Durée du temps de Golang

Le temps est un facteur très important pour les programmeurs. Non seulement il permet de déterminer comment et quand une action est exécutée, mais cela nous permet de régir la durée d'une opération et même de conserver les journaux de diverses activités du programme.

Go nous fournit le package d'heure pour gérer l'heure et la date liées. Dans cet article, nous couvrirons comment mesurer le temps écoulé entre deux instances.

Temps.Durée

La durée se réfère au temps écoulé entre deux fois comme un nombre de nanosecondes INT64. Si nous définissons la durée sur 1000000000 nanosecondes, cela représente 1 seconde ou 1000 millisecondes. La durée maximale que nous pouvons représenter (pour INT64) est de 290 ans.

La définition de syntaxe suivante pour la durée dans le package de temps.

Type Durée Int64

Les durées définies dans le package de temps comprennent:

const (
Durée nanoseconde = 1
Microseconde = 1000 * nanoseconde
Millisecondes = 1000 * microseconde
Deuxième = 1000 * millisecondes
Minute = 60 * seconde
Heure = 60 * minute
)

Notez que les valeurs ci-dessus sont des constantes.

Dans le package de temps, nous pouvons utiliser la fonction suivante pour retourner une durée:

Temps.Sous()

La syntaxe de fonction est comme indiqué:

Func (T Time) Sub (U Time) durée

Renvoie la durée T-U.

Temps.Depuis()

La syntaxe de la méthode ensure () est comme indiqué:

func depuis (t heures)

Cette fonction renvoie la durée passée depuis t.

Temps.Jusqu'à()

La syntaxe est comme indiqué:

Func jusqu'à (T temps) durée

retourner la durée jusqu'à t. Considérez-le comme un raccourci pour le temps.Sub (temps.Maintenant()).

Temps.Durée

Cette fonction renvoie la durée en nanosecondes. La syntaxe est comme indiqué:

func (D durée) millisecondes () int64

Exemple

Le code suivant illustre comment calculer la durée.

package principal
importer (
"FMT"
"temps"
)
func main ()
// définir la durée
Temps de durée VAR.Durée = 1000000000
// en heures
fmt.Println (durée.Heures())
// minutes
fmt.Println (durée.Minutes())
// secondes
fmt.Println (durée.Secondes ())
// millisecondes
fmt.Println (durée.Millisecondes ())
// microsecondes
fmt.Println (durée.Microsecondes ())
// Utilisation de la sous-méthode
Maintenant: = temps.Maintenant()
temps.Sommeil (1000)
diff: = maintenant.Sub (temps.Maintenant())
fmt.Println ("Elapsed Seconds:", Diff.Secondes ())

Dans la première section du programme, nous créons une durée et la fixons sur 1000000000 nanosecondes. Nous utilisons ensuite les méthodes du package temporel pour la convertir en différents formats.

Dans la deuxième section, nous utilisons la méthode Sub () pour calculer le décalage horaire après une opération de sommeil.

Le code ci-dessus doit retourner:

$ Go Run Durée.aller
0.000277777777777778
0.016666666666666666
1
1000
1000000
Deux secondes écoulées: -0.0072517

Conclusion

Cet article vous guide à travailler avec des durées dans la langue go, comme indiqué par le package. Pour plus d'informations, considérez la documentation.