Golang tidsvarighet

Tid er en veldig viktig faktor for programmerere. Ikke bare tillater det å bestemme hvordan og når en handling utføres, lar det oss styre hvor lang tid en operasjon tar og til og med holde logger over forskjellige aktiviteter i programmet.

Go gir oss tidspakken for å håndtere tid og dato relatert. I denne artikkelen vil vi dekke hvordan vi må måle tiden som går mellom to ganger forekomster.

Tid.Varighet

Varighet refererer til tiden som går mellom to ganger objekter som en INT64 nanosekundtelling. Hvis vi setter varigheten til 1000000000 nanosekunder, representerer dette 1 sekund eller 1000 millisekunder. Den maksimale varigheten vi kan representere (for int64) er 290 år.

Følgende syntaksdefinisjon for varigheten i tidspakken.

Type varighet Int64

Varighetene som er definert i tidspakken inkluderer:

const (
Nanosekund varighet = 1
Mikrosekund = 1000 * nanosekund
Millisekund = 1000 * mikrosekund
Andre = 1000 * millisekunder
Minutt = 60 * sekund
Time = 60 * minutt
)

Merk at verdiene ovenfor er konstanter.

I tidspakken kan vi bruke følgende funksjon til å returnere en varighet:

Tid.Under()

Funksjonssyntaksen er som vist:

func (t time) sub (u tid) varighet

Returnerer varigheten T-U.

Tid.Siden()

Syntaks for siden () -metoden er som vist:

func siden (t tid)

Denne funksjonen returnerer varigheten passert siden t.

Tid.Før()

Syntaksen er som vist:

func til (t tid) varighet

returner varigheten til t. Tenk på det som en korthet for tid.Sub (tid.Nå()).

Tid.Varighet

Denne funksjonen returnerer varigheten i nanosekunder. Syntaksen er som vist:

func (d varighet) millisekunder () int64

Eksempel

Følgende kode illustrerer hvordan du beregner varigheten.

pakkehoved
import (
"FMT"
"tid"
)
func main ()
// Sett varighet
var varighetstid.Varighet = 1000000000
// i timer
fmt.Println (varighet.Timer ())
// minutter
fmt.Println (varighet.Minutter())
// sekunder
fmt.Println (varighet.Sekunder ())
// millisekunder
fmt.Println (varighet.Millisekunder ())
// mikrosekunder
fmt.Println (varighet.Mikrosekunder ())
// ved hjelp av undermetode
Nå: = tid.Nå()
tid.Søvn (1000)
Diff: = nå.Sub (tid.Nå())
fmt.Println ("Gledet sekunder:", Diff.Sekunder ())

I den første delen av programmet lager vi en varighet og setter den til 1000000000 nanosekunder. Vi bruker deretter metodene fra tidspakken for å konvertere den til forskjellige formater.

I den andre delen bruker vi Sub () -metoden for å beregne tidsforskjellen etter en søvnoperasjon.

Koden over skal returnere:

$ gå løp varighet.gå
0.00027777777777777778
0.016666666666666666
1
1000
1000000
Forløpt sekunder: -0.0072517

Konklusjon

Denne artikkelen guider deg til å jobbe med varigheter i GO -språket som gitt av tidspakken. For ytterligere informasjon, bør du vurdere dokumentasjonen.