Go语言中高效处理动态字符串容器：深入理解append与大规模数据策略

package main

import (
    "fmt"
    "time"
)

func main() {
    var matches []string
    start := time.Now()

    // 模拟添加100万个匹配项
    for i := 0; i < 1000000; i++ {
        matches = append(matches, "example_match_string")
    }

    duration := time.Since(start)
    fmt.Printf("Append 1,000,000 strings took: %v\n", duration)
    fmt.Printf("Final slice length: %d\n", len(matches))
    fmt.Printf("Final slice capacity: %d\n", cap(matches))
}

package main

import (
    "fmt"
    "time"
)

func main() {
    // 预估最终会有1,000,000个匹配项
    matches := make([]string, 0, 1000000) // length 0, capacity 1,000,000
    start := time.Now()

    for i := 0; i < 1000000; i++ {
        matches = append(matches, "example_match_string")
    }

    duration := time.Since(start)
    fmt.Printf("Append 1,000,000 strings with pre-allocation took: %v\n", duration)
    fmt.Printf("Final slice length: %d\n", len(matches))
    fmt.Printf("Final slice capacity: %d\n", cap(matches))
}

// GrepStream 模拟一个流式处理函数
// 从in读取数据，应用正则表达式，将匹配结果写入out
func GrepStream(in io.Reader, out io.Writer, patterns []*regexp.Regexp) error {
    scanner := bufio.NewScanner(in)
    for scanner.Scan() {
        line := scanner.Bytes()
        for _, p := range patterns {
            if p.Match(line) {
                // 发现匹配，写入输出
                if _, err := out.Write(line); err != nil {
                    return err
                }
                if _, err := out.Write([]byte("\n")); err != nil { // 添加换行符
                    return err
                }
                break // 假设每行只输出第一个匹配
            }
        }
    }
    return scanner.Err()
}

// GrepChannel 模拟一个使用通道传递结果的函数
func GrepChannel(in io.Reader, patterns []*regexp.Regexp) <-chan []byte {
    out := make(chan []byte)
    go func() {
        defer close(out)
        scanner := bufio.NewScanner(in)
        for scanner.Scan() {
            line := scanner.Bytes()
            for _, p := range patterns {
                if p.Match(line) {
                    // 发送匹配项的副本，避免下游修改影响原始数据
                    match := make([]byte, len(line))
                    copy(match, line)
                    out <- match
                    break
                }
            }
        }
        if err := scanner.Err(); err != nil {
            // 处理错误，例如通过另一个错误通道或日志记录
            fmt.Printf("Error scanning: %v\n", err)
        }
    }()
    return out
}

// 错误示例：直接引用大日志文件中的子切片，可能导致原始大文件无法被GC
func processLogBad(logData []byte) [][]byte {
    var matches [][]byte
    // 假设 logData 是整个GB级日志文件内容
    // ... 查找匹配项 ...
    match := logData[startIndex:endIndex] // match直接引用了logData的一部分
    matches = append(matches, match) // 只要matches存在，logData就不会被GC
    return matches
}

// 正确示例：拷贝匹配项，允许原始大文件被GC
func processLogGood(logData []byte) [][]byte {
    var matches [][]byte
    // ... 查找匹配项 ...
    subSlice := logData[startIndex:endIndex]

    // 显式拷贝匹配项
    copiedMatch := make([]byte, len(subSlice))
    copy(copiedMatch, subSlice)
    matches = append(matches, copiedMatch) // 此时，copiedMatch是独立内存，logData可以被GC
    return matches
}