Analizando cadena de fecha en Ir

Intenté analizar la cadena de fecha "2014-09-12T11:45:26.371Z"en Ir.

Código

layout := "2014-09-12T11:45:26.371Z"
str := "2014-11-12T11:45:26.371Z"
t, err := time.Parse(layout , str)

Tengo este error:

tiempo de análisis "2014-11-12T11: 47: 39.489Z": mes fuera de rango

¿Cómo puedo analizar esta cadena de fecha?

Utilice los números de diseño exactos descritos aquí y una buena publicación de blog aquí .

entonces:

layout := "2006-01-02T15:04:05.000Z"
str := "2014-11-12T11:45:26.371Z"
t, err := time.Parse(layout, str)

if err != nil {
    fmt.Println(err)
}
fmt.Println(t)

da:

>> 2014-11-12 11:45:26.371 +0000 UTC

Lo sé. Mente alucinante. También me atrapó por primera vez. Ir simplemente no usa una sintaxis abstracta para los componentes de fecha y hora ( YYYY-MM-DD), sino estos números exactos ( creo que la hora de la primera confirmación de ir No, de acuerdo con esto . ¿Alguien sabe?).

El diseño a usar " 2006-01-02T15:04:05.000Z" se describe en la respuesta de RickyA . No es "el momento del primer commit de go", sino más bien una forma mnemónica de recordar dicho diseño. Ver paquete / hora :

El tiempo de referencia utilizado en los diseños es:

Mon Jan 2 15:04:05 MST 2006

que es tiempo de Unix 1136239445.
Como MST es GMT-0700, el tiempo de referencia puede considerarse como

 01/02 03:04:05PM '06 -0700

(1,2,3,4,5,6,7, siempre que recuerde que 1 es para el mes y 2 para el día, que no es fácil para un europeo como yo, acostumbrado al formato de fecha día-mes)

Como se ilustra en " time.parse: ¿por qué Golang analiza el tiempo incorrectamente? ", Ese diseño (usando 1,2,3,4,5,6,7) debe respetarse exactamente .

Como se respondió, pero para guardar la escritura "2006-01-02T15:04:05.000Z"para el diseño, puede usar la constante RFC3339 del paquete .

str := "2014-11-12T11:45:26.371Z"
t, err := time.Parse(time.RFC3339, str)

if err != nil {
    fmt.Println(err)
}
fmt.Println(t)

https://play.golang.org/p/Dgu2ZvHwTh

Sugeriré usar time.RFC3339 constante del paquete de tiempo. Puede consultar otras constantes desde el paquete de tiempo. https://golang.org/pkg/time/#pkg-constants

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("Time parsing");
    dateString := "2014-11-12T11:45:26.371Z"
    time1, err := time.Parse(time.RFC3339,dateString);
    if err!=nil {
    fmt.Println("Error while parsing date :", err);
    }
    fmt.Println(time1); 
}

Esto es bastante tarde para la fiesta, y realmente no digo nada que no se haya dicho ya de una forma u otra, principalmente a través de los enlaces anteriores, pero quería dar un TL; resumen de DR a aquellos con menos capacidad de atención:

La fecha y hora de la cadena de formato go es muy importante. Así es como Go sabe qué campo es cuál. Generalmente son 1-9 de izquierda a derecha de la siguiente manera:

• Enero / enero / enero / enero / 01 / _1 (etc.) son por mes
• 02 / _2 son para el día del mes
• 15/03 / _3 / PM / P / pm / p son para hora y meridiano (3pm)
• 04 / _4 son por minutos
• 05 / _5 son por segundos
• 2006/06 son para el año
• -0700 / 07:00 / MST son para zona horaria
• .999999999 / .000000000 etc. son por segundos parciales (creo que la distinción es si se eliminan los ceros finales)
• Lunes / lunes son días de la semana (que 01-02-2006 realmente era),

Por lo tanto, no escriba "01-05-15" como su formato de fecha, a menos que quiera "Mes-Segunda-Hora"

(... de nuevo, esto fue básicamente un resumen de lo anterior).

Esto puede ser muy tarde, pero esto es para las personas que pueden tropezar con este problema y pueden querer usar un paquete externo para analizar la cadena de fecha.

Intenté buscar bibliotecas y encontré esta:

https://github.com/araddon/dateparse

Ejemplo de README:

package main

import (
    "flag"
    "fmt"
    "time"

    "github.com/apcera/termtables"
    "github.com/araddon/dateparse"
)

var examples = []string{
    "May 8, 2009 5:57:51 PM",
    "Mon Jan  2 15:04:05 2006",
    "Mon Jan  2 15:04:05 MST 2006",
    "Mon Jan 02 15:04:05 -0700 2006",
    "Monday, 02-Jan-06 15:04:05 MST",
    "Mon, 02 Jan 2006 15:04:05 MST",
    "Tue, 11 Jul 2017 16:28:13 +0200 (CEST)",
    "Mon, 02 Jan 2006 15:04:05 -0700",
    "Thu, 4 Jan 2018 17:53:36 +0000",
    "Mon Aug 10 15:44:11 UTC+0100 2015",
    "Fri Jul 03 2015 18:04:07 GMT+0100 (GMT Daylight Time)",
    "12 Feb 2006, 19:17",
    "12 Feb 2006 19:17",
    "03 February 2013",
    "2013-Feb-03",
    //   mm/dd/yy
    "3/31/2014",
    "03/31/2014",
    "08/21/71",
    "8/1/71",
    "4/8/2014 22:05",
    "04/08/2014 22:05",
    "4/8/14 22:05",
    "04/2/2014 03:00:51",
    "8/8/1965 12:00:00 AM",
    "8/8/1965 01:00:01 PM",
    "8/8/1965 01:00 PM",
    "8/8/1965 1:00 PM",
    "8/8/1965 12:00 AM",
    "4/02/2014 03:00:51",
    "03/19/2012 10:11:59",
    "03/19/2012 10:11:59.3186369",
    // yyyy/mm/dd
    "2014/3/31",
    "2014/03/31",
    "2014/4/8 22:05",
    "2014/04/08 22:05",
    "2014/04/2 03:00:51",
    "2014/4/02 03:00:51",
    "2012/03/19 10:11:59",
    "2012/03/19 10:11:59.3186369",
    // Chinese
    "2014年04月08日",
    //   yyyy-mm-ddThh
    "2006-01-02T15:04:05+0000",
    "2009-08-12T22:15:09-07:00",
    "2009-08-12T22:15:09",
    "2009-08-12T22:15:09Z",
    //   yyyy-mm-dd hh:mm:ss
    "2014-04-26 17:24:37.3186369",
    "2012-08-03 18:31:59.257000000",
    "2014-04-26 17:24:37.123",
    "2013-04-01 22:43",
    "2013-04-01 22:43:22",
    "2014-12-16 06:20:00 UTC",
    "2014-12-16 06:20:00 GMT",
    "2014-04-26 05:24:37 PM",
    "2014-04-26 13:13:43 +0800",
    "2014-04-26 13:13:44 +09:00",
    "2012-08-03 18:31:59.257000000 +0000 UTC",
    "2015-09-30 18:48:56.35272715 +0000 UTC",
    "2015-02-18 00:12:00 +0000 GMT",
    "2015-02-18 00:12:00 +0000 UTC",
    "2017-07-19 03:21:51+00:00",
    "2014-04-26",
    "2014-04",
    "2014",
    "2014-05-11 08:20:13,787",
    // mm.dd.yy
    "3.31.2014",
    "03.31.2014",
    "08.21.71",
    //  yyyymmdd and similar
    "20140601",
    // unix seconds, ms
    "1332151919",
    "1384216367189",
}

var (
    timezone = ""
)

func main() {
    flag.StringVar(&timezone, "timezone", "UTC", "Timezone aka `America/Los_Angeles` formatted time-zone")
    flag.Parse()

    if timezone != "" {
        // NOTE:  This is very, very important to understand
        // time-parsing in go
        loc, err := time.LoadLocation(timezone)
        if err != nil {
            panic(err.Error())
        }
        time.Local = loc
    }

    table := termtables.CreateTable()

    table.AddHeaders("Input", "Parsed, and Output as %v")
    for _, dateExample := range examples {
        t, err := dateparse.ParseLocal(dateExample)
        if err != nil {
            panic(err.Error())
        }
        table.AddRow(dateExample, fmt.Sprintf("%v", t))
    }
    fmt.Println(table.Render())
}

Si ha trabajado con el formato / análisis de hora / fecha en otros idiomas, es posible que haya notado que los otros idiomas usan marcadores de posición especiales para el formato de fecha / hora. Por ejemplo, usos del lenguaje ruby

%d for day
%Y for year

etc. Golang, en lugar de utilizar códigos como el anterior, utiliza marcadores de posición de formato de fecha y hora que solo parecen fecha y hora. Go usa el tiempo estándar, que es:

Mon Jan 2 15:04:05 MST 2006  (MST is GMT-0700)
or 
01/02 03:04:05PM '06 -0700

Entonces, si notas que Go usa

01 for the day of the month,
02 for the month
03 for hours,
04 for minutes
05 for second
and so on

Por lo tanto, por ejemplo, para analizar 2020-01-29, la cadena de diseño debe ser 06-01-02 o 2006-01-02.

Puede consultar la tabla de diseño de marcador de posición completa en este enlace: https://golangbyexample.com/parse-time-in-golang/