
`os.Args` is a `[]string` containing the raw command-line arguments. `os.Args[0]` is the path to the running binary; `os.Args[1:]` contains everything the user typed after the binary name.

<ExamplePair>
<ExampleProse>

Access `os.Args` directly for simple tools that take positional arguments. The slice is always non-nil - when no arguments are given, `os.Args` has length 1 (just the binary name).

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    args := os.Args

    fmt.Println("binary:", args[0])
    fmt.Println("args:  ", args[1:])
    fmt.Println("count: ", len(args)-1)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Check argument count before indexing to avoid an index-out-of-range panic. Access individual arguments by index after validating length.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Fprintln(os.Stderr, "usage: greet <name>")
        os.Exit(1)
    }

    name := os.Args[1]
    fmt.Printf("Hello, %s!\n", name)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Iterate over all provided arguments with a range loop over `os.Args[1:]`.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
    "strings"
)

func main() {
    args := os.Args[1:]

    if len(args) == 0 {
        fmt.Println("no arguments provided")
        return
    }

    fmt.Println("joined:", strings.Join(args, ", "))

    for i, arg := range args {
        fmt.Printf("  [%d] %s\n", i, arg)
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`os.Args` is appropriate for positional arguments in simple, single-purpose tools. For anything with optional flags (`--verbose`, `--output=file`), use the `flag` package - it generates consistent help text and handles the `--` convention automatically. For tools with subcommands (`git commit`, `docker run`), use `flag.FlagSet` per subcommand or a library like cobra. Parsing `os.Args` by hand for complex CLIs produces fragile code that fails on edge cases (arguments with spaces, `--` end-of-flags, `-` as stdin indicator) that users expect to work. Never use `os.Args[0]` to infer the install location of the binary at runtime - use `os.Executable()` instead, which resolves symlinks.
</InProduction>


os.Args provides raw access to command-line arguments as a string slice, with os.Args[0] holding the binary name and os.Args[1:] holding the user-supplied arguments.

Command-Line Arguments


The `flag` package parses named command-line flags. Declare flags before calling `flag.Parse()`, then access their values through the returned pointers or with `flag.Args()` for remaining positional arguments.

<ExamplePair>
<ExampleProse>

Declare typed flags with `flag.String`, `flag.Int`, `flag.Bool`, and `flag.Duration`. Each returns a pointer to the flag's value. Call `flag.Parse()` to process `os.Args[1:]` before reading any flag value.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "flag"
    "fmt"
)

func main() {
    host := flag.String("host", "localhost", "server hostname")
    port := flag.Int("port", 8080, "server port")
    verbose := flag.Bool("verbose", false, "enable verbose output")

    flag.Parse()

    fmt.Printf("host: %s\n", *host)
    fmt.Printf("port: %d\n", *port)
    fmt.Printf("verbose: %v\n", *verbose)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

After `flag.Parse()`, `flag.Args()` returns the remaining non-flag positional arguments. This lets a command accept both flags and positional arguments in any order.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "flag"
    "fmt"
)

func main() {
    output := flag.String("output", "stdout", "output destination")
    flag.Parse()

    positional := flag.Args()
    fmt.Printf("output: %s\n", *output)
    fmt.Printf("files:  %v\n", positional)
}
// Usage: ./tool --output=file.txt a.go b.go
// output: file.txt
// files:  [a.go b.go]
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Override `flag.Usage` to customize the help message shown for `-help` or `-h`. The default usage lists all flags alphabetically with their defaults and descriptions.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "flag"
    "fmt"
    "os"
)

func main() {
    timeout := flag.Duration("timeout", 0, "request timeout (0 = no timeout)")

    flag.Usage = func() {
        fmt.Fprintf(os.Stderr, "Usage: fetch [flags] <url>\n\nFlags:\n")
        flag.PrintDefaults()
    }

    flag.Parse()

    if flag.NArg() == 0 {
        flag.Usage()
        os.Exit(1)
    }

    fmt.Printf("fetching %s (timeout: %v)\n", flag.Arg(0), *timeout)
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
The `flag` package is sufficient for single-command tools. Always set meaningful defaults and usage strings - they appear in the auto-generated `-help` output and are the primary documentation for most CLI tools. Always call `flag.Parse()` before reading any flag value; accessing a flag value before `flag.Parse()` returns the declared default, not the user-supplied value, which masks bugs silently. The `flag` package accepts both one- and two-dash forms: `-name value`, `-name=value`, `--name value`, and `--name=value` are all equivalent. What it does not support is combined short flags (`-abc` meaning `-a -b -c`) or positional-only GNU-style `--` termination; for those patterns use a third-party library like `pflag` or `cobra`. For integration tests of CLI tools, `flag.CommandLine` can be reset between calls, but it is generally cleaner to refactor the tool so the flag set is a parameter rather than global state.
</InProduction>


The flag package parses named flags (--name=value or --name value), generates help text automatically, and provides typed accessors for string, int, bool, and duration values.

Command-Line Flags


Go ships a test runner in the standard library. Test files end in `_test.go` and contain functions named `TestXxx` or `BenchmarkXxx`. Run tests with `go test ./...`.

<ExamplePair>
<ExampleProse>

A test function accepts `*testing.T`. Call `t.Error` or `t.Errorf` to mark a failure without stopping the test. Call `t.Fatal` or `t.Fatalf` to mark a failure and stop immediately.

</ExampleProse>
<ExampleCode>

```go
// math_test.go
package main

import "testing"

func add(a, b int) int { return a + b }

func TestAdd(t *testing.T) {
    got := add(2, 3)
    want := 5
    if got != want {
        t.Errorf("add(2, 3) = %d; want %d", got, want)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Table-driven tests loop over a slice of cases. Each entry specifies inputs and the expected output. When a case fails, `t.Errorf` reports the case name so you can identify it without reading the data manually.

</ExampleProse>
<ExampleCode>

```go
func TestAddTable(t *testing.T) {
    cases := []struct {
        name    string
        a, b    int
        want    int
    }{
        {"positive", 2, 3, 5},
        {"zero", 0, 0, 0},
        {"negative", -1, -2, -3},
    }

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            got := add(tc.a, tc.b)
            if got != tc.want {
                t.Errorf("got %d; want %d", got, tc.want)
            }
        })
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Benchmark functions accept `*testing.B`. The `b.N` field is set by the runner to the number of iterations needed to get a stable measurement. Run with `go test -bench=. -benchmem` to include allocation counts.

</ExampleProse>
<ExampleCode>

```go
func BenchmarkAdd(b *testing.B) {
    for range b.N {
        add(2, 3)
    }
}

// With expensive setup:
func BenchmarkAddSetup(b *testing.B) {
    data := make([]int, 1000) // expensive setup
    b.ResetTimer()            // exclude setup from measurement
    b.ReportAllocs()          // surface allocation counts

    for range b.N {
        _ = data[0] + data[1]
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Table-driven tests are idiomatic Go - they make adding cases trivial and the failure output shows which case failed by name. Use `t.Helper()` in assertion helper functions so failure line numbers point to the test that called the helper, not inside the helper itself. Benchmarks require `b.ResetTimer()` when setup is expensive, so setup time is excluded from the reported ns/op. `b.ReportAllocs()` surfaces allocation counts in the output, which is often more diagnostic than raw speed. Place fixture files under a `testdata/` directory in the package - the `go test` tool changes to the package directory before running, so `os.Open("testdata/input.json")` works without path arithmetic. Use `t.TempDir()` for temporary directories in tests; it is automatically cleaned up when the test ends.
</InProduction>


Go's built-in testing package provides TestXxx functions, table-driven tests, BenchmarkXxx functions, and the testdata directory convention without external frameworks.