DateFormatExchange (DFE)

Get it

$ go get github.com/newm4n/go-dfe

About

Golang formats time.Time into string or parses a string back to time.Time using a speciffic date format. While the format it self resembles the actual date so you get the feeling on how it would look like, making these format can be some what un-intuitive.

Imagine if we have a date string of "February 21, 2018. At 21:32:12", And the format to parse this string is "January 02, 2006. At 15:04:05". It appears that January, 02, 2006, 15, 04, 05 is actually a sub pattern to recognize for their respected date element.

Date format in Golang

According to Golang time.Format() Code :

const (
	_                        = iota
	stdLongMonth             = iota + stdNeedDate  // "January"
	stdMonth                                       // "Jan"
	stdNumMonth                                    // "1"
	stdZeroMonth                                   // "01"
	stdLongWeekDay                                 // "Monday"
	stdWeekDay                                     // "Mon"
	stdDay                                         // "2"
	stdUnderDay                                    // "_2"
	stdZeroDay                                     // "02"
	stdHour                  = iota + stdNeedClock // "15"
	stdHour12                                      // "3"
	stdZeroHour12                                  // "03"
	stdMinute                                      // "4"
	stdZeroMinute                                  // "04"
	stdSecond                                      // "5"
	stdZeroSecond                                  // "05"
	stdLongYear              = iota + stdNeedDate  // "2006"
	stdYear                                        // "06"
	stdPM                    = iota + stdNeedClock // "PM"
	stdpm                                          // "pm"
	stdTZ                    = iota                // "MST"
	stdISO8601TZ                                   // "Z0700"  // prints Z for UTC
	stdISO8601SecondsTZ                            // "Z070000"
	stdISO8601ShortTZ                              // "Z07"
	stdISO8601ColonTZ                              // "Z07:00" // prints Z for UTC
	stdISO8601ColonSecondsTZ                       // "Z07:00:00"
	stdNumTZ                                       // "-0700"  // always numeric
	stdNumSecondsTz                                // "-070000"
	stdNumShortTZ                                  // "-07"    // always numeric
	stdNumColonTZ                                  // "-07:00" // always numeric
	stdNumColonSecondsTZ                           // "-07:00:00"
	stdFracSecond0                                 // ".0", ".00", ... , trailing zeros included
	stdFracSecond9                                 // ".9", ".99", ..., trailing zeros omitted

	stdNeedDate  = 1 << 8             // need month, day, year
	stdNeedClock = 2 << 8             // need hour, minute, second
	stdArgShift  = 16                 // extra argument in high bits, above low stdArgShift
	stdMask      = 1<<stdArgShift - 1 // mask out argument
)

By looking to the above const snippet, you will understand how to create a date format in Go.

Date format in Java

Date format in Java have a more intuitive way to define date format.

According to SimpleDateFormat Java Doc :

Letter	Date or Time Component	Presentation	Examples
G	Era designator	Text	AD
y	Year	Year	1996; 96
Y	Week year	Year	2009; 09
M	Month in year	Month	July; Jul; 07
w	Week in year	Number	27
W	Week in month	Number	2
D	Day in year	Number	189
d	Day in month	Number	10
F	Day of week in month	Number	2
E	Day name in week	Text	Tuesday; Tue
u	Day number of week (1 = Monday, ..., 7 = Sunday)	Number	1
a	Am/pm marker	Text	PM
H	Hour in day (0-23)	Number	0
k	Hour in day (1-24)	Number	24
K	Hour in am/pm (0-11)	Number	0
h	Hour in am/pm (1-12)	Number	12
m	Minute in hour	Number	30
s	Second in minute	Number	55
S	Millisecond	Number	978
z	Time zone	General time zone	Pacific Standard Time; PST; GMT-08:00
Z	Time zone	RFC 822 time zone	-0800
X	Time zone	ISO 8601 time zone	-08; -0800; -08:00

How do we map date format in Golang and Java

Thus the following mapping can be created between golang and java date format.

Const	Go Format	Java Format
`stdLongMonth`	`January`	`MMMM`
`stdMonth`	`Jan`	`MMM`
`stdNumMonth`	`1`	`M`
`stdZeroMonth`	`01`	`MM`
`stdLongWeekDay`	`Monday`	`EEEE`
`stdWeekDay`	`Mon`	`EEE`
`stdDay`	`2`	`d`
`stdUnderDay`	`_2`	n/a fallback to `_d`
`stdZeroDay`	`02`	`dd`
`stdHour`	`15`	`HH`
`stdHour12`	`3`	`K`
`stdZeroHour12`	`03`	`KK`
`stdMinute`	`4`	`m`
`stdZeroMinute`	`04`	`mm`
`stdSecond`	`5`	`s`
`stdZeroSecond`	`05`	`ss`
`stdFracSecond9`	`999999999`	`SSS`
`stdLongYear`	`2006`	`yyyy`
`stdYear`	`06`	`yy`
`stdPM`	`PM`	`aa`
`stdpm`	`pm`	n/a fallback to `aa`
`stdTZ`	`MST`	`Z`
`stdISO8601TZ`	`Z0700`	`'Z'XX`
`stdISO8601SecondsTZ`	`Z070000`	n/a fallback to `'Z'XX`
`stdISO8601ShortTZ`	`Z07`	`'Z'X`
`stdISO8601ColonTZ`	`Z07:00`	`'Z'XXX`
`stdISO8601ColonSecondsTZ`	`Z07:00:00`	n/a fallback to `'Z'XXX`
`stdNumTZ`	`-0700`	`XX`
`stdNumSecondsTz`	`-070000`	n/a fallback to `'Z'XX`
`stdNumShortTZ`	`-07`	`X`
`stdNumColonTZ`	`-07:00`	`XXX`
`stdNumColonSecondsTZ`	`-07:00:00`	n/a fallback to `XXX`

Usage

import (
	"github.com/newm4n/go-dfe"
	"time"
)

func FormatTime(t *time.Time) string {
	translation := DateFormatExchange.NewPatternTranslation()
	return t.Format(translation.JavaToGoFormat("dd MMMM yyyy HH:mm:ss"))
}

func ParseTime(date string) (*time.Time, error) {
	translation := DateFormatExchange.NewPatternTranslation()
	t, err := time.Parse(translation.JavaToGoFormat("dd MMMM yyyy HH:mm:ss"), date)
	if err != nil {
		return nil, err
	}
	return &t, err
}