Golang-Konvertierungszeitstempel

Zeitstempel sind eine Möglichkeit für Computer, Zeit zu verarbeiten. Dabei werden in der Regel ganze Zahlen verwendet, um die Anzahl der Sekunden von einem Zeitpunkt zum anderen darzustellen (normalerweise 1. Januar 1970, 00:00:00 UTC). In der Go-Sprache ist das Konvertieren von Zeitstempeln sehr einfach. In diesem Artikel werden einige verwandte Methoden und Techniken vorgestellt.

1. Verwenden Sie die Funktion time.Unix(), um den Zeitstempel in einen Zeitwert umzuwandeln.

Die Funktion time.Unix() akzeptiert zwei Parameter, einer ist der Unix-Zeitstempel und der andere der Nanosekunden-Offset. Es gibt einen entsprechenden Wert vom Typ Time zurück. Zum Beispiel:

package main

import (
    "fmt"
    "time"
)

func main() {
    unixTimestamp := int64(1609459200)
    t := time.Unix(unixTimestamp, 0)
    fmt.Println(t)
}

Der obige Code wandelt den Zeitstempel 1609459200 in den entsprechenden Zeitwert um: 2021-01-01 00:00:00 +0000 UTC. Der zweite Parameter ist der Nanosekunden-Offset. Wenn Sie ihn nicht benötigen, können Sie 0 übergeben. 1609459200 转换为对应的时间值：2021-01-01 00:00:00 +0000 UTC。其中第二个参数是纳秒偏移量，如果你不需要用到它，可以传入 0。

2. 使用 time.UnixNano() 函数将时间戳转换为纳秒

time.UnixNano() 函数接受一个 Unix 时间戳，返回它对应的纳秒数。例如：

package main

import (
    "fmt"
    "time"
)

func main() {
    unixTimestamp := int64(1609459200)
    nano := time.UnixNano(unixTimestamp)
    fmt.Println(nano)
}

上面的代码将时间戳 1609459200 转换为对应的纳秒数：1609459200000000000。

3. 使用 time.Since() 方法将时间戳转换为 duration（持续时间）

time.Since() 方法接受一个时间值，并返回当前时间与该时间值之间的持续时间。因此，我们可以将时间戳转换为时间值，然后使用 time.Since() 方法来计算其对应的持续时间。例如：

package main

import (
    "fmt"
    "time"
)

func main() {
    unixTimestamp := int64(1609459200)
    t := time.Unix(unixTimestamp, 0)
    duration := time.Since(t)
    fmt.Println(duration)
}

上面的代码将时间戳 1609459200 转换为对应的时间值，然后计算出它与当前时间的持续时间：73.141589ms。

4. 使用 time.Now().Unix() 方法获取当前时间的时间戳

我们可以使用 time.Now().Unix() 方法获取当前时间的时间戳，它返回一个 int64 类型的值。例如：

package main

import (
    "fmt"
    "time"
)

func main() {
    unixTimestamp := time.Now().Unix()
    fmt.Println(unixTimestamp)
}

上面的代码获取当前时间的时间戳，并将其打印出来。你可以看到，输出的时间戳是一个当前时间的整数值。

5. 使用 time.Parse() 方法将字符串转换为时间值

time.Parse() 方法接受两个参数，一个是时间格式字符串，另一个是需要转换的时间字符串。它返回一个对应的 Time 类型的值。例如：

package main

import (
    "fmt"
    "time"
)

func main() {
    layout := "2006-01-02 15:04:05"
    str := "2021-01-01 00:00:00"
    t, err := time.Parse(layout, str)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(t)
}

上面的代码将字符串 "2021-01-01 00:00:00" 转换为对应的时间值：2021-01-01 00:00:00 +0000 UTC。其中，layout 参数是时间格式字符串，必须使用指定时间序列 Mon Jan 2 15:04:05 MST 2006 来表示时间的各个部分，这是因为 go 的时间包采用了该序列，而且其初始时间正好是 Unix 时间戳 0

Verwenden Sie die Funktion time.UnixNano(), um Zeitstempel in Nanosekunden umzuwandeln.

Die Funktion time.UnixNano() akzeptiert einen Unix-Zeitstempel und gibt die entsprechende Anzahl von Nanosekunden zurück. Zum Beispiel:

rrreee🎜Der obige Code wandelt den Zeitstempel 1609459200 in die entsprechende Anzahl von Nanosekunden um: 1609459200000000000. 🎜
🎜Verwenden Sie die Methode time.Since(), um den Zeitstempel in die Dauer umzuwandeln. 🎜🎜🎜Die Methode time.Since() akzeptiert einen Zeitwert und gibt die aktuelle Zeit und den Zeitwert der Zeitdauer zurück . Daher können wir den Zeitstempel in einen Zeitwert umwandeln und dann die Methode time.Since() verwenden, um die entsprechende Dauer zu berechnen. Zum Beispiel: 🎜rrreee🎜Der obige Code wandelt den Zeitstempel 1609459200 in den entsprechenden Zeitwert um und berechnet dann seine Dauer mit der aktuellen Zeit: 73.141589ms. 🎜
🎜Verwenden Sie die Methode time.Now().Unix(), um den Zeitstempel der aktuellen Zeit abzurufen🎜🎜🎜Wir können die Methode time.Now().Unix() verwenden, um die zu erhalten Zeitstempel der aktuellen Zeit. Es wird ein Wert vom Typ int64 zurückgegeben. Zum Beispiel: 🎜rrreee🎜Der obige Code ruft den Zeitstempel der aktuellen Uhrzeit ab und druckt ihn aus. Sie können sehen, dass die Zeitstempelausgabe ein ganzzahliger Wert der aktuellen Zeit ist. 🎜
🎜Verwenden Sie die Methode time.Parse(), um eine Zeichenfolge in einen Zeitwert umzuwandeln🎜🎜🎜Die Methode time.Parse() akzeptiert zwei Parameter, einer ist der Zeitformat-String und der andere der Zeitwert, der konvertiert werden muss. Zeitzeichenfolge. Es gibt einen entsprechenden Wert vom Typ Time zurück. Zum Beispiel: 🎜rrreee🎜Der obige Code wandelt die Zeichenfolge "2021-01-01 00:00:00" in den entsprechenden Zeitwert um: 2021-01-01 00:00:00 +0000 UTC. Unter diesen ist der Parameter layout eine Zeitformatzeichenfolge, und die angegebene Zeitsequenz Mon Jan 2 15:04:05 MST 2006 muss verwendet werden, um jeden Teil davon darzustellen Dies liegt daran, dass das Zeitpaket diese Reihenfolge annimmt und seine Anfangszeit genau der Zeit entspricht, die dem Unix-Zeitstempel 0 entspricht. 🎜🎜Zusammenfassung🎜🎜In diesem Artikel werden Methoden und Techniken zum Konvertieren von Zeitstempeln in Zeitwerte, Nanosekunden, Dauer usw. in der Go-Sprache vorgestellt. Diese Methoden sind sehr nützlich, wenn Sie in der Go-Sprache mit der Zeit umgehen müssen. Abhängig von Ihrem spezifischen Anwendungsszenario können Sie natürlich eine oder mehrere dieser Methoden zur Zeitstempelkonvertierung und -verarbeitung auswählen. 🎜

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