Czas trwania czasu Golang

Czas jest bardzo ważnym czynnikiem dla programistów. Nie tylko pozwala na ustalenie, w jaki sposób i po wykonywaniu działania pozwala nam rządzić, jak długo trwa operacja, a nawet przechowywać dzienniki różnych działań w programie.

Go zapewnia nam pakiet czasu, aby obsłużyć czas i datę. W tym artykule omówimy, jak mierzyć czas upływający między dwukrotnymi instancjami.

Czas.Czas trwania

Czas trwania odnosi się do czasu upływu między dwukrotnymi obiektami jako liczba nanosekund INT64. Jeśli ustawimy czas trwania na 1000000000 nanosekund, reprezentuje to 1 sekundę lub 1000 milisekund. Maksymalny czas, jaki możemy reprezentować (dla INT64) wynosi 290 lat.

Następująca definicja składni dla czasu trwania w pakiecie czasowym.

Czas trwania Int64

Czas trwania zdefiniowany w pakiecie czasowym obejmuje:

const (
Czas trwania nanosekund = 1
Microsekund = 1000 * nanosekund
Milisekunda = 1000 * Microsekund
Drugi = 1000 * milisekund
Minute = 60 * sekunda
Godzinę = 60 * minutę
)

Zauważ, że powyższe wartości są stałymi.

W pakiecie czasowym możemy użyć następującej funkcji, aby zwrócić czas:

Czas.Pod()

Składnia funkcji jest jak pokazana:

Czas trwania podmoty

Zwraca czas trwania t-u.

Czas.Od()

Składnia dla metody od czasu () jest jak pokazano:

FUNC od czasu (czas t)

Ta funkcja zwraca czas trwania, odkąd t.

Czas.Dopóki()

Składnia jest jak pokazana:

FUNC do czasu trwania czasu (czasu)

zwróć czas trwania do t. Pomyśl o tym jak o skrócie na czas.Sub (czas.Teraz()).

Czas.Czas trwania

Ta funkcja zwraca czas trwania w nanosekundach. Składnia jest jak pokazana:

FUNC (czas trwania) miliseconds () int64

Przykład

Poniższy kod ilustruje, jak obliczyć czas trwania.

Pakiet Main
import (
„FMT”
"czas"
)
func main ()
// Ustaw czas trwania
Czas trwania.Czas trwania = 1000000000
// w godzinach
fmt.Println (czas trwania.Godziny())
// minuty
fmt.Println (czas trwania.Minuty())
// sekundy
fmt.Println (czas trwania.Sekundy())
// milisekund
fmt.Println (czas trwania.Miliseconds ())
// Mikrosekund
fmt.Println (czas trwania.MicroseConds ())
// za pomocą metody sub
teraz: = czas.Teraz()
czas.Sen (1000)
diff: = teraz.Sub (czas.Teraz())
fmt.Println („upłynął sekundy:”, diff.Sekundy())

W pierwszej sekcji programu tworzymy czas trwania i ustawiamy go na 1000000000 nanosekund. Następnie używamy metod z pakietu czasowego, aby przekonwertować go na różne formaty.

W drugiej sekcji używamy metody sub () do obliczenia różnicy czasu po operacji snu.

Kod powyżej powinien zwrócić:

$ Go Run Turn.Iść
0.0002777777777777778
0.0166666666666666666
1
1000
1000000
Upłynęły sekundy: -0.0072517

Wniosek

W tym artykule prowadzi Cię do pracy z czasem trwania języka Go, zgodnie z pakietem czasu. Aby uzyskać dodatkowe informacje, rozważ dokumentację.