Come analizzare il timestamp di unix in time.Time

Sto cercando di analizzare un timestamp Unix ma ottengo un errore di intervallo. Questo non ha davvero senso per me, perché il layout è corretto (come nei documenti Go):

package main

import "fmt"
import "time"

func main() {
    tm, err := time.Parse("1136239445", "1405544146")
    if err != nil{
        panic(err)
    }

    fmt.Println(tm)
}

Terreno di gioco

La time.Parsefunzione non esegue i timestamp Unix. Invece puoi usare strconv.ParseIntper analizzare la stringa int64e creare il timestamp con time.Unix:

package main

import (
    "fmt"
    "time"
    "strconv"
)

func main() {
    i, err := strconv.ParseInt("1405544146", 10, 64)
    if err != nil {
        panic(err)
    }
    tm := time.Unix(i, 0)
    fmt.Println(tm)
}

Produzione:

2014-07-16 20:55:46 +0000 UTC

Parco giochi: http://play.golang.org/p/v_j6UIro7a

Modificare:

Modificato da strconv.Atoia strconv.ParseIntper evitare overflow di int su sistemi a 32 bit.

È possibile utilizzare direttamente la funzione time.Unix dell'ora che converte il timestamp unix in UTC

package main

import (
  "fmt"
  "time"
)


func main() {
    unixTimeUTC:=time.Unix(1405544146, 0) //gives unix time stamp in utc 

    unitTimeInRFC3339 :=unixTimeUTC.Format(time.RFC3339) // converts utc time to RFC3339 format

    fmt.Println("unix time stamp in UTC :--->",unixTimeUTC)
    fmt.Println("unix time stamp in unitTimeInRFC3339 format :->",unitTimeInRFC3339)
}

Produzione

unix time stamp in UTC :---> 2014-07-16 20:55:46 +0000 UTC
unix time stamp in unitTimeInRFC3339 format :----> 2014-07-16T20:55:46Z

Controlla in Go Playground: https://play.golang.org/p/5FtRdnkxAd

Condividendo alcune funzioni che ho creato per le date:

Tieni presente che volevo ottenere il tempo per una posizione particolare (non solo l'ora UTC). Se si desidera l'ora UTC, rimuovere semplicemente la variabile loc e la chiamata alla funzione .In (loc).

func GetTimeStamp() string {
     loc, _ := time.LoadLocation("America/Los_Angeles")
     t := time.Now().In(loc)
     return t.Format("20060102150405")
}
func GetTodaysDate() string {
    loc, _ := time.LoadLocation("America/Los_Angeles")
    current_time := time.Now().In(loc)
    return current_time.Format("2006-01-02")
}

func GetTodaysDateTime() string {
    loc, _ := time.LoadLocation("America/Los_Angeles")
    current_time := time.Now().In(loc)
    return current_time.Format("2006-01-02 15:04:05")
}

func GetTodaysDateTimeFormatted() string {
    loc, _ := time.LoadLocation("America/Los_Angeles")
    current_time := time.Now().In(loc)
    return current_time.Format("Jan 2, 2006 at 3:04 PM")
}

func GetTimeStampFromDate(dtformat string) string {
    form := "Jan 2, 2006 at 3:04 PM"
    t2, _ := time.Parse(form, dtformat)
    return t2.Format("20060102150405")
}

Secondo la documentazione di go , Unix restituisce un'ora locale.

Unix restituisce l'ora locale corrispondente all'ora Unix specificata

Ciò significa che l'output dipenderà dalla macchina su cui viene eseguito il codice, che, molto spesso, è ciò di cui hai bisogno, ma a volte potresti voler avere il valore in UTC.

Per fare ciò, ho adattato lo snippet in modo che restituisse un'ora in UTC:

i, err := strconv.ParseInt("1405544146", 10, 64)
if err != nil {
    panic(err)
}
tm := time.Unix(i, 0)
fmt.Println(tm.UTC())

Stampa sulla mia macchina (in CEST)

2014-07-16 20:55:46 +0000 UTC

Faccio molte registrazioni in cui i timestamp sono float64 e uso questa funzione per ottenere i timestamp come stringa:

func dateFormat(layout string, d float64) string{
    intTime := int64(d)
    t := time.Unix(intTime, 0)
    if layout == "" {
        layout = "2006-01-02 15:04:05"
    }
    return t.Format(layout)
}

Usa solo il tempo

esempio:

package main

import (
    "fmt"
    "time"
)

func main() {
    fromString := "Wed, 6 Sep 2017 10:43:01 +0300"
    t, e := time.Parse("Mon, _2 Jan 2006 15:04:05 -0700", fromString)
    if e != nil {
        fmt.Printf("err: %s\n", e)
    }
    fmt.Printf("UTC time: %v\n", t.UTC())
}

Esempio funzionante su play.golang.org .