Comment implémenter efficacement la conversion du temps dans Golang

Golang est un langage de programmation relativement jeune, mais grâce à son efficacité opérationnelle extrêmement élevée et à ses fortes capacités de traitement simultané, il est de plus en plus favorisé par les développeurs. Dans le développement réel, nous devons souvent convertir le temps en chaînes dans différents formats, ou convertir des chaînes en temps. Dans cet article, nous expliquerons comment implémenter efficacement la conversion du temps dans Golang.

1. Type d'heure

Dans Golang, il existe deux types d'heure principaux : time.Time et time.Duration. Parmi eux, time.Time représente un point temporel, qui peut être utilisé pour représenter une heure spécifique, comme 12 heures le 1er juillet 2021, et time.Duration représente une période de temps, qui peut être utilisée pour représenter l'heure. intervalle entre un certain moment, par exemple 10 secondes, 5 minutes, etc.

2. Sortie formatée de time

Si vous devez convertir une heure de type time.Time en chaîne, vous pouvez utiliser la méthode Format() dans le type time.Time. La méthode Format() reçoit une présentation de format d'heure comme paramètre d'entrée, puis formate l'heure dans une chaîne correspondante.

Ce qui suit est un exemple de code :

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Now()
    fmt.Println(t.Format("2006-01-02 15:04:05"))
}

Résultat d'exécution :

2021-07-01 12:00:00

Dans la chaîne de format, différents caractères représentent différentes significations, comme indiqué dans le tableau suivant :

03 (horloge 12 heures) 04minutes05secondes.000millisecondesPMAM ou PM (format 12 heures)Lundi Jour de la semaine (nom complet, tel que Lundi) LunJour de la semaine (nom complet, tel que Mon) JanMois (nom complet, tel que Janvier ), vous pouvez également personnaliser la chaîne de format, par exemple : String to time typeSi vous devez convertir une chaîne en une heure de type time.Time, vous pouvez utiliser la méthode time.Parse(). La méthode Parse() reçoit deux paramètres, le premier paramètre est la chaîne d'heure et le deuxième paramètre est la disposition du format d'heure. Par exemple : Dans le code ci-dessus, nous avons converti la chaîne en une variable t de type time.Time et déterminé les erreurs dans le processus de conversion dans le code pour garantir la robustesse du programme. En Golang, on peut directement utiliser la soustraction pour calculer la différence de temps, par exemple :

package main

import (
    "fmt"
    "time"
)

func main() {
    t1 := time.Date(2021, 7, 1, 12, 0, 0, 0, time.Local)
    t2 := time.Date(2021, 7, 1, 12, 1, 0, 0, time.Local)
    duration := t2.Sub(t1)
    fmt.Println(duration)
}

Dans le code ci-dessus, on utilise la fonction time.Date() pour créer Deux fois t1 et t2, calculez leur différence de temps et enregistrez le résultat dans une durée variable de type time.Duration.

Caractères de format	Significations
2006	année (l'année utilisée dans l'exemple)
01	mois
02	jour
15	heure (horloge 24 heures)
	t := time.Now() fmt.Println(t.Format("2006年01月02日 15:04:05.000 PM MST"))
	package main import (     "fmt"     "time" ) func main() {     str := "2021-07-01 12:00:00"     layout := "2006-01-02 15:04:05"     t, err := time.Parse(layout, str)     if err != nil {         fmt.Println(err)     }     fmt.Println(t) }
Calculer la différence de temps

Convertir l'horodatage en type time.Time

3. Dans les programmes, les horodatages sont parfois utilisés pour représenter l'heure. Dans Golang, vous pouvez utiliser la méthode time.Unix() pour convertir les horodatages en time.Time de type. Par exemple :

package main

import (
    "fmt"
    "time"
)

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

Résultat d'exécution :

2021-07-01 13:00:00 +0800 CST

Dans le code ci-dessus, nous convertissons un horodatage 1625133600 (qui représente 13h00 le 1er juillet 2021, heure de Pékin) en un horodatage en utilisant la méthode time.Unix() Time t de type time.Time.

4. Remarques sur les opérations temporelles

Dans le processus d'utilisation de Golang pour les opérations temporelles, vous devez faire attention aux points suivants :

1) Lorsque vous utilisez la méthode time.Parse() pour convertir une chaîne en heure de type time.Time Ce faisant, vous devez vous assurer que la chaîne d'heure correspond au format de la disposition du format d'heure, sinon une erreur se produira.

2) Lorsque nous devons effectuer une conversion de fuseau horaire lors du traitement du temps, nous devons utiliser les deux variables time.UTC() et time.Local time.UTC() représente le temps universel coordonné et time.Local représente l'emplacement de. le fuseau horaire actuel.
5. 3) Lors du traitement du temps, si vous avez besoin d'obtenir les parties distinctes du temps telles que l'année, le mois, le jour, l'heure, la minute et la seconde, vous pouvez utiliser Année(), Mois(), Jour(), Heure. (), Minute (dans le type time.Time), Second () et d'autres méthodes.

4) Lorsque vous utilisez une variable de type time.Duration pour représenter un intervalle de temps, vous pouvez utiliser la méthode time.ParseDuration() pour convertir l'intervalle de temps de type chaîne en une variable de type time.Duration et contrôler la précision.

En bref, lorsque vous utilisez Golang pour traiter le temps, vous devez faire attention aux détails pour garantir l'exactitude de l'heure et la robustesse du programme.

Résumé

6. Dans cet article, nous avons expliqué comment effectuer des opérations de conversion d'heure dans Golang, y compris une sortie au format temporel, la conversion de chaînes en type d'heure, le calcul de la différence de temps et la conversion des horodatages en heure. d'autres aspects de la connaissance. En maîtrisant ces connaissances, nous pouvons nous aider à gérer plus efficacement les problèmes liés au temps et à améliorer le caractère pratique et la fiabilité du programme.

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!