File Handling in Go

# CHAPTER 18

File Handling in Go #

1. Introduction #

2. Learning Objectives #

• Create and write to a new file.

• Read data from an existing file.

• Use defer to ensure files are closed safely.

• Understand basic file permissions (e.g., 0644).

• Delete files from the system.

3. Writing to a File #

package main

import (
    "fmt"
    "os"
)

func main() {
    message := "Welcome to File Handling in Go!"
    // Convert string to a slice of bytes []byte
    data := []byte(message) 

    // 0644 means: Owner can Read/Write. Others can only Read.
    err := os.WriteFile("notes.txt", data, 0644)
    
    if err != nil {
        fmt.Println("Error writing file:", err)
        return
    }
    fmt.Println("File created successfully!")
}

4. Reading from a File #

func main() {
    // Returns the file contents as a slice of bytes
    data, err := os.ReadFile("notes.txt")
    
    if err != nil {
        fmt.Println("Error reading file:", err)
        return
    }

    // Convert the bytes back to a string to print it
    fmt.Println("File Content:")
    fmt.Println(string(data))
}

5. Appending and Advanced File Operations (os.OpenFile) #

The Golden Rule of File I/O: If you open a file, you MUST close it. Leaving files open causes "Memory Leaks" and file locking issues. We use the defer keyword to guarantee the file closes the moment the function finishes.

func main() {
    // Open file with flags: Append (O_APPEND), Create if it doesn't exist (O_CREATE), Write-Only (O_WRONLY)
    file, err := os.OpenFile("server.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        fmt.Println("Failed to open file:", err)
        return
    }
    
    // CRITICAL: Schedule the file to close when main() finishes!
    defer file.Close()

    // Write a new line
    logEntry := "User logged in at 10:00 AM\n"
    file.WriteString(logEntry)
    
    fmt.Println("Log updated!")
}

6. Deleting a File #

func main() {
    err := os.Remove("notes.txt")
    if err != nil {
        fmt.Println("Could not delete file:", err)
        return
    }
    fmt.Println("File deleted.")
}

7. Mini Project: Notes CLI #

package main

import (
    "fmt"
    "os"
)

func main() {
    var note string
    fmt.Print("Enter a note to save: ")
    // NOTE: Scanln only reads up to the first space. 
    // In a real app, you would use bufio.NewReader for full sentences.
    fmt.Scanln(&note) 

    file, err := os.OpenFile("my_notes.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer file.Close()

    file.WriteString(note + "\n")
    fmt.Println("Note saved securely!")
}

8. Common Mistakes #

• Forgetting defer file.Close(): This is the #1 mistake beginners make. If a server opens 10,000 files and never closes them, the operating system will crash the server for exceeding file handle limits.

• Reading Massive Files into Memory: os.ReadFile loads the *entire* file into RAM. If the file is a 50GB database dump, your program will run out of memory and crash. (For massive files, use bufio.NewReader or os.File.Read in chunks).

9. Best Practices #

• Always check errors: Trying to read a file that doesn't exist will crash your logic. Always write if err != nil after interacting with the file system.

10. Exercises #

1. 1. Write a program that creates a file called hello.txt and writes your name into it.

1. 2. Read the file and print the output.

1. 3. Use os.Remove to delete the file.

11. MCQs with Answers & Explanations #

12. Interview Preparation #

1. 1. Why is the defer keyword heavily used in Go file handling?

1. 2. Explain the difference between os.WriteFile and opening a file with os.O_APPEND.

1. 3. How would you handle reading a file that is significantly larger than the available RAM?

13. Summary #

14. Next Chapter Recommendation #