
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.

String Functions


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


Recover is a built-in that catches panics in a deferred function. When called inside a defer, recover returns the value passed to panic; called outside a defer, it returns nil. Recover is used at package boundaries to convert panics to errors (e.g., in HTTP handlers) or to log a panic with context before crashing.

<ExamplePair>
<ExampleProse>

Recover inside a deferred function catches a panic and returns the panic value. If no panic is in flight, recover returns nil.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
)

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("recovered:", r)
        }
    }()

    fmt.Println("before panic")
    panic("something went wrong")
    fmt.Println("never reached")
}

// Output:
// before panic
// recovered: something went wrong
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Safe divide: a function that panics on division by zero. A caller can recover to handle the error gracefully.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
)

func safeDivide(a, b int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            // Convert panic to error
            err = fmt.Errorf("divide panic: %v", r)
            result = 0
        }
    }()

    if b == 0 {
        panic("divide by zero")
    }
    return a / b, nil
}

func main() {
    res, err := safeDivide(10, 2)
    fmt.Println(res, err) // 5 <nil>

    res, err = safeDivide(10, 0)
    fmt.Println(res, err) // 0 divide panic: divide by zero
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Re-panicking: a defer that logs a panic and re-panics to propagate it up the stack.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "runtime/debug"
)

func criticalOperation() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("CRITICAL ERROR:", r)
            fmt.Println("Stack trace:")
            fmt.Println(string(debug.Stack()))
            panic(r) // re-panic
        }
    }()

    // Simulate a critical failure
    panic("database connection lost")
}

func main() {
    // The program will crash because criticalOperation re-panics
    criticalOperation()
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

HTTP handler that recovers panics and converts them to 500 responses. This is the standard pattern in web frameworks - panic in a handler is caught at the framework level, logged with stack trace, and a 500 is sent to the client.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "log"
    "net/http"
    "runtime/debug"
)

func recoverMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("PANIC in %s %s: %v\n", r.Method, r.RequestURI, err)
                log.Printf("Stack:\n%s", debug.Stack())
                w.WriteHeader(http.StatusInternalServerError)
                fmt.Fprintf(w, "Internal Server Error")
            }
        }()
        next.ServeHTTP(w, r)
    })
}

func panicHandler(w http.ResponseWriter, r *http.Request) {
    panic("deliberate panic")
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/panic", panicHandler)

    handler := recoverMiddleware(mux)
    log.Println("server listening on :8080")
    log.Fatal(http.ListenAndServe(":8080", handler))
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Recover is primarily for converting panics to errors at package boundaries (HTTP handlers, RPC servers, goroutine launches). Never silently swallow a panic - always log the error with a stack trace (use runtime/debug.Stack()) before converting to an error return or sending a response. Never recover inside a goroutine that you launched unless that goroutine is a long-lived service; panics in background goroutines that you don't recover will crash the process. The pattern: HTTP handler or RPC framework catches panic → logs with stack trace → responds with 500 or error → continues serving. Panics that reach the main goroutine should crash the process (use panic for programmer errors, not expected failures). If you find yourself recovering the same panic in multiple places, it's a sign that the panic should have been an error return instead.
</InProduction>


Recover from panics in deferred functions, re-panicking, and converting panics to errors at package boundaries.