Use os.ReadFile() for reading small files entirely into memory as a byte slice, converting to string with string(content). 2. For large files or line-by-line reading, use bufio.Scanner with os.Open() and defer file.Close() to stream efficiently. 3. Write files using os.WriteFile() with a byte slice and permission setting like 0644, which overwrites existing files. 4. To append to a file, use os.OpenFile() with os.O_APPEND|os.O_CREATE|os.O_WRONLY flags and WriteString(). 5. For JSON data, marshal structs to JSON bytes with json.Marshal() and write using os.WriteFile(), or read with os.ReadFile() and unmarshal with json.Unmarshal(). 6. Always handle errors and use defer to close files when opened manually. 7. Prefer os.ReadFile and os.WriteFile for simplicity with small files, and bufio for streaming or large data to optimize performance. Go provides both high-level convenience and low-level control for file operations, making it efficient and safe when best practices are followed.

Reading and writing files in Go is straightforward thanks to the os and io/ioutil (now largely replaced by os and io packages in modern Go) packages. Here's how you can do it effectively for common use cases.

1. Reading a File

The most common way to read a file is using os.ReadFile() (introduced in Go 1.16), which reads the entire file into memory as a byte slice.

package main

import (
    "fmt"
    "log"
    "os"
)

func main() {
    content, err := os.ReadFile("example.txt")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(string(content))
}

• This is ideal for small files.
• Returns []byte, so use string(content) to convert to string.
• Handles opening and closing the file automatically.

For larger files, or when you want to read line by line (e.g., to save memory), use bufio.Scanner:

file, err := os.Open("largefile.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

scanner := bufio.NewScanner(file)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

if err := scanner.Err(); err != nil {
    log.Fatal(err)
}

This method streams the file, processing one line at a time—great for logs or big data.

2. Writing to a File

To write a string or byte slice to a file, use os.WriteFile():

data := []byte("Hello, World!\n")
err := os.WriteFile("output.txt", data, 0644)
if err != nil {
    log.Fatal(err)
}

Or, if you're writing a string:

err := os.WriteFile("output.txt", []byte("Hello, Go!"), 0644)

• The third argument is the file permission (0644 means owner can read/write, others can read).
• This overwrites the file if it exists.

To append to a file instead:

file, err := os.OpenFile("output.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
    log.Fatal(err)
}
defer file.Close()

if _, err := file.WriteString("New line\n"); err != nil {
    log.Fatal(err)
}

This opens the file in append mode and creates it if it doesn’t exist.

3. Working with Structured Data (e.g., JSON)

Go makes it easy to read and write structured data like JSON:

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// Writing JSON to file
person := Person{Name: "Alice", Age: 30}
data, _ := json.Marshal(person)
os.WriteFile("person.json", data, 0644)

// Reading JSON from file
content, _ := os.ReadFile("person.json")
var p Person
json.Unmarshal(content, &p)
fmt.Printf("% v\n", p)

Don’t forget to handle errors in production code.

Key Tips

• Use defer file.Close() whenever you manually open a file.
• Prefer os.ReadFile and os.WriteFile for simple, small-file operations.
• Use bufio.Scanner or bufio.Writer for better performance with large files or streaming.
• Always handle errors—file operations are prone to failures (permissions, paths, disk space).

Basically, Go gives you both simple high-level functions and fine-grained control when you need it. For most cases, os.ReadFile and os.WriteFile are all you need.

The above is the detailed content of How do you read and write files in Go?. For more information, please follow other related articles on the PHP Chinese website!