web-dev-qa-db-fra.com

Convertir l'heure UTC en heure "locale" dans Go

Comment puis-je convertir l'heure UTC en heure locale ?

J'ai créé une carte avec la différence UTC pour tous les pays dont j'ai besoin de l'heure locale. Ensuite, j'ajoute cette différence en tant que durée à l'heure actuelle (UTC) et j'imprime le résultat en espérant que c'est l'heure locale de ce pays spécifique.

Pour certaines raisons, le résultat est incorrect. Par exemple avec Hongrie il y a une différence d'une heure. Une idée pourquoi j'obtiens des résultats incorrects?

package main

import "fmt"
import "time"

func main() {

    m := make(map[string]string)
    m["Hungary"] = "+01.00h"

    offSet, err := time.ParseDuration(m["Hungary"])
    if err != nil {
        panic(err)
    }
    t := time.Now().UTC().Add(offSet)
    Nice := t.Format("15:04")

    fmt.Println(Nice)
}
timegotimezonetimezone-offset
17
hey

Gardez à l'esprit que le temps de jeu est défini sur 2009-11-10 23:00:00 +0000 UTC, donc ça marche.

La bonne façon est d'utiliser time.LoadLocation cependant, voici un exemple:

var countryTz = map[string]string{
    "Hungary": "Europe/Budapest",
    "Egypt":   "Africa/Cairo",
}

func timeIn(name string) time.Time {
    loc, err := time.LoadLocation(countryTz[name])
    if err != nil {
        panic(err)
    }
    return time.Now().In(loc)
}

func main() {
    utc := time.Now().UTC().Format("15:04")
    hun := timeIn("Hungary").Format("15:04")
    eg := timeIn("Egypt").Format("15:04")
    fmt.Println(utc, hun, eg)
}
25
OneOfOne

Votre approche est défectueuse. Un pays peut avoir plusieurs fuseaux horaires, par exemple les États-Unis et la Russie. En raison de l'heure d'été (DST), un fuseau horaire peut avoir plusieurs heures, par exemple la Hongrie. La Hongrie est UTC +1: 00 et est également UTC + 2: 00 pour l'heure d'été.

Pour chaque emplacement pour lequel vous voulez l'heure locale pour une heure UTC donnée, utilisez l'emplacement du fuseau horaire IANA (tzdata). Par exemple,

package main

import (
    "fmt"
    "time"
)

func main() {
    utc := time.Now().UTC()
    fmt.Println(utc)
    local := utc
    location, err := time.LoadLocation("Europe/Budapest")
    if err == nil {
        local = local.In(location)
    }
    fmt.Println("UTC", utc.Format("15:04"), local.Location(), local.Format("15:04"))
    local = utc
    location, err = time.LoadLocation("America/Los_Angeles")
    if err == nil {
        local = local.In(location)
    }
    fmt.Println("UTC", utc.Format("15:04"), local.Location(), local.Format("15:04"))
}

Production:

2014-08-14 23:57:09.151377514 +0000 UTC
UTC 23:57 Europe/Budapest 01:57
UTC 23:57 America/Los_Angeles 16:57

Les références:

Base de données des fuseaux horaires IANA

base de données tz

fuseaux horaires de la base de données tz

Fuseau horaire

Heure en Hongrie

12
peterSO

Épargnez-vous les tracas de jouer avec des zones spécifiques, utilisez l'emplacement "Local". Voici un exemple complet et pratique de conversion locale et UTC:

package main

import (
    "fmt"
    "log"
    "time"
)

const (
    dateTimeFormat = "2006-01-02 15:04 MST"
    dateFormat    = "2006-01-02"
    timeFormat    = "15:04"
)

// A full cycle example of receiving local date and time,
// handing off to a database, retrieving as UTC, and formatting as local datetime
// This should be good in *any* timezone
func main() {
    // If using a form for entry, I strongly suggest a controlled format input like
    // <input type="date" ... > and <input type="time" ... >
    locallyEnteredDate := "2017-07-16"
    locallyEnteredTime := "14:00"

    // Build a time object from received fields (time objects include zone info)
    // We are assuming the code is running on a server that is in the same zone as the current user
    zone, _ := time.Now().Zone() // get the local zone
    dateTimeZ := locallyEnteredDate + " " + locallyEnteredTime + " " + zone
    dte, err := time.Parse(dateTimeFormat, dateTimeZ)
    if err != nil {
        log.Fatal("Error parsing entered datetime", err)
    }
    fmt.Println("dte:", dte) // dte is a legit time object
    // Perhaps we are saving this in a database.
    // A good database driver should save the time object as UTC in a time with zone field,
    // and return a time object with UTC as zone.

    // For the sake of this example, let's assume an object identical to `dte` is returned
    // dte := ReceiveFromDatabase()

    // Convert received date to local.
    // Note the use of the convenient "Local" location https://golang.org/pkg/time/#LoadLocation.
    localLoc, err := time.LoadLocation("Local")
    if err != nil {
        log.Fatal(`Failed to load location "Local"`)
    }
    localDateTime := dte.In(localLoc)

    fmt.Println("Date:", localDateTime.Format(dateFormat))
    fmt.Println("Time:", localDateTime.Format(timeFormat))
}
2
Rohanthewiz