Go File & Data

// Reads entire file into []byte in one call
data, err := os.ReadFile("config.json")
if err != nil {
    return fmt.Errorf("read config: %w", err)
}
fmt.Println(string(data))

// os.ReadFile is equivalent to:
// f, _ := os.Open(name)
// defer f.Close()
// io.ReadAll(f)

f, err := os.Open("data.txt")
if err != nil {
    return err
}
defer f.Close()

scanner := bufio.NewScanner(f)
for scanner.Scan() {
    line := scanner.Text()  // one line, no trailing \n
    fmt.Println(line)
}
if err := scanner.Err(); err != nil {
    return err
}

// Creates or overwrites the file atomically
data := []byte("hello, file\n")
err := os.WriteFile("out.txt", data, 0644)
if err != nil {
    return err
}

// Write a string directly
err = os.WriteFile("out.txt",
    []byte("content"), 0644)

f, err := os.Create("out.txt")  // create or truncate
if err != nil {
    return err
}
defer f.Close()

w := bufio.NewWriter(f)
fmt.Fprintln(w, "line 1")
fmt.Fprintln(w, "line 2")

// Must flush — buffered writes are not sent until Flush()
if err := w.Flush(); err != nil {
    return err
}

// Copy a file efficiently (32KB chunks internally)
src, _ := os.Open("input.txt")
defer src.Close()

dst, _ := os.Create("output.txt")
defer dst.Close()

n, err := io.Copy(dst, src)
fmt.Printf("copied %d bytes\n", n)

// io.CopyN — copy at most N bytes
io.CopyN(dst, src, 1024)

// bytes.Buffer — in-memory Reader and Writer
var buf bytes.Buffer
fmt.Fprintf(&buf, "hello %s", "world")
fmt.Println(buf.String())  // hello world

// strings.NewReader — turn a string into io.Reader
r := strings.NewReader("some data")
io.Copy(os.Stdout, r)

// io.ReadAll — drain a Reader into []byte
data, err := io.ReadAll(r)

u := User{ID: 1, Name: "Alice"}

// Compact JSON
data, err := json.Marshal(u)
// {"id":1,"name":"Alice","created_at":"0001-..."}

// Indented JSON for human readability
data, err = json.MarshalIndent(u, "", "  ")
if err != nil {
    return err
}
fmt.Println(string(data))

// Prefer Encoder when writing to http.ResponseWriter,
// os.File, or any io.Writer — avoids allocating []byte
enc := json.NewEncoder(os.Stdout)
enc.SetIndent("", "  ")

users := []User{{ID: 1, Name: "Alice"}}
if err := enc.Encode(users); err != nil {
    return err
}
// Encode appends a trailing newline automatically

payload := []byte(`{"id":1,"name":"Alice"}`)

var u User
if err := json.Unmarshal(payload, &u); err != nil {
    return fmt.Errorf("decode user: %w", err)
}
fmt.Println(u.Name)  // Alice

// Unmarshal unknown structure into map
var m map[string]any
json.Unmarshal(payload, &m)
fmt.Println(m["name"])  // Alice

// Decode from an HTTP response body or file
resp, _ := http.Get("https://api.example.com/user")
defer resp.Body.Close()

var u User
if err := json.NewDecoder(resp.Body).Decode(&u); err != nil {
    return err
}

// Reject unknown fields to catch typos in clients
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
dec.Decode(&u)

// Join — OS-correct separator (/ on Unix, \ on Windows)
p := filepath.Join("data", "2024", "report.csv")
// "data/2024/report.csv"

filepath.Dir(p)   // "data/2024"
filepath.Base(p)  // "report.csv"
filepath.Ext(p)   // ".csv"

// Abs — resolve relative path to absolute
abs, err := filepath.Abs("./config.yaml")

// Clean — normalize ../ and //
filepath.Clean("a/../b//c")  // "b/c"

// Create a single directory
os.Mkdir("output", 0755)

// Create all intermediate directories
os.MkdirAll("output/2024/reports", 0755)

// Remove a file
os.Remove("tmp.txt")

// Remove directory and all contents
os.RemoveAll("output")

// Rename (also works as move)
os.Rename("old.txt", "new.txt")

//go:embed static/*
var staticFiles embed.FS

// Serve embedded files over HTTP
sub, _ := fs.Sub(staticFiles, "static")
http.Handle("/static/",
    http.StripPrefix("/static/",
        http.FileServer(http.FS(sub)),
    ),
)

// Multiple files or patterns on separate lines
//go:embed migrations/*.sql
//go:embed config/defaults.yaml
var assets embed.FS

// List embedded files
entries, _ := assets.ReadDir("migrations")
for _, e := range entries {
    fmt.Println(e.Name())
}

// Note: files beginning with . or _ are excluded
// unless the pattern explicitly names them.