Go语言中高效原地编辑大型文本文件的策略与实践

package main

import (
    "bufio"
    "fmt"
    "io"
    "io/ioutil"
    "os"
    "path/filepath"
    "strings"
)

// editFileInPlace 模拟原地编辑大型文本文件
// filePath: 待编辑的文件路径
// lineNumberToEdit: 要编辑的行号 (从1开始)
// newContent: 新的行内容
func editFileInPlace(filePath string, lineNumberToEdit int, newContent string) error {
    // 1. 打开原始文件进行读取
    originalFile, err := os.Open(filePath)
    if err != nil {
        return fmt.Errorf("无法打开原始文件 %s: %w", filePath, err)
    }
    defer originalFile.Close() // 确保文件在函数结束时关闭

    // 2. 创建一个临时文件用于写入修改后的内容
    // ioutil.TempFile 会在默认临时目录中创建一个唯一命名的文件
    tempFile, err := ioutil.TempFile(filepath.Dir(filePath), "temp_edit_*.txt")
    if err != nil {
        return fmt.Errorf("无法创建临时文件: %w", err)
    }
    // 确保临时文件在操作失败时被清理
    defer func() {
        if r := recover(); r != nil {
            os.Remove(tempFile.Name()) // 清理临时文件
            panic(r) // 重新抛出异常
        }
        // 如果成功，我们会在最后重命名，否则也需要清理
        // 但在这里，我们只在错误发生时清理，成功时会重命名
    }()
    defer tempFile.Close() // 确保临时文件在函数结束时关闭

    // 3. 使用 bufio.Scanner 逐行读取原始文件
    scanner := bufio.NewScanner(originalFile)
    writer := bufio.NewWriter(tempFile)
    defer writer.Flush() // 确保所有缓冲数据写入文件

    currentLine := 0
    for scanner.Scan() {
        currentLine++
        line := scanner.Text()

        // 4. 根据条件修改行内容
        if currentLine == lineNumberToEdit {
            _, err := writer.WriteString(newContent + "\n")
            if err != nil {
                return fmt.Errorf("写入新内容到临时文件失败: %w", err)
            }
        } else {
            _, err := writer.WriteString(line + "\n")
            if err != nil {
                return fmt.Errorf("写入原始行到临时文件失败: %w", err)
            }
        }
    }

    if err := scanner.Err(); err != nil {
        return fmt.Errorf("读取原始文件时发生错误: %w", err)
    }

    // 5. 关闭文件，确保所有数据都已写入磁盘
    originalFile.Close()
    tempFile.Close()

    // 6. 将临时文件重命名为原始文件，实现“原地”替换
    // os.Rename 是一个原子操作 (在同一文件系统内)
    err = os.Rename(tempFile.Name(), filePath)
    if err != nil {
        // 如果重命名失败，需要清理临时文件
        os.Remove(tempFile.Name())
        return fmt.Errorf("重命名临时文件到原始文件失败: %w", err)
    }

    return nil
}

func main() {
    // 创建一个测试文件
    testFilePath := "large_test_file.txt"
    createTestFile(testFilePath, 100000) // 创建一个包含10万行的文件

    fmt.Printf("开始编辑文件: %s\n", testFilePath)

    lineNumber := 50000 // 假设我们要修改第50000行
    newLineContent := "这一行是修改后的新内容，由Go程序插入。"

    err := editFileInPlace(testFilePath, lineNumber, newLineContent)
    if err != nil {
        fmt.Printf("编辑文件失败: %v\n", err)
        return
    }

    fmt.Println("文件编辑成功。")

    // 验证修改是否成功
    fmt.Printf("正在验证第 %d 行内容...\n", lineNumber)
    content, err := readLine(testFilePath, lineNumber)
    if err != nil {
        fmt.Printf("读取验证行失败: %v\n", err)
        return
    }
    fmt.Printf("第 %d 行内容: %s\n", lineNumber, content)
    if strings.TrimSpace(content) == strings.TrimSpace(newLineContent) {
        fmt.Println("验证成功：内容已正确修改。")
    } else {
        fmt.Println("验证失败：内容未按预期修改。")
    }

    // 清理测试文件
    // os.Remove(testFilePath)
    // fmt.Printf("测试文件 %s 已删除。\n", testFilePath)
}

// 辅助函数：创建测试文件
func createTestFile(filePath string, numLines int) {
    file, err := os.Create(filePath)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    writer := bufio.NewWriter(file)
    for i := 1; i <= numLines; i++ {
        writer.WriteString(fmt.Sprintf("这是文件中的第 %d 行。\n", i))
    }
    writer.Flush()
    fmt.Printf("创建了包含 %d 行的测试文件: %s\n", numLines, filePath)
}

// 辅助函数：读取指定行内容进行验证
func readLine(filePath string, lineNumber int) (string, error) {
    file, err := os.Open(filePath)
    if err != nil {
        return "", err
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    currentLine := 0
    for scanner.Scan() {
        currentLine++
        if currentLine == lineNumber {
            return scanner.Text(), nil
        }
    }

    if err := scanner.Err(); err != nil {
        return "", err
    }

    return "", fmt.Errorf("未找到第 %d 行", lineNumber)
}