
Go's `regexp` package uses the RE2 engine, which guarantees linear-time matching. Compile patterns once and reuse them; compiling per request is a common performance bug.

<ExamplePair>
<ExampleProse>

Compile a pattern with `regexp.Compile` (returns an error) or `regexp.MustCompile` (panics on invalid pattern - correct for package-level variables). Test a match with `MatchString`.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "regexp"
)

// Compile once at package level.
var emailRE = regexp.MustCompile(`^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$`)

func main() {
    fmt.Println(emailRE.MatchString("user@example.com")) // true
    fmt.Println(emailRE.MatchString("not-an-email"))      // false
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`FindString` returns the first match. `FindAllString` returns all matches. Pass `-1` as the count to get all matches; pass `n` to limit to the first n.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile(`\d+`)
    s := "I have 3 cats and 12 dogs"

    fmt.Println(re.FindString(s))         // 3
    fmt.Println(re.FindAllString(s, -1))  // [3 12]
    fmt.Println(re.FindAllString(s, 1))   // [3]
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Replace matches with `ReplaceAllString` (literal replacement) or `ReplaceAllStringFunc` (replacement computed by a function).

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "regexp"
    "strings"
)

func main() {
    re := regexp.MustCompile(`\b\w+\b`)
    s := "hello world"

    // Replace every word with its uppercase version.
    result := re.ReplaceAllStringFunc(s, strings.ToUpper)
    fmt.Println(result) // HELLO WORLD

    // Simple literal replacement.
    re2 := regexp.MustCompile(`\d+`)
    fmt.Println(re2.ReplaceAllString(s, "[NUM]")) // hello world (no digits)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Named capture groups let you extract labeled sub-matches by name. `SubexpNames` maps indices to names; `FindStringSubmatch` returns matched groups.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`)

    match := re.FindStringSubmatch("Today is 2026-04-25")
    names := re.SubexpNames()

    result := map[string]string{}
    for i, name := range names {
        if i != 0 && name != "" {
            result[name] = match[i]
        }
    }

    fmt.Println(result) // map[day:25 month:04 year:2026]
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Compile regexps once at package level with `MustCompile` - RE2 guarantees linear-time matching on input length, but compilation itself is expensive. Compiling inside a function called per request is a common performance bug that shows up clearly in profiling. Go's RE2 engine does not support lookaheads, lookbehinds, or backreferences - for patterns that require them, consider a purpose-built parser instead. For simple prefix/suffix checks, `strings.HasPrefix` and `strings.HasSuffix` are faster than a regexp match.
</InProduction>


regexp.Compile, MustCompile, MatchString, FindString, FindAllString, ReplaceAllString, and named capture groups.

Regular Expressions


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.

JSON


Go's template packages (`text/template` and `html/template`) render dynamic content by combining a template string with data. `html/template` automatically escapes HTML and should always be used for browser output. Both packages share the same API.

<ExamplePair>
<ExampleProse>

Parse and execute a basic template. Template actions use `{{` and `}}` delimiters. `.` refers to the data passed to Execute.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "os"
    "text/template"
)

func main() {
    tmpl := template.Must(template.New("greeting").Parse(
        "Hello, {{.Name}}! You have {{.Count}} messages.\n",
    ))

    data := struct {
        Name  string
        Count int
    }{"Alice", 3}

    tmpl.Execute(os.Stdout, data)
    // Hello, Alice! You have 3 messages.
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Use `{{if}}`, `{{else}}`, `{{range}}`, and `{{with}}` to control output. `{{range}}` iterates over slices, maps, and channels.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "os"
    "text/template"
)

const tmplText = `
{{- range .Items}}
  - {{.}}
{{- end}}
{{if .HasMore}}... and more{{end}}
`

func main() {
    tmpl := template.Must(template.New("list").Parse(tmplText))

    data := struct {
        Items   []string
        HasMore bool
    }{
        Items:   []string{"Go", "Rust", "Python"},
        HasMore: true,
    }

    tmpl.Execute(os.Stdout, data)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Add custom functions with `template.FuncMap` before parsing. Functions must be registered before the template is parsed.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "os"
    "strings"
    "text/template"
)

func main() {
    funcMap := template.FuncMap{
        "upper": strings.ToUpper,
        "greet": func(name string) string {
            return "Hello, " + name + "!"
        },
    }

    tmpl := template.Must(
        template.New("fn").Funcs(funcMap).Parse(`{{upper .Name}} - {{greet .Name}}`),
    )

    tmpl.Execute(os.Stdout, map[string]string{"Name": "world"})
    // WORLD - Hello, world!
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Use `html/template` (same API) when generating HTML. It escapes values automatically to prevent XSS.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "html/template"
    "os"
)

func main() {
    tmpl := template.Must(template.New("page").Parse(
        `<p>Welcome, {{.Username}}!</p>`,
    ))

    // If Username contains HTML, it is escaped automatically.
    data := struct{ Username string }{`<script>alert(1)</script>`}
    tmpl.Execute(os.Stdout, data)
    // <p>Welcome, &lt;script&gt;alert(1)&lt;/script&gt;!</p>
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Always use `html/template` (not `text/template`) for any output that reaches a browser - it contextually escapes HTML, CSS, JavaScript, and URL attributes and prevents XSS. `text/template` is for non-HTML output: config files, code generation, email plain text, Markdown. Parse templates once at startup (`var tmpl = template.Must(template.ParseFiles(...))`) rather than per request - parsing is expensive and the compiled template is safe for concurrent use. `template.Must` panics on parse errors, which is correct for startup-time template loading.
</InProduction>


text/template and html/template - template actions, custom functions, parsing once at startup, and avoiding XSS with html/template.