Golang中如何在大二进制文件中查找[]byte的偏移量

为什么不将整个文件读入内存并使用 bytes.Index() 呢？5 MB 的数据完全可以轻松放入内存。

func scanFile(f io.ReadSeeker, search []byte) (int64, error){
    data, err := ioutil.ReadAll(f)
    if err != nil {
        return 0, err
    }
    return bytes.Index(data, search), nil
}

在大型二进制文件中查找特定字节序列的偏移量，可以使用以下方法：

package main

import (
    "bytes"
    "fmt"
    "io"
    "os"
)

func findOffset(file *os.File, search []byte) (int64, error) {
    const bufferSize = 32 * 1024 // 32KB缓冲区
    buffer := make([]byte, bufferSize)
    overlap := len(search) - 1
    var offset int64 = 0
    
    for {
        n, err := file.Read(buffer)
        if err != nil && err != io.EOF {
            return -1, err
        }
        
        // 在当前缓冲区中搜索
        if idx := bytes.Index(buffer[:n], search); idx != -1 {
            return offset + int64(idx), nil
        }
        
        // 处理缓冲区边界情况
        if n > overlap {
            // 保存最后overlap个字节用于下一次搜索
            copy(buffer[:overlap], buffer[n-overlap:n])
            offset += int64(n - overlap)
            // 将文件指针移回以重新读取重叠部分
            _, err = file.Seek(offset, io.SeekStart)
            if err != nil {
                return -1, err
            }
        }
        
        if err == io.EOF {
            break
        }
    }
    
    return -1, nil // 未找到
}

func main() {
    file, err := os.Open("file.bin")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    
    search := []byte("hello")
    offset, err := findOffset(file, search)
    if err != nil {
        panic(err)
    }
    
    if offset >= 0 {
        fmt.Printf("Found at offset: %d\n", offset)
    } else {
        fmt.Println("Not found")
    }
}

更高效的实现使用bufio.Reader配合自定义搜索：

package main

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

func findOffsetWithReader(file *os.File, search []byte) (int64, error) {
    reader := bufio.NewReader(file)
    searchLen := len(search)
    var offset int64 = 0
    window := make([]byte, searchLen)
    
    // 初始化窗口
    n, err := io.ReadFull(reader, window)
    if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
        return -1, err
    }
    
    for {
        // 检查当前窗口是否匹配
        if bytes.Equal(window[:n], search) {
            return offset, nil
        }
        
        // 读取下一个字节
        nextByte, err := reader.ReadByte()
        if err != nil {
            if err == io.EOF {
                break
            }
            return -1, err
        }
        
        // 滑动窗口
        if searchLen > 1 {
            copy(window, window[1:])
            window[searchLen-1] = nextByte
        } else {
            window[0] = nextByte
        }
        offset++
    }
    
    return -1, nil
}

func main() {
    file, err := os.Open("file.bin")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    
    search := []byte("hello")
    offset, err := findOffsetWithReader(file, search)
    if err != nil {
        panic(err)
    }
    
    if offset >= 0 {
        fmt.Printf("Found 'hello' at offset: %d\n", offset)
    } else {
        fmt.Println("Pattern not found")
    }
}

使用io.SectionReader进行内存映射式搜索：

package main

import (
    "bytes"
    "fmt"
    "io"
    "os"
)

func findOffsetMemoryEfficient(file *os.File, search []byte) (int64, error) {
    fileInfo, err := file.Stat()
    if err != nil {
        return -1, err
    }
    fileSize := fileInfo.Size()
    
    const chunkSize = 1 * 1024 * 1024 // 1MB chunks
    searchLen := len(search)
    
    for start := int64(0); start < fileSize; start += chunkSize {
        end := start + chunkSize + int64(searchLen) - 1
        if end > fileSize {
            end = fileSize
        }
        
        section := io.NewSectionReader(file, start, end-start)
        chunk := make([]byte, end-start)
        
        n, err := section.Read(chunk)
        if err != nil && err != io.EOF {
            return -1, err
        }
        
        if idx := bytes.Index(chunk[:n], search); idx != -1 {
            return start + int64(idx), nil
        }
        
        if end == fileSize {
            break
        }
    }
    
    return -1, nil
}

func main() {
    file, err := os.Open("file.bin")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    
    offset, err := findOffsetMemoryEfficient(file, []byte("hello"))
    if err != nil {
        panic(err)
    }
    
    if offset >= 0 {
        fmt.Printf("Offset: %d (0x%x)\n", offset, offset)
    }
}

这些方法都能在5MB文件中高效查找字节序列的偏移量。第一种方法使用固定缓冲区，第二种使用滑动窗口，第三种使用分块读取。根据具体需求选择合适的方法。