Arbeiten mit verschiedenen Zeitzonen in Go
Zeitzonen sind entscheidend für jede Anwendung, die mit Daten und Uhrzeiten zu tun hat. Dies gilt natürlich insbesondere für Apps, die Benutzer über Kontinente und Standorte hinweg bedienen. Zeitzonen bestimmen die Abweichung von der koordinierten Weltzeit (UTC) für bestimmte Orte auf der ganzen Welt. Sie spielen eine wichtige Rolle bei der Gewährleistung einer genauen und zuverlässigen Zeiterfassung.
Für die Arbeit mit Zeit und Zeitzonen stellt Go in seiner Standardbibliothek das Zeitpaket zur Verfügung. Mit dem Zeitpaket können Sie Zeitzonen an verschiedenen Orten abrufen und umrechnen.
Das Zeitpaket
Das Zeitpaket bietet Funktionen zum Arbeiten mit Uhrzeiten und Datumsangaben, zum Messen und Anzeigen von Zeiten und zum Bearbeiten von Datumsangaben mithilfe eines gregorianischen Kalenders ohne Schaltsekunden.
Das Zeitpaket stellt einen Zeitstrukturtyp bereit , der das Standortfeld enthält, das Sie zum Festlegen von Zeitzonen verwenden können.
Sie können das Zeitpaket mit einer Importanweisung importieren.
import "time"
Hier ist der Zeitstrukturtyp und seine Felder. Die Felder sind nicht exportiert, daher fehlen sie in der offiziellen Dokumentation.
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
}
Viele Methoden verwenden die Time- und Location -Strukturen, einschließlich der Zeitzonenmethoden.
Zeitzoneninformationen werden geladen
Das Laden von Zeitzoneninformationen ist eine der grundlegenden Operationen bei der Arbeit mit Zeitzonen. Die LoadLocation- Methode bietet Funktionen zum Laden von Zeitzoneninformationen aus der IANA-Zeitzonendatenbank . Die LoadLocation- Methode übernimmt den Namen der Zeitzone und gibt die Standortinformationen und einen Behandlungsfehler zurück. Sobald es die Zeitzoneninformationen geladen hat, erstellt es eine Zeitstrukturinstanz , die der Zeitzone zugeordnet ist.
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)
}
Die In -Methode der Now- Funktion übernimmt einen Ort und gibt dort die Zeit aus:
Darüber hinaus können Sie die FixedZone- Methode verwenden, um die aktuelle Uhrzeit an einem Standort zu laden, wenn Sie die Standortzeichenfolge und den Offset der Zeitzone von UTC kennen. Zuerst müssen Sie die aktuelle Zeit in UTC laden, und dann verwenden Sie die FixedZone-Methode, um den Standort basierend auf der Zeichenfolge und dem Offset zu laden, bevor Sie den Standort an die Methode In der Zeitinstanz übergeben.
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)
}
Die Hauptfunktion gibt die aktuelle Zeit in Lagos auf der Konsole aus.
Zeitzonendauer messen
Das time-Paket stellt die Zone- Methode zum Abrufen der Abkürzung und des Offsets der Zeitzone bereit, die einem time.Time- Wert zugeordnet ist. Die Zone-Methode gibt die Zeichenfolge zurück, die die Abkürzung der Zeitzone darstellt (z. B. „EST“ für „Amerika/New_York“), und eine Ganzzahl, die die Anzahl der Sekunden östlich der UTC darstellt.
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)
}
In der main-Funktion misst die Zone-Methode die Dauer der Zeitzonenverschiebung zwischen zwei Zeitzonen (time.Time-Werte). Die Variable t1 ist die aktuelle Uhrzeit in UTC und die Variable t2 die aktuelle Uhrzeit in der Zeitzone „America/New_York“.
Die Funktion druckt die Dauervariable (die Differenz im Versatz zwischen den Zeitzonen), die die Zeitzonenverschiebung in Sekunden darstellt.
Auswertung der Zeit zwischen Zeitzonen
Sie können die Zeit zwischen Zeitzonen auswerten, wenn Sie die Dauer zwischen den Zeitzonen kennen. Sie können die Add -Methode der In-Methode Ihrer time.Time-Strukturinstanz verwenden, um der Zeit in einer Zeitzone eine Dauer hinzuzufügen.
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)
}
Die Funktion „ evaluateTime “ übernimmt eine time.Time-Instanz und eine Dauer vom Typ time.Duration und gibt die Zeit in der Zeitzone zurück. Es lädt die aktuelle Zeit in „Afrika/Lagos“ und fügt der Zeit eine Dauer hinzu.
Manipulieren Sie Uhrzeit und Datum mit dem Time-Paket
Das Zeitpaket ist sehr vielseitig, um sowohl mit Zeiten als auch mit Datumsangaben zu arbeiten. Das time-Paket bietet Funktionen wie Unix() zum Konvertieren von Zeit in Unix-Zeit, Sleep() zum Anhalten von Goroutinen und Format() zum Formatieren von Zeitwerten in Strings.
Schreibe einen Kommentar