Parsing date/time strings which are not 'standard' formats

How do I parse non-standard date/time strings in Go. In example if I wanted to convert the string 10/15/1983 into a time.Time? The time.Parse() function supposedly allows you to specify a format.

http://play.golang.org/p/v5DbowXt1x

package main

import "fmt"
import "time"

func main() {
	test, err := time.Parse("10/15/1983", "10/15/1983")
	if err != nil {
		panic(err)
	}
	
	fmt.Println(test)
}

This results in a panic.

panic: parsing time "10/15/1983" as "10/15/1983": cannot parse "" as "0/"

Logically that makes sense because how is it supposed to know which is the day and which is the month.

Other languages have a function similar to the following:

parse("mm/dd/yyyy", "10/15/1983")

I cannot find such a function in the Go docs, is my only choice to regex?

There are some key values that the time.Parse is looking for.

By changing:

test, err := time.Parse("10/15/1983", "10/15/1983")

to

test, err := time.Parse("01/02/2006", "10/15/1983")

the parser will recognize it.

Here's the <a href="http://play.golang.org/p/tPr45KHNbF">modified code on the playground</a>.

package main

import "fmt"
import "time"

func main() {
	test, err := time.Parse("01/02/2006", "10/15/1983")
	if err != nil {
		panic(err)
	}
	
	fmt.Println(test)
}

<br/>

You can utilize the constants list in the <a href="http://golang.org/src/pkg/time/format.go">src/pkg/time/format.go</a> file to create your own parse formats.

const (
	stdLongMonth      = "January"
	stdMonth          = "Jan"
	stdNumMonth       = "1"
	stdZeroMonth      = "01"
	stdLongWeekDay    = "Monday"
	stdWeekDay        = "Mon"
	stdDay            = "2"
	stdUnderDay       = "_2"
	stdZeroDay        = "02"
	stdHour           = "15"
	stdHour12         = "3"
	stdZeroHour12     = "03"
	stdMinute         = "4"
	stdZeroMinute     = "04"
	stdSecond         = "5"
	stdZeroSecond     = "05"
	stdLongYear       = "2006"
	stdYear           = "06"
	stdPM             = "PM"
	stdpm             = "pm"
	stdTZ             = "MST"
	stdISO8601TZ      = "Z0700"  // prints Z for UTC
	stdISO8601ColonTZ = "Z07:00" // prints Z for UTC
	stdNumTZ          = "-0700"  // always numeric
	stdNumShortTZ     = "-07"    // always numeric
	stdNumColonTZ     = "-07:00" // always numeric
)

So anytime your format specifies a year, it should be done with "06" or "2006", seconds are specified by "05" or "5" and time zones are specified at "MST", "Z0700", "Z07:00", "-0700", "-07" or "-07:00". If you reference the constants list you can likely put together any standard format you'd need to parse.

For example, if you want to parse the date/time in the <a href="http://en.wikipedia.org/wiki/Common_Log_Format">Common Log Format</a>, the format Apache uses for its log files, you would do so by passing the following string to time.Parse() as the <i>layout</i> argument.

"02/Jan/2006:15:04:05 -0700"

"02" denotes the day of the month field, "Jan" denotes the month name field, "2006" denotes the year field, "15" denotes the hour of day field in 24 hour format, "04" denotes the minutes field, "05" denotes the seconds field and "-0700" denotes the time zone field.

That format would parse the current PST time: 31/Dec/2012:15:32:25 -0800

So the time.Parse() call would look like this:

test, err := time.Parse("02/Jan/2006:15:04:05 -0700", "31/Dec/2012:15:32:25 -0800")

If you can't remember the Numbers in the specifying layout ("2006-01-02T15:04:05.000Z"), you may use my simple date formatting library github.com/metakeule/fmtdate that uses MS Excel conventions, like Y,M,D,h and internally translates them to the number format:

package main

import (
	"github.com/metakeule/fmtdate"

	"fmt"
)

func main() {
	test, err := fmtdate.Parse("MM/DD/YYYY", "10/15/1983")
	if err != nil {
		panic(err)
	}

	fmt.Println(test)
}

If you are looking for a C-Style formatting function: After reviewing some of the options I have chosen https://github.com/cactus/gostrftime as it generally follows the strfmt(3) notation.

To quote the example:

import (
    "fmt"
    "time"
    "github.com/cactus/gostrftime"
)

func main() {
    now := time.Now()
    fmt.Println(gostrftime.Format("%Y-%m-%d", now))
}

If a date format has to be used by both C and Go and the C implementation is not to be touched there's no choice but to adapt on the Go end. The above package fulfills that need.

If you don't want bother remembering the magic numbers, you can do this:

package main

import (
   "fmt"
   "time"
)

func main() {
   var (
      y, d int
      m time.Month
   )
   fmt.Sscanf("10/15/1983", "%v/%v/%v", &m, &d, &y)
   t := time.Date(y, m, d, 0, 0, 0, 0, time.UTC)
   fmt.Println(t) // 1983-10-15 00:00:00 +0000 UTC
}

https://golang.org/pkg/fmt#Sscanf