Durata del tempo di Golang

Il tempo è un fattore molto importante per i programmatori. Non solo consente di determinare come e quando viene eseguita un'azione, ci consente di governare per quanto tempo impiega un'operazione e persino conservare i registri di varie attività nel programma.

Go ci fornisce il pacchetto Time per gestire l'ora e la data correlata. In questo articolo, tratteremo come misurare il tempo trascorso tra due volte istanze.

Tempo.Durata

La durata si riferisce al tempo trascorso tra due volte oggetti come un numero di nanosecondi INT64. Se impostiamo la durata su 1000000000 nanosecondi, questo rappresenta 1 secondo o 1000 millisecondi. La durata massima che possiamo rappresentare (per int64) è di 290 anni.

Quanto segue la definizione di sintassi per la durata nel pacchetto temporale.

Durata del tipo int64

Le durate definite nel pacchetto Time includono:

const (
Durata del nanosecondo = 1
Microsecondo = 1000 * nanosecondi
Millisecondi = 1000 * microsecondo
Secondo = 1000 * millisecondi
Minuto = 60 * secondo
Ora = 60 * minuto
)

Si noti che i valori di cui sopra sono costanti.

Nel pacchetto Time, possiamo utilizzare la seguente funzione per restituire una durata:

Tempo.Sub()

La sintassi della funzione è come mostrata:

Func (t time) sub (tempo u) durata

restituisce la durata t-u.

Tempo.Da()

La sintassi per il metodo da At () è come mostrato:

Func da (t ora)

Questa funzione restituisce la durata passata da T.

Tempo.Fino a()

La sintassi è come mostrata:

func fino alla durata (tempo t)

restituire la durata fino a t. Pensalo come una scorciatoia per il tempo.Sub (tempo.Ora()).

Tempo.Durata

Questa funzione restituisce la durata in nanosecondi. La sintassi è come mostrata:

Func (Durata D) millisecondi () int64

Esempio

Il seguente codice illustra come calcolare la durata.

Pacchetto principale
importazione (
"FMT"
"tempo"
)
func main ()
// Imposta durata
tempo di durata var.Durata = 1000000000
// in ore
fmt.Println (durata.Ore())
// minuti
fmt.Println (durata.Minuti())
// secondi
fmt.Println (durata.Secondi ())
// millisecondi
fmt.Println (durata.Millisecondi ())
// microsecondi
fmt.Println (durata.Microseconds ())
// usando il metodo sub
ora: = tempo.Ora()
tempo.Sonno (1000)
diff: = ora.Sub (tempo.Ora())
fmt.Println ("Secondi trasmessi:", Diff.Secondi ())

Nella prima sezione del programma, creiamo una durata e la impostiamo su 1000000000 nanosecondi. Quindi utilizziamo i metodi dal pacchetto Time per convertirlo in vari formati.

Nella seconda sezione, utilizziamo il metodo sub () per calcolare la differenza di tempo dopo un'operazione di sonno.

Il codice sopra dovrebbe restituire:

$ go run durata.andare
0.000277777777777778
0.01666666666666666
1
1000
1000000
Secondi trascorsi: -0.0072517

Conclusione

Questo articolo ti guida a lavorare con le durate nel linguaggio Go come fornito dal pacchetto Time. Per ulteriori informazioni, considerare la documentazione.