Golang-Zeitumrechnung

Golang ist eine effiziente und prägnante Programmiersprache, die in verschiedenen Bereichen weit verbreitet ist. In der Entwicklung müssen wir häufig die Zeit konvertieren, z. B. die Konvertierung von Zeichenfolgen in Zeit, die Konvertierung von Zeit in Zeichenfolgen usw., und die unterschiedlichen Zeitformate verursachen auch bestimmte Probleme. Daher wird in diesem Artikel die Zeitumrechnungsoperation in Golang vorgestellt und ihre spezifische Verwendung anhand von Beispielen erläutert.

1. String in Zeit umwandeln

In Golang können wir die Parse-Funktion im Zeitpaket verwenden, um einen String in Zeit umzuwandeln. Die spezifische Definition der Parse-Funktion lautet wie folgt:

func Parse(layout, value string) (Time, error)

wobei Layout das Zeitformat der zu konvertierenden Zeichenfolge und value die zu konvertierende Zeichenfolge darstellt. Diese beiden Parameter können die vordefinierten Konstanten im Zeitpaket verwenden. Die spezifischen Konstanten und ihre Bedeutung lauten wie folgt: 05 2006 „

UnixDate“Mon Jan _2 15:04:05 MST 2006“RFC3339“2006-01-02T15:04:05Z07:00“Zum Beispiel, Ändern Sie die Zeichenfolge. Der Beispielcode zum Konvertieren von „2022/04/12 15:20:00“ in die Zeit lautet wie folgt:

timeStr := "2022/04/12 15:20:00"
layout := "2006/01/02 15:04:05"
t, err := time.Parse(layout, timeStr)
if err != nil {
    fmt.Println("转化失败：", err)
} else {
    fmt.Println("转化成功：", t)
}

转化成功： 2022-04-12 15:20:00 +0000 UTC

In ähnlicher Weise können wir in Golang die Funktion Format verwenden, um die Zeit in einen String umzuwandeln. Die spezifische Definition dieser Funktion lautet wie folgt: Zum Beispiel lautet der Beispielcode zum Konvertieren der Zeit in eine Zeichenfolge im Format „2022/04/12 15:20:00“ wie folgt:

t := time.Now()
layout := "2006/01/02 15:04:05"
timeStr := t.Format(layout)
fmt.Println("转化后时间字符串：", timeStr)

Unter diesen ist timeStr die zu konvertierende Zeichenfolge und Layout das Zeitformat der Zeichenfolge ( „2006/01/02 15:04:05“ steht für Jahr, Monat, Tag, Stunde, Minute und Sekunde), t ist das nach der Konvertierung erhaltene Zeitobjekt und err ist die Fehlermeldung während des Konvertierungsprozesses. Wenn Sie den obigen Code ausführen, lautet das Ausgabeergebnis wie folgt:	2. Konvertieren Sie die Zeit in einen String.
func (t Zeit) Formatierungszeichenfolge (Layoutzeichenfolge)	Unter diesen ist t das zu konvertierende Zeitobjekt und Layout stellt die formatierte Zeitzeichenfolge dar. Seine Verwendung ähnelt auch der oben vorgestellten Parse-Funktion.

wobei t die aktuelle Zeit und Layout das Format ist konvertierte Zeit („2006/01/02 15:04:05“ steht für Jahr, Monat, Tag, Stunde, Minute und Sekunde) und timeStr ist die konvertierte Zeitzeichenfolge. Führen Sie den obigen Code aus und das Ausgabeergebnis lautet wie folgt:

转化后时间字符串： 2022/04/12 15:20:00

3. Zeitzonenkonvertierung

In Golang kann die Zeitzonendarstellung der Zeit mithilfe der Standortfunktion im Zeitpaket abgerufen werden. Seine Definition lautet wie folgt:

func LoadLocation(name string) (*Location, error)

Wobei name den Zeitzonennamen darstellt (z. B. „Asien/Shanghai“).

Beim Konvertieren der Ortszeit in UTC-Zeit können Sie beispielsweise die UTC-Funktion im Zeitpaket verwenden. Der Beispielcode lautet wie folgt:

t := time.Now()
utc := t.UTC()
fmt.Println("本地时间：", t)
fmt.Println("UTC时间：", utc)

wobei t die Ortszeit und utc die konvertierte UTC-Zeit ist. Führen Sie den obigen Code aus und das Ausgabeergebnis lautet wie folgt:

本地时间： 2022-10-07 15:24:56.200122 +0800 CST m=+0.000498761
UTC时间： 2022-10-07 07:24:56.200122 +0000 UTC

4. Zeitaddition und -subtraktion

In Golang können Zeitaddition und -subtraktion mit der Add-Funktion und der Sub-Funktion durchgeführt werden. Seine spezifische Definition lautet wie folgt:

func (t Time) Add(d Duration) Time

func (t Time) Sub(u Time) Duration

Unter diesen fügt die Add-Funktion die Zeit t zu einem Duration-Objekt d hinzu und gibt zurück das neue Zeitobjekt; die Sub-Funktion subtrahiert ein weiteres Zeitobjekt u von der Zeit t und gibt ein Duration-Objekt zurück.

Der Beispielcode zum Hinzufügen von 10 Minuten zur vorhandenen Zeit lautet beispielsweise wie folgt:

t := time.Now()
d := 10 * time.Minute
newTime := t.Add(d)
fmt.Println("原时间：", t)
fmt.Println("加10分钟后的时间：", newTime)

wobei t die vorhandene Zeit, d das hinzuzufügende Zeitintervall (10 Minuten) und newTime die neue erhaltene Zeit ist nach Zugabe. Führen Sie den obigen Code aus und das Ausgabeergebnis lautet wie folgt:

原时间： 2022-10-07 15:35:26.924559 +0800 CST m=+0.000213898
加10分钟后的时间： 2022-10-07 15:45:26.924559 +0800 CST

5. So optimieren Sie die Zeitkonvertierungseffizienz

In der tatsächlichen Entwicklung haben wir möglicherweise einen großen Zeitkonvertierungsbedarf, und die Verwendung von Golangs eigenem Zeitpaket für die Konvertierung wird dies erheblich tun die Programmeffizienz verringern. Derzeit können wir zur Optimierung Bibliotheken von Drittanbietern verwenden.

Zu den derzeit beliebtesten Zeitumrechnungsbibliotheken gehören:

Die Zeitumrechnungskomponente in der Gorm-Bibliothek

Rob Pikes Open-Source-Zeitbibliothek

Bjoernus Open-Source-TimeUtils-Bibliothek

Diese Bibliotheken von Drittanbietern können die Zeit erheblich verbessern Konvertierungseffizienz und löst auch die Probleme, die durch unterschiedliche Zeitlayouts auf verschiedenen Systemen verursacht werden.

Zusammenfassung

In diesem Artikel wird der Vorgang der Zeitkonvertierung in Golang vorgestellt, einschließlich der Konvertierung von Zeichenfolgen in Zeit, der Konvertierung von Zeit in Zeichenfolgen, der Zeitzonenkonvertierung sowie der Zeitaddition und -subtraktion. Gleichzeitig werden einige gängige Zeitkonvertierungsbibliotheken bereitgestellt, um die Effizienz der Zeitkonvertierung zu optimieren. Ich hoffe, dass dieser Artikel Golang-Entwicklern bei der Zeitkonvertierung helfen kann.

Das obige ist der detaillierte Inhalt vonGolang-Zeitumrechnung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!