Go os Package

// Getenv — empty string if not set (can't distinguish unset vs "")
host := os.Getenv("DB_HOST")

// LookupEnv — second return tells you if the key exists
port, ok := os.LookupEnv("DB_PORT")
if !ok {
    port = "5432"  // use default
}

// Setenv / Unsetenv
os.Setenv("APP_ENV", "production")
os.Unsetenv("APP_ENV")

// Environ — all env vars as "KEY=VALUE" strings
for _, e := range os.Environ() {
    fmt.Println(e)  // PATH=/usr/bin:..., HOME=/Users/alice, ...
}

// Clearenv — remove all environment variables
os.Clearenv()

// Open — read-only
f, err := os.Open("data.txt")
if err != nil {
    log.Fatal(err)
}
defer f.Close()
// use f as an io.Reader (bufio.Scanner, json.Decoder, etc.)

// Create — create or truncate for writing
out, err := os.Create("output.txt")
if err != nil {
    log.Fatal(err)
}
defer out.Close()
fmt.Fprintln(out, "line 1")
fmt.Fprintln(out, "line 2")

// OpenFile — full control over flags and permissions
f2, err := os.OpenFile("log.txt",
    os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
defer f2.Close()
fmt.Fprintln(f2, "appended line")

os.O_RDONLY  // read-only (default for Open)
os.O_WRONLY  // write-only
os.O_RDWR   // read+write
os.O_APPEND  // append on each write
os.O_CREATE  // create if not exists
os.O_EXCL    // error if file exists (with O_CREATE)
os.O_TRUNC   // truncate to zero on open
os.O_SYNC    // synchronous I/O

// Combine with bitwise OR
// Read+write, create if absent, don't truncate:
flags := os.O_RDWR | os.O_CREATE

// ReadDir returns entries sorted by name
entries, err := os.ReadDir(".")
if err != nil {
    log.Fatal(err)
}
for _, e := range entries {
    fmt.Printf("%s  dir=%v\n", e.Name(), e.IsDir())
}

// Get full FileInfo if needed
for _, e := range entries {
    info, _ := e.Info()
    fmt.Printf("%-20s %6d bytes\n", e.Name(), info.Size())
}

// Temp files and directories
f, _ := os.CreateTemp("", "prefix-*.txt")
defer os.Remove(f.Name())

dir, _ := os.MkdirTemp("", "workdir-*")
defer os.RemoveAll(dir)

import (
    "errors"
    "io/fs"
)

_, err := os.Open("missing.txt")

// Modern style — works through wrapped errors
errors.Is(err, fs.ErrNotExist)    // true
errors.Is(err, fs.ErrPermission)  // false
errors.Is(err, fs.ErrExist)       // false

// Legacy helpers (don't unwrap)
os.IsNotExist(err)    // true
os.IsExist(err)       // true when creating an already-existing file
os.IsPermission(err)  // true for EACCES / EPERM
os.IsTimeout(err)     // true for timeout errors

// Extract the underlying *PathError for details
var pe *os.PathError
if errors.As(err, &pe) {
    fmt.Println(pe.Op, pe.Path, pe.Err)
    // open missing.txt no such file or directory
}

import "os/exec"

// Output — run and capture stdout; returns error if exit code != 0
out, err := exec.Command("git", "rev-parse", "HEAD").Output()
if err != nil {
    log.Fatal(err)
}
fmt.Println(strings.TrimSpace(string(out)))

// CombinedOutput — capture stdout + stderr together
out2, err := exec.Command("go", "build", "./...").CombinedOutput()
if err != nil {
    fmt.Fprintf(os.Stderr, "build failed:\n%s\n", out2)
}

// Run — just run, no output capture
err = exec.Command("go", "fmt", "./...").Run()

cmd := exec.Command("ffmpeg", "-i", "input.mp4", "output.mp3")

// Pipe stdout/stderr to our own writers
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr

// Provide stdin
cmd.Stdin = strings.NewReader("input data")

// Set working directory
cmd.Dir = "/tmp/work"

// Override or extend environment
cmd.Env = append(os.Environ(), "GOFLAGS=-mod=vendor")

if err := cmd.Run(); err != nil {
    var exitErr *exec.ExitError
    if errors.As(err, &exitErr) {
        fmt.Println("exit code:", exitErr.ExitCode())
    }
}