Travailler avec différents fuseaux horaires dans Go
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 package de temps 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 package time fournit un type de structure Time contenant le champ d’emplacement que vous pouvez utiliser pour définir les fuseaux horaires.
Vous pouvez importer le package horaire avec une instruction d’importation.
import "time"
Voici le type de structure time et ses champs. Les champs ne sont pas exportés, ils sont donc absents de la documentation officielle.
package main
type Time struct {
// wall is the wall time in the format returned by the runtime.nanotime()
// function.
wall uint64
// ext is the monotonic clock reading in the format returned by
// runtime.nanotime().
ext int64
// loc is a pointer to the Location struct associated with this time.
loc *Location
}
type Location struct {
// name is the time zone name, such as "UTC"or "PST".
name string
// zone contains information about the time zone abbreviation, offset,
// and rule for a single time zone in the location.
zone []zone
// tx contains information about when the time zone abbreviation or
// offset changes for a location.
tx []zoneTrans
// extend contains the name of a parent time zone if this location
// extends from another one.
extend string
// cacheStart and cacheEnd are Unix timestamps that deine the range
// for which the cacheZone field is valid.
cacheStart int64
cacheEnd int64
// cacheZone points to the zone that is currently valid for the time
// range defined by cacheStart and cacheEnd.
cacheZone *zone
}
De nombreuses méthodes utilisent les structures Time et Location , 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. La méthode LoadLocation fournit des fonctionnalités pour charger les informations de fuseau horaire à partir de la base de données des fuseaux horaires IANA . La méthode LoadLocation 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 une instance de structure d’heure associée au fuseau horaire .
import (
"fmt"
"time"
)
func main() {
// Load the time zone location for America/New_York
loc, err: = time.LoadLocation("America/New_York")
if err! = nil {
fmt.Println("Error loading location:", err)
return
}
// Get the current time at a location
now: = time.Now().In(loc)
fmt.Println("Current time in New York:", now)
}
La méthode In de la fonction Now prend un emplacement et y imprime l’heure :
De plus, vous pouvez utiliser la méthode FixedZone pour charger l’heure actuelle dans 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 l’emplacement en fonction de la chaîne et du décalage avant de transmettre l’emplacement à la méthode In de l’instance de temps.
import (
"fmt"
"time"
)
func main() {
// Get the current time in UTC
now: = time.Now().UTC()
// Set the time zone for Lagos
lagos: = now.In(time.FixedZone("WAT", 3600))
// Print the current time in both locations
fmt.Println("Current time in Lagos:", lagos)
}
La fonction principale imprime l’heure actuelle à Lagos sur la console.
Mesure de la durée du fuseau horaire
Le package time fournit la méthode Zone pour récupérer l’abréviation et le décalage du fuseau horaire associé à une valeur time.Time . 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.
import (
"fmt"
"time"
)
func main() {
// Load the time zone location for America/New_York
loc, err: = time.LoadLocation("America/New_York")
if err! = nil {
fmt.Println("Error loading location:", err)
return
}
// Get the current time in UTC and the specified location
t1: = time.Now()
t2: = t1.In(loc)
// Get the offset in seconds for each time zone
//for the time zones
_, offset1: = t1.Zone()
_, offset2: = t2.Zone()
// Calculate the duration of the time zone shift
// between UTC and America/New_York
duration: = offset2 - offset1
fmt.Printf("The time zone shift duration" +
"between UTC and New York is: %d seconds", duration)
}
Dans la fonction principale, la méthode Zone mesure la durée du décalage horaire entre deux fuseaux horaires (valeurs time.Time). La variable t1 est l’heure actuelle en UTC et la variable t2 est l’heure actuelle dans le fuseau horaire « Amérique/New_York ».
La fonction imprime la variable de durée (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 la méthode Add de la méthode In de votre instance de structure time.Time pour ajouter une durée à l’heure dans un fuseau horaire.
import (
"log"
"time" // import the time package
)
func evaluateTime(t time.Time, duration time.Duration) time.Time {
// load the location for Africa/Lagos
location, err: = time.LoadLocation("Africa/Lagos")
if err! = nil {
log.Println("There was an error loading the location")
}
return t.In(location).Add(duration)
}
La fonction évalueTime prend une instance time.Time et une durée de type time.Duration , 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.
Laisser un commentaire