Les fuseaux horaires sont cruciaux pour toute application qui traite des dates et des heures. Bien sûr, c’est particulièrement vrai pour les applications qui servent des utilisateurs sur plusieurs continents et dans plusieurs endroits. Les fuseaux horaires déterminent le décalage par rapport au temps universel coordonné (UTC) pour des lieux spécifiques dans le monde. Ils jouent un rôle essentiel pour garantir un traitement précis et fiable de l’heure.
Go fournit le paquetage time dans sa bibliothèque standard pour travailler avec le temps et les fuseaux horaires. Vous pouvez récupérer et convertir les fuseaux horaires à différents endroits en utilisant le paquetage time.
Le paquetage Time
Le site temps fournit des fonctionnalités permettant de travailler avec des heures et des dates, de mesurer et d’afficher le temps, et de manipuler des dates en utilisant un calendrier grégorien sans secondes intercalaires.
Le paquetage temps fournit une Temps Type de structure contenant le champ de localisation que vous pouvez utiliser pour définir les fuseaux horaires.
Vous pouvez importer le paquetage horaire avec une instruction d’importation.
import "time"
Voici le type struct 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 Lieu structs, y compris les méthodes de fuseau horaire.
Chargement des informations sur le fuseau horaire
Le chargement des informations sur les fuseaux horaires est l’une des opérations de base pour travailler avec les fuseaux horaires. Le site LoadLocation La méthode LoadLocation fournit une fonctionnalité permettant de charger des informations sur les fuseaux horaires à partir de la base de données des fuseaux horaires de l’IANA. Le site LoadLocation prend en compte le nom du fuseau horaire et renvoie les informations de localisation ainsi qu’une erreur à traiter. Une fois qu’elle a chargé les informations sur le fuseau horaire, elle crée un objet heure instance de la structure 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)
}
Le site Sur méthode de la Maintenant prend un lieu et imprime l’heure qui y règne :
En outre, vous pouvez utiliser l’option FixedZone pour charger l’heure actuelle dans un lieu si vous connaissez la chaîne du lieu 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 lieu en fonction de la chaîne de caractères et du décalage avant de transmettre le lieu à la méthode In the 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)
}
Le site principal La fonction main imprime l’heure actuelle en Lagos sur la console.
Mesure de la durée des fuseaux horaires
Le paquetage temps fournit le Zone Procédé de récupération de l’abréviation et du décalage du fuseau horaire associé à un système d’exploitation. temps. valeur. La méthode Zone renvoie la chaîne représentant l’abréviation du fuseau horaire (par exemple « EST » pour « America/New_York ») et un nombre 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 entre deux fuseaux horaires (valeurs time.Time). Le site t1 est l’heure actuelle en UTC, et la variable t2 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 du 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 de la méthode In de votre instance de la 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)
}
Le site evaluateTime prend en entrée une instance time.Time et une durée de type time.Durationqui renvoie l’heure dans le fuseau horaire. Il charge l’heure actuelle en « Afrique/Lagos » et ajoute une durée à l’heure.
Manipuler l’heure et la date avec le Time Package
Le paquetage Time est très polyvalent pour travailler avec les heures et les dates. Il fournit des fonctions telles que Unix() pour convertir l’heure en heure Unix, Sleep() pour mettre en pause les goroutines, et Format() pour formater les valeurs de temps en chaîne.