Búsqueda de sitios web

Trabajar con diferentes zonas horarias en Go


Deje que el paquete de tiempo de Go se encargue de los complicados matices de la conversión y el cálculo de la zona horaria por usted.

Las zonas horarias son cruciales para cualquier aplicación que trate con fechas y horas. Por supuesto, esto es especialmente cierto para las aplicaciones que atienden a usuarios de todos los continentes y ubicaciones. Las zonas horarias determinan la diferencia con respecto a la hora universal coordinada (UTC) para ubicaciones específicas alrededor del mundo. Desempeñan un papel vital para garantizar un manejo del tiempo preciso y confiable.

Go proporciona el paquete de hora en su biblioteca estándar para trabajar con hora y zonas horarias. Puede buscar y convertir zonas horarias en varias ubicaciones utilizando el paquete de hora.

El paquete del tiempo

El paquete time proporciona funcionalidad para trabajar con horas y fechas, medir y mostrar el tiempo y manipular fechas usando un calendario gregoriano sin segundos intercalares.

El paquete de hora proporciona un tipo de estructura Time que contiene el campo de ubicación que puede utilizar para establecer zonas horarias.

Puede importar el paquete de tiempo con una declaración de importación.

import "time"

Aquí está el tipo de estructura de tiempo y sus campos. Los campos no se exportan, por lo que no aparecen en la documentación oficial.

package main
type Time struct {
    // wall is the wall time in the format returned by the runtime.nanotime()
    // function.
    wall uint64
    // ext is the monotonic clock reading in the format returned by
    // runtime.nanotime().
    ext int64
    // loc is a pointer to the Location struct associated with this time.
    loc *Location
}
type Location struct {
    // name is the time zone name, such as "UTC" or "PST".
    name string
    // zone contains information about the time zone abbreviation, offset,
    // and rule for a single time zone in the location.
    zone []zone
    // tx contains information about when the time zone abbreviation or
    // offset changes for a location.
    tx []zoneTrans
    // extend contains the name of a parent time zone if this location
    // extends from another one.
    extend string
    // cacheStart and cacheEnd are Unix timestamps that deine the range
    // for which the cacheZone field is valid.
    cacheStart int64
    cacheEnd int64
    // cacheZone points to the zone that is currently valid for the time
    // range defined by cacheStart and cacheEnd.
    cacheZone *zone
}

Muchos métodos utilizan las estructuras Hora y Ubicación, incluidos los métodos de zona horaria.

Cargando información de zona horaria

Cargar información de zona horaria es una de las operaciones básicas cuando se trabaja con zonas horarias. El método LoadLocation proporciona funcionalidad para cargar información de zona horaria desde la base de datos de zonas horarias de la IANA. El método LoadLocation toma el nombre de la zona horaria y devuelve la información de ubicación y un error de manejo. Una vez que ha cargado la información de la zona horaria, crea una instancia de estructura time asociada con la zona horaria.

import (
    "fmt"
    "time"
)
func main() {
    // Load the time zone location for America/New_York
    loc, err := time.LoadLocation("America/New_York")
    if err != nil {
        fmt.Println("Error loading location:", err)
        return
    }
    // Get the current time at a location
    now := time.Now().In(loc)
    fmt.Println("Current time in New York:", now)
}

El método In de la función Now toma una ubicación e imprime la hora allí:

Además, puede utilizar el método FixedZone para cargar la hora actual en una ubicación si conoce la cadena de ubicación y el desplazamiento de la zona horaria con respecto a UTC. Primero, deberá cargar la hora actual en UTC y luego usará el método FixedZone para cargar la ubicación según la cadena y el desplazamiento antes de pasar la ubicación al método In de la instancia de tiempo.

import (
    "fmt"
    "time"
)
func main() {
    // Get the current time in UTC
    now := time.Now().UTC()
    // Set the time zone for Lagos
    lagos := now.In(time.FixedZone("WAT", 3600))
    // Print the current time in both locations
    fmt.Println("Current time in Lagos:", lagos)
}

La función principal imprime la hora actual en Lagos en la consola.

Medición de la duración de la zona horaria

El paquete de hora proporciona el método Zone para recuperar la abreviatura y el desplazamiento de la zona horaria asociada con un valor time.Time. El método Zone devuelve la cadena que representa la abreviatura de la zona horaria (por ejemplo, "EST" para "América/Nueva_York") y un número entero que representa el número de segundos al este de UTC.

import (
    "fmt"
    "time"
)
func main() {
    // Load the time zone location for America/New_York
    loc, err := time.LoadLocation("America/New_York")
    if err != nil {
        fmt.Println("Error loading location:", err)
        return
    }
    // Get the current time in UTC and the specified location
    t1 := time.Now()
    t2 := t1.In(loc)
    // Get the offset in seconds for each time zone 
    //for the time zones
    _, offset1 := t1.Zone()
    _, offset2 := t2.Zone()
    // Calculate the duration of the time zone shift 
    // between UTC and America/New_York
    duration := offset2 - offset1
    fmt.Printf("The time zone shift duration" +
      " between UTC and New York is: %d seconds", duration)
}

En la función principal, el método Zona mide la duración del cambio de zona horaria entre dos zonas horarias (valores de hora.Tiempo). La variable t1 es la hora actual en UTC y la variable t2 es la hora actual en la zona horaria "América/Nueva_York".

La función imprime la variable duración (la diferencia de desplazamiento entre las zonas horarias) que representa el cambio de zona horaria en segundos.

Evaluación del tiempo entre zonas horarias

Puede evaluar el tiempo entre zonas horarias si conoce la duración entre las zonas horarias. Puede utilizar el método Add del método In de su instancia de estructura time.Time para agregar una duración a la hora en una zona horaria.

import (
    "log"
    "time" // import the time package
)
func evaluateTime(t time.Time, duration time.Duration) time.Time {
    // load the location for Africa/Lagos
    location, err := time.LoadLocation("Africa/Lagos")
    if err != nil {
        log.Println("There was an error loading the location")
    }
    
    return t.In(location).Add(duration)
}

La función evaluateTime toma una instancia time.Time y una duración de tipo time.Duration, devolviendo la hora en la zona horaria. Carga la hora actual en "África/Lagos" y agrega una duración a la hora.

Manipular la hora y la fecha con el paquete Time

El paquete de tiempo es muy versátil para trabajar tanto con horas como con fechas. El paquete time proporciona funciones como Unix() para convertir el tiempo a tiempo Unix, Sleep() para pausar rutinas y Format() para formatear valores de tiempo en cadenas.

Artículos relacionados: