
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.

String Formatting


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


The `strings` package provides utility functions for searching, splitting, joining, trimming, and transforming strings. For efficient string construction in loops, `strings.Builder` avoids the O(n²) cost of repeated concatenation.

<ExamplePair>
<ExampleProse>

Search and test string content with Contains, HasPrefix, HasSuffix, Count, and Index.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "Hello, Go World"

    fmt.Println(strings.Contains(s, "Go"))      // true
    fmt.Println(strings.HasPrefix(s, "Hello"))  // true
    fmt.Println(strings.HasSuffix(s, "World"))  // true
    fmt.Println(strings.Count(s, "o"))          // 3
    fmt.Println(strings.Index(s, "Go"))         // 7
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Split strings into parts and rejoin them with Join. Replace one or all occurrences with Replace and ReplaceAll.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "strings"
)

func main() {
    csv := "one,two,three"
    parts := strings.Split(csv, ",")
    fmt.Println(parts)                          // [one two three]
    fmt.Println(strings.Join(parts, " | "))     // one | two | three

    s := "aababc"
    fmt.Println(strings.Replace(s, "a", "x", 2))  // xxbabc (first 2 only)
    fmt.Println(strings.ReplaceAll(s, "a", "x"))   // xxbxbc
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Convert case and trim whitespace or specific characters. Repeat a string N times.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.ToUpper("hello")) // HELLO
    fmt.Println(strings.ToLower("HELLO")) // hello

    padded := "  hello  "
    fmt.Println(strings.TrimSpace(padded))      // "hello"
    fmt.Println(strings.Trim(padded, " "))       // "hello"
    fmt.Println(strings.TrimLeft(padded, " "))   // "hello  "
    fmt.Println(strings.TrimRight(padded, " "))  // "  hello"

    fmt.Println(strings.Repeat("ab", 3)) // ababab
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Use strings.Builder to build strings efficiently in a loop. It avoids allocating a new string on every append.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "strings"
)

func join(words []string, sep string) string {
    var b strings.Builder
    for i, w := range words {
        if i > 0 {
            b.WriteString(sep)
        }
        b.WriteString(w)
    }
    return b.String()
}

func main() {
    result := join([]string{"foo", "bar", "baz"}, ", ")
    fmt.Println(result) // foo, bar, baz
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`strings.Builder` is the correct way to build strings in a loop - it writes to an internal byte buffer and converts once at the end. Repeated `+` concatenation inside a loop creates a new string allocation per iteration: O(n²) total work and GC pressure. `strings.Title` is deprecated - use `golang.org/x/text/cases` for locale-aware title casing, since `strings.Title` does not handle Unicode correctly. For contains/prefix/suffix checks on byte slices rather than strings, use the `bytes` package equivalents to avoid an allocation.
</InProduction>


The strings package - searching, splitting, trimming, replacing, and building strings efficiently with strings.Builder.