Go fmt Package

fmt.Print("Hello", "World")       // HelloWorld   (no space between strings)
fmt.Print(1, 2, 3)                // 1 2 3       (spaces between non-strings)

fmt.Println("Hello", "World")    // Hello World\n
fmt.Println(42, true)            // 42 true\n

name, age := "Alice", 30
fmt.Printf("Name: %s, Age: %d\n", name, age) // Name: Alice, Age: 30
fmt.Printf("%v %v %v\n", 1, "two", true)     // 1 two true

// Sprintf returns a formatted string instead of printing it
s := fmt.Sprintf("Hello, %s! You are %d years old.", "Bob", 25)
// s = "Hello, Bob! You are 25 years old."

url := fmt.Sprintf("https://api.example.com/users/%d", userID)

// Sprint — like Print but returns a string
s2 := fmt.Sprint("count:", 42)    // "count:42"  (no space: string + non-string)
s3 := fmt.Sprint(1, 2, 3)         // "1 2 3"    (spaces between non-strings)

// Sprintln — always adds spaces and a trailing newline
s4 := fmt.Sprintln("Hello", "World") // "Hello World\n"

// Write to stderr
fmt.Fprintf(os.Stderr, "error: %v\n", err)

// Write to a file
f, _ := os.Create("out.txt")
fmt.Fprintf(f, "result: %d\n", 42)

// Write to a buffer (bytes.Buffer implements io.Writer)
var buf bytes.Buffer
fmt.Fprintf(&buf, "Hello, %s!", "World")
s := buf.String()   // "Hello, World!"

// Write to an HTTP response (http.ResponseWriter is an io.Writer)
fmt.Fprintf(w, "Status: %s\n", status)

// Fprintf returns (n int, err error) — bytes written and any write error
n, err := fmt.Fprintf(f, "%d\n", 99)

type Point struct{ X, Y int }
p := Point{1, 2}

fmt.Printf("%v\n",  p)   // {1 2}          — default format
fmt.Printf("%+v\n", p)   // {X:1 Y:2}      — with field names
fmt.Printf("%#v\n", p)   // main.Point{X:1, Y:2} — Go syntax
fmt.Printf("%T\n",  p)   // main.Point     — type name
fmt.Printf("%v\n",  42)  // 42
fmt.Printf("%v\n", true) // true
fmt.Printf("%v\n", []int{1, 2, 3}) // [1 2 3]

fmt.Printf("|%6d|\n", 42)      // |    42|   right-aligned, padded with spaces
fmt.Printf("|%-6d|\n", 42)     // |42    |   left-aligned
fmt.Printf("|%06d|\n", 42)     // |000042|   zero-padded
fmt.Printf("|%+6d|\n", 42)     // |   +42|   always show sign

fmt.Printf("|%10s|\n", "hi")   // |        hi|   right-aligned string
fmt.Printf("|%-10s|\n", "hi")  // |hi        |   left-aligned string

fmt.Printf("%.2f\n", 3.14159)    // 3.14
fmt.Printf("%.4f\n", 3.14159)    // 3.1416
fmt.Printf("%8.2f\n", 3.14159)   // |    3.14|   width 8, 2 decimal places

fmt.Printf("%.5s\n", "Hello, World") // Hello   — truncate string to 5 chars

// Use * to pass width/precision as an argument
fmt.Printf("%*d\n", 8, 42)         // |      42|
fmt.Printf("%.*f\n", 3, 3.14159)   // 3.142

rows := []struct{ name string; score float64 }{
    {"Alice", 98.5},
    {"Bob", 87.123},
    {"Charlie", 100.0},
}
fmt.Printf("%-10s  %6s\n", "Name", "Score")
fmt.Printf("%-10s  %6s\n", "----------", "------")
for _, r := range rows {
    fmt.Printf("%-10s  %6.1f\n", r.name, r.score)
}
// Name        Score
// ----------  ------
// Alice         98.5
// Bob           87.1
// Charlie      100.0

type Direction int

const (
    North Direction = iota
    South
    East
    West
)

func (d Direction) String() string {
    return [...]string{"North", "South", "East", "West"}[d]
}

fmt.Println(North)          // North   (not 0)
fmt.Printf("%v\n", South)   // South
fmt.Printf("%s\n", East)    // East
fmt.Printf("%d\n", West)    // 3  (%d bypasses String())

type Color struct{ R, G, B uint8 }

func (c Color) String() string {
    return fmt.Sprintf("#%02X%02X%02X", c.R, c.G, c.B)
}

func (c Color) GoString() string {
    return fmt.Sprintf("Color{R:%d, G:%d, B:%d}", c.R, c.G, c.B)
}

red := Color{255, 0, 0}
fmt.Printf("%v\n",  red) // #FF0000
fmt.Printf("%#v\n", red) // Color{R:255, G:0, B:0}

// Simple error with context (no wrapping)
err := fmt.Errorf("user %d not found", userID)

// %w wraps the original error — callers can unwrap it
func loadUser(id int) (*User, error) {
    u, err := db.Query(id)
    if err != nil {
        return nil, fmt.Errorf("loadUser %d: %w", id, err)
    }
    return u, nil
}

// The caller can still inspect the original error
_, err = loadUser(99)
errors.Is(err, sql.ErrNoRows)  // true — unwraps through the chain

// Sscanf(input, format, &vars...) → n int, err error
var name string
var age  int
n, err := fmt.Sscanf("Alice 30", "%s %d", &name, &age)
// n=2, err=nil, name="Alice", age=30

// Parse a log timestamp
var hour, min, sec int
fmt.Sscanf("14:05:09", "%d:%d:%d", &hour, &min, &sec)
// hour=14, min=5, sec=9

// Scan from stdin (blocks until user presses Enter)
var x int
fmt.Scan(&x)

// Scanf — like Scan but with a format string
var s string
fmt.Scanf("%s", &s)