
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.

Text Templates


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 `fmt` package provides print functions driven by format verbs. Go's verbs are distinct from C's `printf` - `%v` prints any value in a default format, `%+v` adds struct field names, and `%#v` prints a Go syntax representation useful for debugging.

<ExamplePair>
<ExampleProse>

The `%v` verb prints values in a human-readable default format. Add `+` for struct field names or `#` for Go syntax output.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Point struct {
    X, Y int
}

func main() {
    p := Point{3, 4}

    fmt.Printf("%v\n", p)   // {3 4}
    fmt.Printf("%+v\n", p)  // {X:3 Y:4}
    fmt.Printf("%#v\n", p)  // main.Point{X:3, Y:4}
    fmt.Printf("%T\n", p)   // main.Point
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Format integers with `%d` (decimal), `%b` (binary), `%o` (octal), `%x` (hex). Control width and zero-padding with width specifiers.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    n := 42
    fmt.Printf("%d\n", n)    // 42
    fmt.Printf("%b\n", n)    // 101010
    fmt.Printf("%o\n", n)    // 52
    fmt.Printf("%x\n", n)    // 2a
    fmt.Printf("%X\n", n)    // 2A

    // Width and padding
    fmt.Printf("%6d\n", n)   //     42 (right-aligned)
    fmt.Printf("%-6d|\n", n) // 42     (left-aligned)
    fmt.Printf("%06d\n", n)  // 000042 (zero-padded)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Format floats with `%f` (decimal), `%e` (scientific), `%g` (compact). Control precision with `%.Nf`.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    f := 3.14159
    fmt.Printf("%f\n", f)     // 3.141590
    fmt.Printf("%.2f\n", f)   // 3.14
    fmt.Printf("%8.2f\n", f)  //     3.14
    fmt.Printf("%e\n", f)     // 3.141590e+00
    fmt.Printf("%g\n", f)     // 3.14159
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Use `Sprintf` to produce a formatted string, `Fprintf` to write directly to an `io.Writer`, and `Errorf` to create formatted errors (with `%w` for wrapping).

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    // Sprintf returns a string
    msg := fmt.Sprintf("Hello, %s! You are %d years old.", "Alice", 30)
    fmt.Println(msg)

    // Fprintf writes to any io.Writer (here, os.Stderr)
    fmt.Fprintf(os.Stderr, "error: %s\n", "something went wrong")

    // Errorf creates an error; %w wraps the error for errors.Is / errors.As
    cause := fmt.Errorf("connection refused")
    err := fmt.Errorf("dial database: %w", cause)
    fmt.Println(err) // dial database: connection refused
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`%+v` and `%#v` are invaluable in debug logs and test failure messages - they surface field names and Go syntax without writing custom String() methods. Prefer `fmt.Fprintf(w, ...)` over `fmt.Sprintf(...) + w.Write(...)` to avoid an intermediate string allocation when writing to an `io.Writer`. Use `%w` in `fmt.Errorf` for wrappable errors; `%s` or `%v` create a new non-wrappable error that callers cannot inspect with `errors.Is` or `errors.As`.
</InProduction>


fmt verbs - %v, %+v, %#v, %T, width and precision, and choosing between Printf, Sprintf, and Fprintf.