
The `os` package provides functions for creating, listing, and removing directories. Most operations mirror the familiar Unix commands but are portable across operating systems.

<ExamplePair>
<ExampleProse>

`os.Mkdir` creates a single directory. It fails if the path already exists or if any intermediate directory is missing. `os.MkdirAll` creates the full path including all intermediate directories, and is idempotent - it returns `nil` if the directory already exists.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    // Create a single directory - fails if parent doesn't exist
    err := os.Mkdir("subdir", 0755)
    if err != nil {
        panic(err)
    }

    // Create a full path - idempotent, no error if already exists
    err = os.MkdirAll("a/b/c", 0755)
    if err != nil {
        panic(err)
    }

    fmt.Println("directories created")
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`os.ReadDir` lists the entries in a directory, sorted by name. Each `fs.DirEntry` provides the name, type (file or directory), and - via `Info()` - the full `fs.FileInfo`.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    entries, err := os.ReadDir(".")
    if err != nil {
        panic(err)
    }

    for _, e := range entries {
        kind := "file"
        if e.IsDir() {
            kind = "dir "
        }
        fmt.Printf("%s %s\n", kind, e.Name())
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`os.Remove` deletes a single file or empty directory. `os.RemoveAll` deletes a path and everything under it - equivalent to `rm -rf`. `os.Getwd` returns the current working directory; `os.Chdir` changes it.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    os.MkdirAll("tmp/nested", 0755)

    // Remove a single empty directory
    os.Remove("tmp/nested")

    // Remove a directory tree (rm -rf equivalent)
    os.RemoveAll("tmp")

    wd, err := os.Getwd()
    if err != nil {
        panic(err)
    }
    fmt.Println("working dir:", wd)
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`os.RemoveAll` is equivalent to `rm -rf` - no confirmation, no recycle bin, no undo. In production code, validate that the path is inside a known prefix (using `filepath.Abs` and `strings.HasPrefix`) before calling it; a bug that constructs a wrong path can delete critical data. `os.MkdirAll` is idempotent - prefer it over a stat-then-mkdir sequence, which has a TOCTOU race. `os.ReadDir` is the modern replacement for `ioutil.ReadDir` (deprecated) and is faster because it uses the `fs.DirEntry` type that avoids a `stat` call per entry when only the name and type are needed. For recursive traversal, use `filepath.WalkDir` rather than calling `os.ReadDir` recursively - it handles errors consistently and lets you skip subtrees by returning `fs.SkipDir`. Avoid `os.Chdir` in server code - it changes the working directory for the whole process, not just the current goroutine.
</InProduction>


os.Mkdir, os.MkdirAll, os.ReadDir, os.Remove, os.RemoveAll, os.Getwd, and os.Chdir for directory operations.

Directories


`os.CreateTemp` and `os.MkdirTemp` create temporary files and directories with unique, non-colliding names. They are the safe replacement for manual temp-file construction, which is vulnerable to race conditions.

<ExamplePair>
<ExampleProse>

`os.CreateTemp` creates a new file in the system temp directory (or a specified dir) with a unique name built from the given pattern. The returned `*os.File` is open for reading and writing. Clean up with `os.Remove` when done.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    // "" uses os.TempDir(); the name will be something like /tmp/example-1234567890
    f, err := os.CreateTemp("", "example-")
    if err != nil {
        panic(err)
    }
    defer os.Remove(f.Name()) // clean up on exit
    defer f.Close()

    fmt.Println("temp file:", f.Name())

    _, err = f.WriteString("temporary content\n")
    if err != nil {
        panic(err)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`os.MkdirTemp` creates a temporary directory. Use it when you need a temporary workspace for multiple files. Clean up the whole tree with `os.RemoveAll` when done.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
    "path/filepath"
)

func main() {
    dir, err := os.MkdirTemp("", "workspace-")
    if err != nil {
        panic(err)
    }
    defer os.RemoveAll(dir) // clean up entire directory

    fmt.Println("temp dir:", dir)

    // Create files inside the temp directory
    p := filepath.Join(dir, "data.txt")
    err = os.WriteFile(p, []byte("hello"), 0600)
    if err != nil {
        panic(err)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

In tests, use `t.TempDir()` instead of `os.MkdirTemp`. It returns a unique directory that the test runner removes automatically when the test completes - no manual cleanup needed.

</ExampleProse>
<ExampleCode>

```go
package mypackage_test

import (
    "os"
    "path/filepath"
    "testing"
)

func TestWriteConfig(t *testing.T) {
    dir := t.TempDir() // cleaned up automatically after the test

    cfg := filepath.Join(dir, "config.json")
    err := os.WriteFile(cfg, []byte(`{"debug":true}`), 0600)
    if err != nil {
        t.Fatal(err)
    }

    // test logic that reads from cfg...
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Always clean up temp files and directories, preferably with `defer` immediately after creation - a crash or early return without the defer running leaves them on disk. Temp files created by `os.CreateTemp` are not deleted on process exit. In tests, `t.TempDir()` is always preferable to manual `os.MkdirTemp` + `defer os.RemoveAll` - the test runner handles cleanup even if the test panics. When writing to a temp file and then renaming it over a real file (atomic write pattern), create the temp file in the same directory as the target so the rename stays on the same filesystem - cross-device renames fail with `EXDEV`. Set restrictive permissions (`0600` for files, `0700` for directories) on temp paths that contain sensitive data; `os.TempDir()` is world-readable on Linux by default.
</InProduction>


os.CreateTemp and os.MkdirTemp for creating temporary files and directories, deferred cleanup, and t.TempDir in tests.

Temporary Files and Directories


The `path/filepath` package manipulates file paths in an OS-aware way. It handles the separator difference between Unix (`/`) and Windows (`\`) so path logic is portable across platforms.

<ExamplePair>
<ExampleProse>

`filepath.Join` constructs a path from components, using the correct separator for the current OS. It also cleans redundant separators and `.` or `..` components.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "path/filepath"
)

func main() {
    p := filepath.Join("dir", "subdir", "file.txt")
    fmt.Println(p)              // dir/subdir/file.txt

    fmt.Println(filepath.Dir(p))  // dir/subdir
    fmt.Println(filepath.Base(p)) // file.txt
    fmt.Println(filepath.Ext(p))  // .txt
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`filepath.Abs` resolves a relative path to an absolute one using the current working directory. Useful when you need a canonical path to log, store in a database, or compare against other paths.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "path/filepath"
)

func main() {
    abs, err := filepath.Abs("config.yaml")
    if err != nil {
        panic(err)
    }
    fmt.Println(abs) // /home/user/project/config.yaml

    // filepath.Clean resolves . and .. without hitting the filesystem
    fmt.Println(filepath.Clean("a/b/../c")) // a/c
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`filepath.WalkDir` traverses a directory tree, calling a function for every file and directory it encounters. It is faster than the older `filepath.Walk` because it does not `stat` each entry separately.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "io/fs"
    "path/filepath"
)

func main() {
    err := filepath.WalkDir(".", func(path string, d fs.DirEntry, err error) error {
        if err != nil {
            return err
        }
        if d.IsDir() {
            fmt.Println("dir: ", path)
        } else {
            fmt.Println("file:", path)
        }
        return nil
    })
    if err != nil {
        panic(err)
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Always use `filepath.Join` (not `path.Join` or string concatenation) to build file paths - `filepath` handles OS-specific separators, while `path` is for URL-style slash paths only. `filepath.WalkDir` (Go 1.16+) is faster than `filepath.Walk` because it receives the `fs.DirEntry` directly from the directory read, avoiding a separate `stat` syscall per entry; prefer it for directory traversal. To skip an entire subtree in `WalkDir`, return `fs.SkipDir` when the callback is called with a directory entry. When building paths from user-supplied input, validate that the resolved absolute path starts with a known prefix before accessing the file - otherwise a `../../../etc/passwd` traversal bypasses the intended directory boundary. Use `filepath.Glob` for simple pattern matching on a single directory level; for recursive matching use `WalkDir` with an `filepath.Match` check inside the callback.
</InProduction>


filepath.Join, filepath.Dir, filepath.Base, filepath.Ext, filepath.Abs, and filepath.WalkDir for directory traversal.