
The `encoding/xml` package encodes Go values to XML and decodes XML into Go values. Struct tags (`xml:"name"`) control how Go fields map to XML elements and attributes.

<ExamplePair>
<ExampleProse>

Encode a struct to XML with `xml.Marshal`. The `xml.Header` constant provides the standard XML declaration. Use `xml:",attr"` to map a field to an XML attribute instead of a child element.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "encoding/xml"
    "fmt"
)

type Book struct {
    XMLName xml.Name `xml:"book"`
    ID      int      `xml:"id,attr"`
    Title   string   `xml:"title"`
    Author  string   `xml:"author"`
}

func main() {
    b := Book{ID: 1, Title: "The Go Programming Language", Author: "Donovan"}
    out, err := xml.MarshalIndent(b, "", "  ")
    if err != nil {
        panic(err)
    }
    fmt.Println(xml.Header + string(out))
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Decode XML into a struct with `xml.Unmarshal`. Fields without a tag use their lowercased name. Unknown elements are silently ignored by default.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "encoding/xml"
    "fmt"
)

type Book struct {
    XMLName xml.Name `xml:"book"`
    ID      int      `xml:"id,attr"`
    Title   string   `xml:"title"`
    Author  string   `xml:"author"`
}

func main() {
    data := []byte(`<book id="42"><title>The Go Programming Language</title><author>Donovan</author></book>`)

    var b Book
    if err := xml.Unmarshal(data, &b); err != nil {
        panic(err)
    }
    fmt.Printf("ID:%d Title:%s Author:%s\n", b.ID, b.Title, b.Author)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Use `xml.Decoder` for streaming. It reads tokens one at a time and avoids loading the full document into memory - essential for large XML files or feeds.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "encoding/xml"
    "fmt"
    "strings"
)

type Item struct {
    Title string `xml:"title"`
}

func main() {
    feed := `<feed><item><title>First</title></item><item><title>Second</title></item></feed>`

    dec := xml.NewDecoder(strings.NewReader(feed))
    for {
        tok, err := dec.Token()
        if err != nil {
            break // io.EOF
        }
        if se, ok := tok.(xml.StartElement); ok && se.Name.Local == "item" {
            var item Item
            dec.DecodeElement(&item, &se)
            fmt.Println(item.Title)
        }
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
XML is common in enterprise integrations, SOAP services, and RSS/Atom feeds. `encoding/xml` handles straightforward cases well, but for large XML streams use `xml.Decoder` token-by-token to avoid loading the entire document into memory - a 500 MB XML export will OOM your service if passed to `xml.Unmarshal`. For namespace-heavy XML (SOAP envelopes, XHTML), embed `xml.Name` with the `Space` field to match qualified names precisely. When generating XML for third-party consumers, always test the output against their schema validator - whitespace, attribute ordering, and namespace prefixes can all cause rejections even when the data is structurally correct.
</InProduction>


encoding/xml Marshal and Unmarshal, struct tags for element and attribute mapping, streaming with Encoder/Decoder, and handling namespaces.


The `time` package provides types and functions for measuring and displaying time. `time.Time` represents an instant in time with nanosecond precision. `time.Duration` represents an elapsed duration as an `int64` nanosecond count.

<ExamplePair>
<ExampleProse>

`time.Now()` returns the current local time. Access individual components with methods like `Year()`, `Month()`, `Day()`, `Hour()`, `Minute()`, `Second()`, and `Weekday()`.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now)

    fmt.Println(now.Year(), now.Month(), now.Day())
    fmt.Println(now.Hour(), now.Minute(), now.Second())
    fmt.Println(now.Weekday())
    fmt.Println(now.Unix())     // seconds since epoch
    fmt.Println(now.UnixNano()) // nanoseconds since epoch
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Build `time.Duration` values using named constants: `time.Second`, `time.Minute`, `time.Hour`, etc. Add or subtract a duration from a `time.Time` with `Add`. Subtract two `time.Time` values with `Sub` to get a `Duration`.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()

    // Add durations to a time
    inAnHour := now.Add(1 * time.Hour)
    fmt.Println(inAnHour)

    yesterday := now.Add(-24 * time.Hour)
    fmt.Println(yesterday)

    // Subtract two times to get a duration
    diff := now.Sub(yesterday)
    fmt.Println(diff)            // 24h0m0s
    fmt.Println(diff.Hours())    // 24
    fmt.Println(diff.Minutes())  // 1440
    fmt.Println(diff.Seconds())  // 86400
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`time.Since(t)` returns the elapsed time since `t`. `time.Until(t)` returns the duration until `t`. Both use the monotonic clock for accuracy. Compare two `time.Time` values with `Before`, `After`, and `Equal`.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Now()

    time.Sleep(2 * time.Millisecond) // simulate work

    elapsed := time.Since(start)
    fmt.Printf("elapsed: %v\n", elapsed)

    deadline := time.Now().Add(5 * time.Second)
    fmt.Printf("time until deadline: %v\n", time.Until(deadline))

    t1 := time.Now()
    t2 := t1.Add(time.Second)
    fmt.Println(t1.Before(t2)) // true
    fmt.Println(t1.After(t2))  // false
    fmt.Println(t1.Equal(t1))  // true
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`time.Time` contains both a wall clock reading and a monotonic clock reading. `time.Since` uses the monotonic clock, which is immune to NTP adjustments and DST transitions - always prefer it for measuring elapsed time. Use the wall clock (from `time.Now()`) for timestamps you store in databases or logs. Never compare two `time.Time` values with `==` when one may have been deserialized from a database: the monotonic component is stripped on round-trips through `time.Time.MarshalJSON` or SQL drivers, making the `Equal` method (which compares only wall time) the correct comparison. In HTTP handlers, record `time.Now()` at the top of the handler to measure end-to-end latency rather than calling `time.Since` with a captured start from middleware, where middleware overhead inflates the measurement.
</InProduction>


time.Time, time.Now, Duration arithmetic, time.Since and time.Until, Add and Sub, and comparisons with Before, After, and Equal.

Time


The `encoding/json` package encodes Go values to JSON and decodes JSON into Go values. Struct field tags (`json:"name"`) control the mapping between Go field names and JSON keys.

<ExamplePair>
<ExampleProse>

Encode a struct to JSON with `json.Marshal`. Struct tags map Go field names to JSON keys. Unexported fields are always omitted.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email,omitempty"` // omitted if empty
    pass  string // unexported - never included
}

func main() {
    u := User{ID: 1, Name: "Alice"}
    b, err := json.Marshal(u)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(b)) // {"id":1,"name":"Alice"}
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Decode JSON into a struct with `json.Unmarshal`. Unknown JSON fields are ignored by default; use `json.Decoder` with `DisallowUnknownFields` to reject them.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func main() {
    data := []byte(`{"id":42,"name":"Bob","role":"admin"}`)

    var u User
    if err := json.Unmarshal(data, &u); err != nil {
        panic(err)
    }
    fmt.Printf("%+v\n", u) // {ID:42 Name:Bob}
    // "role" was ignored
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Use `json.Encoder` and `json.Decoder` for streaming. They write to and read from any `io.Writer`/`io.Reader` without buffering the full JSON in memory.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
)

type Item struct {
    Name  string `json:"name"`
    Price int    `json:"price"`
}

func main() {
    items := []Item{{"Apple", 1}, {"Banana", 2}}

    var buf bytes.Buffer
    enc := json.NewEncoder(&buf)
    enc.SetIndent("", "  ")
    for _, item := range items {
        enc.Encode(item) // writes one JSON object per line
    }
    fmt.Print(buf.String())

    // Decode back
    dec := json.NewDecoder(&buf)
    for dec.More() {
        var item Item
        dec.Decode(&item)
        fmt.Printf("%+v\n", item)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`json.RawMessage` defers decoding of part of a JSON payload. Use it when the shape of a nested value depends on a sibling field.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "encoding/json"
    "fmt"
)

type Event struct {
    Type    string          `json:"type"`
    Payload json.RawMessage `json:"payload"`
}

type ClickPayload struct {
    X, Y int
}

func main() {
    raw := []byte(`{"type":"click","payload":{"X":10,"Y":20}}`)

    var event Event
    json.Unmarshal(raw, &event)

    if event.Type == "click" {
        var click ClickPayload
        json.Unmarshal(event.Payload, &click)
        fmt.Printf("click at (%d, %d)\n", click.X, click.Y)
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`omitempty` omits zero values - for strings that is `""`, for ints `0`, for pointers `nil`. This distinction matters when a client needs to distinguish "field not set" from "field explicitly set to zero". Use `*string` or a custom nullable type to represent fields that must be explicitly absent vs explicitly empty. For high-throughput services, consider `encoding/json/v2` (proposal) or `github.com/bytedance/sonic` / `github.com/json-iterator/go` as drop-in replacements with significantly better performance. Always use `json.Decoder` over `json.Unmarshal` for HTTP request bodies - it streams from the request body without loading the full payload into a byte slice.
</InProduction>


json.Marshal and Unmarshal, struct tags with omitempty, streaming with Encoder/Decoder, custom marshalers, and json.RawMessage for deferred decoding.