使用Golang替换文件中的字符串

这是一个非常实用的文件字符串替换工具，很适合用Go来实现。我来分析一下这个场景并提供核心的代码实现。

核心实现方案

对于递归替换文件和目录中的字符串，主要需要处理文件遍历和字符串替换两个核心功能。以下是关键代码示例：

package main

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

// 替换单个文件中的字符串
func replaceInFile(filePath, oldStr, newStr string) error {
    // 读取文件内容
    content, err := ioutil.ReadFile(filePath)
    if err != nil {
        return err
    }
    
    // 替换字符串
    newContent := strings.ReplaceAll(string(content), oldStr, newStr)
    
    // 如果内容有变化，则写回文件
    if string(content) != newContent {
        return ioutil.WriteFile(filePath, []byte(newContent), 0644)
    }
    
    return nil
}

// 递归遍历目录并替换字符串
func replaceInDirectory(rootDir, oldStr, newStr string, extensions []string) error {
    return filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        
        // 跳过目录
        if info.IsDir() {
            return nil
        }
        
        // 检查文件扩展名
        if len(extensions) > 0 {
            ext := filepath.Ext(path)
            matched := false
            for _, allowedExt := range extensions {
                if strings.EqualFold(ext, allowedExt) {
                    matched = true
                    break
                }
            }
            if !matched {
                return nil
            }
        }
        
        // 执行替换
        return replaceInFile(path, oldStr, newStr)
    })
}

// 处理大文件的流式替换（避免内存问题）
func replaceInLargeFile(filePath, oldStr, newStr string) error {
    // 创建临时文件
    tmpFile := filePath + ".tmp"
    outFile, err := os.Create(tmpFile)
    if err != nil {
        return err
    }
    defer outFile.Close()
    
    writer := bufio.NewWriter(outFile)
    
    // 打开原文件
    inFile, err := os.Open(filePath)
    if err != nil {
        return err
    }
    defer inFile.Close()
    
    scanner := bufio.NewScanner(inFile)
    for scanner.Scan() {
        line := scanner.Text()
        newLine := strings.ReplaceAll(line, oldStr, newStr)
        fmt.Fprintln(writer, newLine)
    }
    
    if err := scanner.Err(); err != nil {
        return err
    }
    
    writer.Flush()
    
    // 替换原文件
    return os.Rename(tmpFile, filePath)
}

func main() {
    // 示例：替换当前目录下所有.go文件中的"oldString"为"newString"
    err := replaceInDirectory(".", "oldString", "newString", []string{".go", ".txt"})
    if err != nil {
        fmt.Printf("替换失败: %v\n", err)
    } else {
        fmt.Println("替换完成")
    }
}

性能优化版本

对于大型文件处理，可以使用更高效的方式：

// 使用bytes包进行高效替换
func replaceBytesInFile(filePath string, oldStr, newStr []byte) error {
    content, err := ioutil.ReadFile(filePath)
    if err != nil {
        return err
    }
    
    // 使用bytes.ReplaceAll进行字节级替换
    newContent := bytes.ReplaceAll(content, oldStr, newStr)
    
    if !bytes.Equal(content, newContent) {
        return ioutil.WriteFile(filePath, newContent, 0644)
    }
    
    return nil
}

// 并发处理多个文件
func concurrentReplace(files []string, oldStr, newStr string) error {
    var wg sync.WaitGroup
    errCh := make(chan error, len(files))
    
    for _, file := range files {
        wg.Add(1)
        go func(f string) {
            defer wg.Done()
            if err := replaceInFile(f, oldStr, newStr); err != nil {
                errCh <- fmt.Errorf("文件 %s: %v", f, err)
            }
        }(file)
    }
    
    wg.Wait()
    close(errCh)
    
    // 收集错误
    var errors []string
    for err := range errCh {
        errors = append(errors, err.Error())
    }
    
    if len(errors) > 0 {
        return fmt.Errorf(strings.Join(errors, "\n"))
    }
    
    return nil
}

命令行工具示例

// 完整的命令行工具
func main() {
    if len(os.Args) < 4 {
        fmt.Println("用法: replace <目录> <旧字符串> <新字符串> [扩展名...]")
        os.Exit(1)
    }
    
    rootDir := os.Args[1]
    oldStr := os.Args[2]
    newStr := os.Args[3]
    extensions := os.Args[4:]
    
    // 验证目录存在
    if _, err := os.Stat(rootDir); os.IsNotExist(err) {
        fmt.Printf("目录不存在: %s\n", rootDir)
        os.Exit(1)
    }
    
    // 执行替换
    start := time.Now()
    err := replaceInDirectory(rootDir, oldStr, newStr, extensions)
    elapsed := time.Since(start)
    
    if err != nil {
        fmt.Printf("错误: %v\n", err)
        os.Exit(1)
    }
    
    fmt.Printf("替换完成，耗时: %v\n", elapsed)
}

这个工具的核心在于filepath.Walk的递归遍历和strings.ReplaceAll的字符串替换。对于大文件，建议使用流式处理避免内存问题，对于大量文件可以考虑并发处理提高性能。