How to Write Files in Go: Complete Guide with Examples

Method 1: Simple File Write with ioutil.WriteFile()

For most beginners, this is the right starting point. It’s readable, handles errors predictably, and closes resources automatically:

package main

import (
    "fmt"
    "io/ioutil"
    "log"
)

func main() {
    data := []byte("Hello, Go!\n")
    
    // Write to file
    err := ioutil.WriteFile("output.txt", data, 0644)
    if err != nil {
        log.Fatal(err) // Proper error handling
    }
    
    fmt.Println("File written successfully")
}

Why this works: The ioutil.WriteFile() function handles file creation, writing, and closing in a single call. The third parameter (0644) sets file permissions: readable and writable by owner, readable by group and others. If the file exists, it gets truncated. If it doesn’t exist, it’s created.

Method 2: Modern Approach with os.WriteFile() (Go 1.16+)

In Go 1.16 and later, os.WriteFile() is the recommended replacement for ioutil.WriteFile():

package main

import (
    "fmt"
    "os"
)

func main() {
    data := []byte("Hello, Go!\n")
    
    // Modern approach
    err := os.WriteFile("output.txt", data, 0644)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }
    
    fmt.Println("File written successfully")
}

Key difference: os.WriteFile() is the modern standard and is preferred in new code. It’s functionally identical to ioutil.WriteFile() but located in the os package where it belongs semantically.

Method 3: Handling Multiple Writes with os.Create()

When writing large amounts of data in chunks, you need more control:

package main

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

func main() {
    // Create file
    file, err := os.Create("output.txt")
    if err != nil {
        log.Fatal(err)
    }
    // CRITICAL: Always defer Close()
    defer file.Close()
    
    // Write multiple chunks
    lines := []string{
        "Line 1\n",
        "Line 2\n",
        "Line 3\n",
    }
    
    for _, line := range lines {
        _, err := file.WriteString(line)
        if err != nil {
            log.Fatal(err)
        }
    }
    
    fmt.Println("All lines written")
}

Critical point: The defer file.Close() statement is non-negotiable. Without it, the file remains open and can cause resource leaks. Go’s defer mechanism guarantees cleanup even if an error occurs.

Method 4: High-Performance Writing with bufio.Writer

For writing thousands of lines or large datasets, buffered I/O dramatically improves performance:

package main

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

func main() {
    file, err := os.Create("large_output.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    
    // Wrap with buffered writer
    writer := bufio.NewWriter(file)
    defer writer.Flush() // Critical: flush remaining data
    
    // Write many lines efficiently
    for i := 1; i <= 100000; i++ {
        _, err := writer.WriteString(fmt.Sprintf("Line %d\n", i))
        if err != nil {
            log.Fatal(err)
        }
    }
    
    // Explicit flush to catch errors
    if err := writer.Flush(); err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("Large file written efficiently")
}

Performance insight: Buffered writing reduces system calls by 99.9%. Instead of 100,000 individual write operations, you get roughly one every 4KB. This is essential when processing large datasets.

Method 5: Appending to Existing Files

To append data without truncating, use the os.OpenFile() function:

package main

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

func main() {
    // Open file in append mode
    file, err := os.OpenFile(
        "append.txt",
        os.O_APPEND|os.O_WRONLY|os.O_CREATE,
        0644,
    )
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    
    data := []byte("Appended line\n")
    _, err = file.Write(data)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("Data appended successfully")
}

Flag breakdown: os.O_APPEND ensures writes go to the end, os.O_WRONLY opens for writing only, and os.O_CREATE creates if needed.