Les fuseaux horaires sont cruciaux pour toute application qui traite des dates et des heures. Bien sûr, cela est particulièrement vrai pour les applications qui servent les utilisateurs à travers les continents et les lieux. Les fuseaux horaires déterminent le décalage par rapport au temps universel coordonné (UTC) pour des emplacements spécifiques dans le monde. Ils jouent un rôle essentiel pour garantir une gestion précise et fiable du temps.
Go fournit le package horaire dans sa bibliothèque standard pour travailler avec l'heure et les fuseaux horaires. Vous pouvez récupérer et convertir des fuseaux horaires à divers endroits à l'aide du package horaire.
Le Forfait Temps
Le temps package fournit des fonctionnalités pour travailler avec les heures et les dates, mesurer et afficher le temps et manipuler les dates à l'aide d'un calendrier grégorien sans secondes intercalaires.
Le forfait temps offre une Tempstype de structure contenant le champ de localisation que vous pouvez utiliser pour définir les fuseaux horaires.
Vous pouvez importer le package horaire avec une instruction d'importation.
importer"temps"
Voici le type de structure time et ses champs. Les champs ne sont pas exportés, ils sont donc absents de la documentation officielle.
emballer principaltaper Temps structure {
// wall est l'heure du mur dans le format renvoyé par le runtime.nanotime()
// fonction.
mur uint64// ext est la lecture d'horloge monotone dans le format renvoyé par
// runtime.nanotime().
poste int64// loc est un pointeur vers la structure Location associée à cette heure.
loc *Emplacement
}taper Emplacement structure {
// name est le nom du fuseau horaire, tel que "UTC" ou "PST".
nom chaîne// zone contient des informations sur l'abréviation du fuseau horaire, le décalage,
// et règle pour un seul fuseau horaire dans l'emplacement.
zone[]zone// tx contient des informations sur le moment où l'abréviation du fuseau horaire ou
// décalage des changements pour un emplacement.
tx []zoneTrans// extend contient le nom d'un fuseau horaire parent si cet emplacement
// s'étend d'un autre.
étendre chaîne// cacheStart et cacheEnd sont des horodatages Unix qui définissent la plage
// pour lequel le champ cacheZone est valide.
cacheStart int64
cacheEnd int64
// cacheZone pointe vers la zone actuellement valide pour l'heure
// plage définie par cacheStart et cacheEnd.
cacheZone *zone
}
De nombreuses méthodes utilisent le temps et Emplacement structures, y compris les méthodes de fuseau horaire.
Chargement des informations de fuseau horaire
Le chargement des informations de fuseau horaire est l'une des opérations de base lorsque vous travaillez avec des fuseaux horaires. Le LoadLocation fournit une fonctionnalité pour charger les informations de fuseau horaire à partir du Base de données des fuseaux horaires de l'IANA. Le LoadLocation La méthode prend le nom du fuseau horaire et renvoie les informations de localisation et une erreur de traitement. Une fois qu'il a chargé les informations de fuseau horaire, il crée un temps instance de structure associée au fuseau horaire.
importer (
"fmt"
"temps"
)fonctionprincipal() {
// Charger l'emplacement du fuseau horaire pour America/New_York
loc, err := temps. ChargerEmplacement("Amérique/New_York")si erreur != néant {
fmt. Imprimerln("Erreur lors du chargement de l'emplacement :", euh)
retour
}
// Obtenir l'heure actuelle à un emplacement
maintenant := temps. Maintenant().Dans (loc)
fmt. Imprimerln("Heure actuelle à New York :", maintenant)
}
Le Dans méthode de la Maintenant la fonction prend un lieu et y imprime l'heure :
De plus, vous pouvez utiliser le ZoneFixe pour charger l'heure actuelle à un emplacement si vous connaissez la chaîne d'emplacement et le décalage du fuseau horaire par rapport à UTC. Tout d'abord, vous devrez charger l'heure actuelle en UTC, puis vous utiliserez la méthode FixedZone pour charger le emplacement basé sur la chaîne et le décalage avant de passer l'emplacement à la méthode de l'heure exemple.
importer (
"fmt"
"temps"
)fonctionprincipal() {
// Obtenir l'heure actuelle en UTC
maintenant := temps. Maintenant().UTC()// Définir le fuseau horaire de Lagos
lagos := maintenant. À l'heure. ZoneFixe("WAT", 3600))
// Affiche l'heure actuelle aux deux endroits
fmt. Imprimerln("Heure actuelle à Lagos :", lagos)
}
Le principal La fonction imprime l'heure actuelle à Lagos sur la console.
Mesure de la durée du fuseau horaire
Le forfait horaire fournit les Zone méthode de récupération de l'abréviation et du décalage du fuseau horaire associé à un temps. Temps valeur. La méthode Zone renvoie la chaîne représentant l'abréviation du fuseau horaire (par exemple "EST" pour "Amérique/New_York") et un entier représentant le nombre de secondes à l'est de l'UTC.
importer (
"fmt"
"temps"
)fonctionprincipal() {
// Charger l'emplacement du fuseau horaire pour America/New_York
loc, err := temps. ChargerEmplacement("Amérique/New_York")si erreur != néant {
fmt. Imprimerln("Erreur lors du chargement de l'emplacement :", euh)
retour
}// Récupère l'heure actuelle en UTC et l'emplacement spécifié
t1 := temps. Maintenant()
t2 := t1.In (loc)// Récupère le décalage en secondes pour chaque fuseau horaire
//pour les fuseaux horaires
_, offset1 := t1.Zone()
_, offset2 := t2.Zone()// Calcule la durée du décalage horaire
// entre UTC et America/New_York
durée := décalage2 - décalage1
fmt. Imprimerf("La durée du changement de fuseau horaire" +
" entre UTC et New York est: %d secondes", durée)
}
Dans la fonction principale, la méthode Zone mesure la durée du décalage horaire entre deux fuseaux horaires (time. valeurs de temps). Le t1 variable est l'heure actuelle en UTC, et la t2 La variable est l'heure actuelle dans le fuseau horaire "America/New_York".
La fonction imprime le durée variable (la différence de décalage entre les fuseaux horaires) représentant le décalage de fuseau horaire en secondes.
Évaluation du temps entre les fuseaux horaires
Vous pouvez évaluer le temps entre les fuseaux horaires si vous connaissez la durée entre les fuseaux horaires. Vous pouvez utiliser le Ajouter méthode de la méthode In de votre temps. Instance de structure de temps pour ajouter une durée à l'heure dans un fuseau horaire.
importer (
"enregistrer"
"temps"// importe le package horaire
)fonctionévaluerTemps(t fois. Temps, durée temps. Durée)temps.Temps {
// charge l'emplacement pour l'Afrique/Lagos
emplacement, euh := heure. ChargerEmplacement("Afrique/Lagos")
si erreur != néant {
enregistrer. Imprimerln("Une erreur s'est produite lors du chargement de l'emplacement")
}
retour t. Dans (lieu).Ajouter (durée)
}
Le évaluerTemps la fonction prend du temps. Instance de temps et une durée de type temps. Durée, renvoyant l'heure dans le fuseau horaire. Il charge l'heure actuelle dans "Africa/Lagos" et ajoute une durée à l'heure.
Manipuler l'heure et la date avec le package Time
Le package de temps est très polyvalent pour travailler avec les heures et les dates. Le package time fournit des fonctions telles qu'Unix() pour convertir l'heure en heure Unix, Sleep() pour mettre en pause les goroutines et Format() pour formater les valeurs d'heure en chaîne.
