We often want to Unmarshal and Marshal times from JSON data. Take the following example

type tsData struct {
    Timestamp time.Time `json:"ts"`
    Value     int       `json:"value"`
}

func main() {
    input := []byte(`{
        "ts": "2019 05 27 12:52:18",
        "value": 10
        }`)

    var data tsData
    if err := json.Unmarshal(input, &data); err != nil {
        fmt.Println("Could not unmarshal data:", err)
    }

    fmt.Printf("%+v\n", data)
}

We have defined a type tsData to represent times series data which has a Timestamp of type time.Time and a Value of type int. Our simulated JSON input is defined in the input variable which has a ts field with a reasonable time format.

Looking back at the documentation, we can see that time.Time has a method UnmarshalJSON meaning it implements the Unmarshaler interface and can be used with json.Unmarshal.

When we come to run the program, however, we exit with the following error message

Could not unmarshal data: parsing time ""2019 05 27 12:52:18"" as ""2006-01-02T15:04:05Z07:00"": cannot parse " 05 27 12:52:18"" as "-"

This indicates that Unmarshal is expecting a particular time format which is different to that we have given as input. The documentation for time.UnmarshalJSON specifies “the time is expected to be a quoted string in the RFC 3339 format”. We therefore need to create our own type that can handle this different format.

Our custom type is called timestamp which simply embeds a time.Time. This allows us to use timestamp in an almost identical manner to a time.Time throughout the rest of our code.

In order to satisfy the Unmarshaler interface, we define a single method on timestamp called UnmarshalJSON. Note how we can access the anonymous field using its type in the line ts.Time = t.

const layout = "2006 01 02 15:04:05"

type timestamp struct {
    time.Time
}

func (ts *timestamp) UnmarshalJSON(b []byte) error {
    // Convert to string and remove quotes
    s := strings.Trim(string(b), "\"")

    // Parse the time using the layout
    t, err := time.Parse(layout, s)
    if err != nil {
        return err
    }

    // Assign the parsed time to our variable
    ts.Time = t
    return nil
}

type tsData struct {
    Timestamp timestamp `json:"ts"`
    Value     int       `json:"value"`
}

func main() {
    input := []byte(`{
        "ts": "2019 05 27 12:52:18",
        "value": 10
        }`)

    var data tsData
    if err := json.Unmarshal(input, &data); err != nil {
        fmt.Println("Could not unmarshal data:", err)
        return
    }

    fmt.Printf("%+v\n", data)
    fmt.Println("Month:", data.Timestamp.Month())
}

Now when we run the code we get the desired output: {Timestamp:2019-05-27 12:52:18 +0000 UTC Value:10} Month: May

Marshaling is achieved by satisfying the json.Marshaler interface. Note the value receiver (ie not *timestamp),

...
func (ts timestamp) MarshalJSON() ([]byte, error) {
    // The +2 is to take account of the quotation marks
    b := make([]byte, 0, len(layout)+2)

    // Write the JSON output
    b = append(b, '"')
    b = ts.AppendFormat(b, layout)
    b = append(b, '"')

    return b, nil
}
...

Now in func main():

...
    dataJSON, err := json.Marshal(data)
    if err != nil {
        fmt.Println("Could not marshal data:", err)
        return
    }

    fmt.Println(bytes.Equal(input, dataJSON))
...

true

The two variables are equal (for this comparison, we have removed all the white space in the input variable).