使用Go语言高效读取大型文件末尾内容的教程

package main

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

// getLastLineWithSeek 从文件末尾开始读取，直到找到第一个换行符或文件开头，返回最后一行内容
func getLastLineWithSeek(filepath string) (string, error) {
    fileHandle, err := os.Open(filepath)
    if err != nil {
        return "", fmt.Errorf("无法打开文件 %s: %w", filepath, err)
    }
    defer fileHandle.Close()

    var lineBuilder strings.Builder // 使用 strings.Builder 提高字符串拼接效率
    var cursor int64 = 0

    stat, err := fileHandle.Stat()
    if err != nil {
        return "", fmt.Errorf("无法获取文件信息 %s: %w", filepath, err)
    }
    filesize := stat.Size()

    for {
        cursor-- // 每次向前移动一个字节
        // 将文件指针移动到相对于文件末尾的 cursor 位置
        _, err := fileHandle.Seek(cursor, io.SeekEnd)
        if err != nil {
            // 如果 Seek 失败，通常意味着我们尝试移动到文件开头之前，或者文件为空
            if err == io.EOF && cursor == -1 { // 文件为空或只有一个字符且没有换行
                break
            }
            return "", fmt.Errorf("Seek 操作失败: %w", err)
        }

        char := make([]byte, 1)
        _, err = fileHandle.Read(char)
        if err != nil {
            if err == io.EOF { // 读到文件开头
                break
            }
            return "", fmt.Errorf("读取字节失败: %w", err)
        }

        // 检查是否是换行符 (LF: 10, CR: 13)
        // 注意：Windows 上的换行符是 CR LF (13 10)
        if char[0] == 10 || char[0] == 13 {
            // 如果不是文件开头且找到了换行符，则停止
            if cursor != -1 { // 避免在文件开头立即停止
                break
            }
        }

        // 将字符添加到行的开头
        lineBuilder.WriteByte(char[0])

        if cursor == -filesize { // 如果已到达文件开头
            break
        }
    }

    // 反转字符串，因为我们是从后向前读取的
    // 或者在构建时就插入到开头，但 Builder 不支持
    // 这里使用简单的反转方法
    rawLine := lineBuilder.String()
    runes := []rune(rawLine)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return strings.TrimSpace(string(runes)), nil // 移除可能存在的空白符
}

// readLastNLines 从文件末尾读取指定数量的行
func readLastNLines(filepath string, n int) ([]string, error) {
    fileHandle, err := os.Open(filepath)
    if err != nil {
        return nil, fmt.Errorf("无法打开文件 %s: %w", filepath, err)
    }
    defer fileHandle.Close()

    var lines []string
    var lineBuilder strings.Builder
    var cursor int64 = 0
    lineCount := 0

    stat, err := fileHandle.Stat()
    if err != nil {
        return nil, fmt.Errorf("无法获取文件信息 %s: %w", filepath, err)
    }
    filesize := stat.Size()

    // 处理空文件情况
    if filesize == 0 {
        return []string{}, nil
    }

    // 确保文件末尾有换行符，否则最后一行可能无法被正确识别
    // 或者在读取完成后进行特殊处理
    // 简单起见，这里假设文件以换行符结束，或者最后一行不以换行符结束也能被处理

    for {
        cursor--
        _, err := fileHandle.Seek(cursor, io.SeekEnd)
        if err != nil {
            if err == io.EOF && cursor == -1 { // 文件为空或只有一个字符
                break
            }
            // 其他 Seek 错误
            return nil, fmt.Errorf("Seek 操作失败: %w", err)
        }

        char := make([]byte, 1)
        _, err = fileHandle.Read(char)
        if err != nil {
            if err == io.EOF { // 读到文件开头
                break
            }
            return nil, fmt.Errorf("读取字节失败: %w", err)
        }

        if char[0] == 10 || char[0] == 13 { // 找到换行符
            // 避免在文件开头或连续换行符时计数错误
            if lineBuilder.Len() > 0 { // 只有当当前行有内容时才算作完整的一行
                lineCount++
                // 反转并添加到行列表
                rawLine := lineBuilder.String()
                runes := []rune(rawLine)
                for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
                    runes[i], runes[j] = runes[j], runes[i]
                }
                lines = append([]string{strings.TrimSpace(string(runes))}, lines...) // 将新行添加到切片开头
                lineBuilder.Reset()                                                   // 重置 Builder
            }
            if lineCount == n { // 已经找到N行
                break
            }
        } else {
            lineBuilder.WriteByte(char[0])
        }

        if cursor == -filesize { // 到达文件开头
            // 如果文件开头还有未处理的字符（即第一行没有以换行符结束）
            if lineBuilder.Len() > 0 {
                lineCount++
                rawLine := lineBuilder.String()
                runes := []rune(rawLine)
                for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
                    runes[i], runes[j] = runes[j], runes[i]
                }
                lines = append([]string{strings.TrimSpace(string(runes))}, lines...)
            }
            break
        }
    }

    // 如果文件内容少于N行，或者文件末尾没有换行符导致最后一行未被计数
    // 确保返回的行数不超过n
    if len(lines) > n {
        return lines[len(lines)-n:], nil
    }
    return lines, nil
}

const MYFILE = "logfile.log"

func main() {
    // 创建一个示例日志文件
    createDummyLogFile(MYFILE)

    c := time.Tick(10 * time.Second) // 每10秒触发一次
    fmt.Println("开始监控文件，每10秒读取最后2行...")
    for now := range c {
        fmt.Printf("\n--- %s 读取文件 %s ---\n", now.Format("2006-01-02 15:04:05"), MYFILE)
        lines, err := readLastNLines(MYFILE, 2) // 读取最后2行
        if err != nil {
            fmt.Printf("读取文件失败: %v\n", err)
            continue
        }
        if len(lines) == 0 {
            fmt.Println("文件为空或未找到任何行。")
        } else {
            for i, line := range lines {
                fmt.Printf("Line %d: %s\n", i+1, line)
            }
        }
    }
}

// createDummyLogFile 创建一个示例日志文件用于测试
func createDummyLogFile(filename string) {
    file, err := os.Create(filename)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    for i := 0; i < 20; i++ {
        file.WriteString(fmt.Sprintf("%s, %.3f\n", time.Now().Add(time.Duration(i)*time.Minute).Format("01/02/2006 15:04:05.000"), 0.300+float64(i)*0.01))
    }
    fmt.Printf("已创建示例日志文件: %s，包含20行数据。\n", filename)
}