Golang convertir l'horodatage

Les horodatages sont un moyen pour les ordinateurs de traiter le temps, en utilisant généralement des nombres entiers pour représenter le nombre de secondes d'un instant à un autre (généralement le 1er janvier 1970 00:00:00 UTC). Dans le langage Go, la conversion des horodatages est très simple. Cet article présentera quelques méthodes et techniques associées.

1. Utilisez la fonction time.Unix() pour convertir l'horodatage en valeur temporelle

time.Unix() La fonction accepte deux paramètres, l'un est le L'horodatage Unix et l'autre est le décalage en nanosecondes. Il renvoie une valeur correspondante de type Time. Par exemple :

package main

import (
    "fmt"
    "time"
)

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

Le code ci-dessus convertit l'horodatage 1609459200 en la valeur temporelle correspondante : 2021-01-01 00:00:00 +0000 UTC code>. Le deuxième paramètre est le décalage en nanosecondes. Si vous n'en avez pas besoin, vous pouvez passer 0. <code>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

Utilisez la fonction time.UnixNano() pour convertir l'horodatage en nanosecondes

time.UnixNano() la fonction accepte un horodatage Unix , renvoyant son nombre correspondant de nanosecondes. Par exemple :

rrreee#🎜🎜#Le code ci-dessus convertit l'horodatage 1609459200 en nombre de nanosecondes correspondant : 1609459200000000000. #🎜🎜#
#🎜🎜#Utilisez la méthode time.Since() pour convertir l'horodatage en durée #🎜🎜##🎜🎜##🎜🎜#time.Since() La méthode accepte une valeur temporelle et renvoie la durée entre l'heure actuelle et cette valeur temporelle. Par conséquent, nous pouvons convertir l’horodatage en valeur temporelle, puis utiliser la méthode time.Since() pour calculer la durée correspondante. Par exemple : #🎜🎜#rrreee#🎜🎜#Le code ci-dessus convertit l'horodatage 1609459200 en la valeur temporelle correspondante, puis calcule sa durée avec l'heure actuelle : 73.141589mscode>. #🎜🎜#
#🎜🎜#Utilisez la méthode time.Now().Unix() pour obtenir l'horodatage de l'heure actuelle #🎜🎜##🎜🎜##🎜🎜#Nous pouvons utiliser l'heure. La méthode Now().Unix() obtient l'horodatage de l'heure actuelle et renvoie une valeur de type int64. Par exemple : #🎜🎜#rrreee#🎜🎜#Le code ci-dessus obtient l'horodatage de l'heure actuelle et l'imprime. Vous pouvez voir que la sortie d'horodatage est une valeur entière de l'heure actuelle. #🎜🎜#
#🎜🎜#Utilisez la méthode time.Parse() pour convertir une chaîne en valeur temporelle#🎜🎜##🎜🎜##🎜🎜#méthode time.Parse() accepte deux Il y a deux paramètres, l'un est la chaîne de format d'heure et l'autre est la chaîne d'heure qui doit être convertie. Il renvoie une valeur correspondante de type Time. Par exemple : #🎜🎜#rrreee#🎜🎜#Le code ci-dessus convertit la chaîne "2021-01-01 00:00:00" en la valeur temporelle correspondante : 2021-01- 01 00:00:00 +0000 UTC. Parmi eux, le paramètre layout est une chaîne de format d'heure, et la séquence temporelle spécifiée Mon Jan 2 15:04:05 MST 2006 doit être utilisée pour représenter chaque partie du time. En effet, go Le paquet d'heure adopte cette séquence, et son heure initiale est exactement l'heure correspondant à l'horodatage Unix 0. #🎜🎜##🎜🎜#Résumé#🎜🎜##🎜🎜#Cet article présente les méthodes et techniques de conversion des horodatages en valeurs de temps, nanosecondes, durée, etc. dans le langage go. Ces méthodes sont très utiles lorsque vous devez gérer le temps en langage Go. Bien entendu, en fonction de votre scénario d'application spécifique, vous pouvez choisir une ou plusieurs de ces méthodes pour la conversion et le traitement de l'horodatage. #🎜🎜#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!