What does encoding/json emit for a time.Time field, and what timestamp input will it reject?

## What the default is `time.Time` is a struct whose fields are all unexported, so the reflective path in `encoding/json` would produce `{}`. It does not, because `time.Time` implements the marshaling interfaces itself: - `MarshalJSON` emits the instant as a **quoted RFC 3339 string with sub-second precision** — effectively `time.RFC3339Nano` inside quotes. Because that layout uses the `.999999999` fractional form, trailing zeros are dropped and a whole-second timestamp has no fractional part at all. - `UnmarshalJSON` accepts a quoted RFC 3339 string and nothing else. - `MarshalText`/`UnmarshalText` do the same without the quotes, which is what makes a `time.Time` usable as a JSON **map key** and in other text-based encodings. So the round trip for `time.Date(2024, time.March, 5, 14, 9, 7, 0, time.UTC)` is the string `"2024-03-05T14:09:07Z"`, and feeding that string back gives an equal instant. ## What is lost RFC 3339 encodes an **offset**, not a zone. A time in a zone whose current offset is +02:00 marshals as `+02:00`; the zone name is gone, and decoding produces a fixed-offset location rather than the original zone. If the receiving side needs to know *which* zone — because it must do calendar arithmetic across a daylight-saving boundary later — the zone identifier has to travel as a separate field. For a pure instant, the offset is sufficient and the loss does not matter. A second edge: `MarshalJSON` reports an error if the instant cannot be represented in RFC 3339, for example a year outside the four-digit range. In practice that only shows up with corrupt or synthetic data. ## The zero value The zero `time.Time` is not `null`. It marshals as `"0001-01-01T00:00:00Z"`, and the classic `omitempty` tag option does **not** suppress it, because `omitempty` has no concept of an empty struct. If you need an absent timestamp on the wire, make the field a `*time.Time` and leave it nil, or use the `omitzero` tag option available in recent Go, which does consult the value's zero-ness. ## Accepting another format When a sender will not emit RFC 3339 — epoch milliseconds is the usual case — you do not reach for a global setting, because there is none. You declare a named type and give it the decoding behaviour: ```go type epochMillis struct{ time.Time } func (e *epochMillis) UnmarshalJSON(b []byte) error { … } ``` The receiver-side rules matter. `UnmarshalJSON` must be on the **pointer** receiver, since it has to mutate; the decoder will find it as long as the field is addressable, which a struct field being decoded into always is. `b` is the raw JSON token including quotes if it is a string, so you either `json.Unmarshal` it into an intermediate value or slice the quotes off yourself. Symmetrically, if you want the type to *emit* the same format, implement `MarshalJSON` too — a type that decodes epoch millis but encodes RFC 3339 is a real and confusing asymmetry unless it is deliberate. A per-sender named type also gives you somewhere to put the sender's quirks: a trailing `Z` the sender omits, a comma as the decimal separator, a two-digit year. That is far better than a chain of `if err != nil { try the next layout }`, which silently picks the first layout an ambiguous value happens to satisfy. ## Testing it Marshalling assertions should compare the **exact string**, not a re-parsed time, or you cannot detect a format regression. Decoding assertions should include a negative case: feed the payload shape you are *not* accepting and assert the error, so the day someone adds a permissive fallback the test fails. And pin the fixture to a reference instant with a day above the 12th, a non-zero offset and a non-zero fraction — that single value catches format errors, day/month confusion and precision truncation at once.