Go语言中bufio.Reader和bufio.Writer的正确关闭姿势

package main

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

func main() {
    // 1. 创建一个文件作为底层写入器
    file, err := os.Create("output.txt")
    if err != nil {
        fmt.Printf("Error creating file: %v\n", err)
        return
    }

    // 使用 defer 确保文件在函数结束时关闭，无论是否发生错误
    // 注意：defer 语句中的 file.Close() 应该在 writer.Flush() 之后执行
    // 通常，我们会将 Flush() 放在 defer 之前，或者在 defer 中嵌套 Flush()
    // 但为了清晰展示 Flush() 的必要性，这里将 Flush() 显式放在 Close() 之前
    defer func() {
        if err := file.Close(); err != nil {
            fmt.Printf("Error closing file: %v\n", err)
        }
    }()

    // 2. 创建一个带缓冲的写入器
    writer := bufio.NewWriter(file)

    // 3. 写入一些数据到缓冲区
    _, err = writer.WriteString("Hello, bufio writer!\nThis is some buffered data.\n")
    if err != nil {
        fmt.Printf("Error writing string: %v\n", err)
        return
    }
    fmt.Println("Data written to bufio.Writer's buffer.")

    // 4. 关键步骤：刷新缓冲区，将数据写入底层文件
    if err := writer.Flush(); err != nil {
        fmt.Printf("Error flushing writer: %v\n", err)
        return
    }
    fmt.Println("bufio.Writer's buffer flushed to underlying file.")

    // 5. 底层文件将在 defer 语句中关闭
    fmt.Println("File 'output.txt' should now contain the written data.")
}

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strings"
)

func main() {
    // 示例1: 关闭 os.File 作为底层 Reader
    // 为了确保文件存在，我们先尝试创建并写入一些内容
    const filename = "input.txt"
    if _, err := os.Stat(filename); os.IsNotExist(err) {
        tempFile, createErr := os.Create(filename)
        if createErr != nil {
            fmt.Printf("Error creating temp file: %v\n", createErr)
            return
        }
        _, _ = tempFile.WriteString("Line 1 from file\nLine 2 from file\n")
        _ = tempFile.Close()
    }

    file, err := os.Open(filename)
    if err != nil {
        fmt.Printf("Error opening file: %v\n", err)
        return
    }
    // 使用 defer 确保文件在函数结束时关闭
    defer func() {
        if err := file.Close(); err != nil {
            fmt.Printf("Error closing file: %v\n", err)
        }
    }()

    reader := bufio.NewReader(file)
    // 读取部分数据
    line, _, err := reader.ReadLine()
    if err != nil && err != io.EOF {
        fmt.Printf("Error reading line: %v\n", err)
        return
    }
    fmt.Printf("Read from file: %s\n", line)

    // 此时，file.Close() 将由 defer 调用，关闭底层文件句柄。
    // bufio.Reader 自身无需额外操作。

    fmt.Println("\n--- Another example with strings.Reader ---")

    // 示例2: 关闭一个不需显式关闭的 Reader (如 strings.Reader)
    strReader := strings.NewReader("Some string data in memory\n")
    bufStrReader := bufio.NewReader(strReader)

    // 从 bufStrReader 读取数据
    data, _ := bufStrReader.ReadString('\n')
    fmt.Printf("Read from string: %s", data)

    // strings.Reader 不持有系统资源，因此它不实现 io.Closer，也就不需要 Close()。
    // 相应地，包装它的 bufio.Reader 也不需要额外的关闭操作。
    fmt.Println("strings.Reader does not require explicit closing.")
}