Las operaciones relacionadas con la hora y la fecha son una parte crucial del desarrollo de software (por ejemplo, mantenimiento de registros). La biblioteca estándar de Go proporciona un paquete de tiempo que tiene muchas funciones y métodos para manejar la fecha y la hora. El sistema operativo mide dos tipos de tiempo, el tiempo de «Reloj de pared» y el tiempo «Monotónico». El tiempo del reloj de pared se usa para decir la hora, mientras que el tiempo del reloj monótono se usa para medir el tiempo. El paquete Go time proporciona funcionalidades para medir y manipular ambos relojes. Golang tiene tiempo. Tipo de datos de tiempo para tratar con el tiempo y la hora del reloj de pared . Duración para tratar con el tiempo monótono.
El primer método básico es time.Now(), que devuelve la fecha y la hora actuales con una precisión de nanosegundos. El valor devuelto tiene el tipo de datos time.Time, que es una estructura. Según la documentación oficial de Golang, «A Time representa un instante en el tiempo con una precisión de nanosegundos».
Go
package main
import (
"fmt"
"time"
)
func main() {
// Returns current time.
t := time.Now()
fmt.Println(t)
}
Producción:
2020-04-29 00:37:36.849599502 +0530 IST m=+0.000166550
En Go, cualquier variable declarada pero no inicializada se establece por defecto en su valor cero. El valor cero del tipo Time es el 1 de enero del año 1, 00:00:00.000000000 UTC, lo que es imposible en un escenario de la vida real. El método IsZero también se puede utilizar para comprobar si una variable de tiempo se inicializa o no.
Go
package main
import (
"fmt"
"time"
)
func main() {
var t time.Time
fmt.Println(t)
fmt.Println(t.IsZero())
}
Producción:
0001-01-01 00:00:00 +0000 UTC true
El tipo de datos time.Time tiene una estructura de tipo base que contiene la hora, la fecha, la ubicación, la zona horaria y la hora monótona. El paquete Go time tiene métodos para extraer partes individuales de un instante de tiempo (como fecha, hora, día, ubicación, etc.).
Go
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now()
fmt.Println(t)
// We can get individual values
// of hour, minute, seconds,
// nanoseconds from time.Time
// datatype
// Returns wall clock time
// from time.Time datatype
fmt.Println(t.Clock())
fmt.Println(t.Hour())
fmt.Println(t.Minute())
fmt.Println(t.Second())
fmt.Println(t.Nanosecond())
fmt.Println("---------------------------------")
// We can get individual values
// of day, month, year, yearday,
// and weekday from time.Time
// datatype
// Returns date from
// time.Time datatype
fmt.Println(t.Date())
fmt.Println(t.Day())
fmt.Println(t.Month())
fmt.Println(t.Year())
fmt.Println(t.YearDay())
fmt.Println(t.Weekday())
// week number
fmt.Println(t.ISOWeek())
fmt.Println("---------------------------------")
// current time in string formats
fmt.Println(t.String())
// nanoseconds passed
// from 1 january 1970
fmt.Println(t.Unix())
// prints abbreviated timezone and
// its offset in seconds from
// east of UTC
fmt.Println(t.Zone())
// prints nanoseconds
// elapsed from 1 january 1970
fmt.Println(t.UnixNano())
}
Producción:
2020-04-29 17:54:25.643755713 +0530 IST m=+0.000064065 17 54 25 17 54 25 643755713 --------------------------------- 2020 April 29 29 April 2020 120 Wednesday 2020 18 --------------------------------- 2020-04-29 17:54:25.643755713 +0530 IST m=+0.000064065 1588163065 IST 19800 1588163065643755713
El operador Golang == compara no solo el instante de tiempo, sino también la ubicación y la lectura monotónica del reloj.
time.Duration tiene un tipo base int64. La duración representa el tiempo transcurrido entre dos instantes como una cuenta de int64 nanosegundos”. La representación máxima posible en nanosegundos es de hasta 290 años.
type Duration int64
Conversión de varias instancias de duración:
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)
Go
package main
import (
"fmt"
"time"
)
func main() {
// random duration in nanoseconds
var d time.Duration = 1000000000
// converts d in hour
fmt.Println(d.Hours())
// converts d in minutes
fmt.Println(d.Minutes())
// converts d in seconds
fmt.Println(d.Seconds())
// converts d in milliseconds
fmt.Println(d.Milliseconds())
// converts d in microseconds
fmt.Println(d.Microseconds())
// string representation go d
fmt.Println(d.String())
}
Producción:
0.0002777777777777778 0.016666666666666666 1 1000 1000000 1s