Why does printing a custom Time type alias in Go produce unexpected output, and how can it be corrected?

Unexpected Output When Printing Time.Time Type Alias

In Go, one may encounter unexpected output when printing a custom Time type alias. Understanding the behavior requires dissecting the issue further.

Understanding the Issue

Consider the following code:

<code class="go">package main
import (
    "encoding/json"
    "fmt"
    "strings"
    "time"
)

type Time time.Time

func (st *Time) UnmarshalJSON(b []byte) error {
    s := strings.Trim(string(b), "\"")
    t, err := time.Parse(time.RFC3339, fmt.Sprintf("%s%s", s, "Z"))
    if err != nil {
        return fmt.Errorf("parse time: %w", err)
    }
    *st = Time(t)
    return nil
}

type User struct {
    Name string
    TS Time
}

const data = `{id: 3, name: "Name", ts: "2021-05-21T03:10:20.958450"}`

func main() {
    user := new(User)
    json.Unmarshal([]byte(data), &user)
    fmt.Printf("%v\n", user)
}</code>

When running this code, the expected output is a formatted Time value, similar to:

&{Name 2021-05-21 03:10:20.95845 +0000 UTC}

However, the actual output appears as:

&{Name {958450000 63757163420 <nil>}}

Explaining the Incorrect Output

The discrepancy arises because Time type alias does not implement fmt.Stringer, causing the default formatting logic to take over. This logic prints the underlying time.Time value's fields enclosed in curly braces.

Correcting the Output

To resolve this, implement a String method in the Time type that delegates to time.Time.String. This enables the desired formatted output:

<code class="go">func (t Time) String() string {
    return time.Time(t).String()
}</code>

Alternative Solution

Another option is to embed time.Time in the Time type. This automatically promotes the String method and other methods (including Marshal*).

<code class="go">type Time struct {
    time.Time
}

func (st *Time) UnmarshalJSON(b []byte) error {
    // ... unchanged ...
    st.Time = t // simple assignment without type conversion
    // ... unchanged ...
}</code>

Additional Considerations

When parsing JSON, avoid manual parsing with strings.Trim; instead, use json.Unmarshal for proper decoding. Additionally, simplify time parsing using time.ParseInLocation:

<code class="go">func (st *Time) UnmarshalJSON(b []byte) error {
    var s string
    if err := json.Unmarshal(b, &s); err != nil {
        return err
    }

    t, err := time.ParseInLocation("2006-01-02T15:04:05", s, time.UTC)
    if err != nil {
        return err
    }

    // ... unchanged ...
}</code>

The above is the detailed content of Why does printing a custom Time type alias in Go produce unexpected output, and how can it be corrected?. For more information, please follow other related articles on the PHP Chinese website!