file - 如何使用扫描仪从特定行号开始读取文件？

Question

我是 Go 新手，我正在尝试编写一个简单的脚本来逐行读取文件。我还想将进度(即读取的最后一个行号)保存在文件系统的某处，这样如果再次将相同的文件作为脚本的输入，它就会从停止的行开始读取文件。以下是我开始的内容。

package main

// Package Imports
import (
    "bufio"
    "flag"
    "fmt"
    "log"
    "os"
)

// Variable Declaration
var (
    ConfigFile = flag.String("configfile", "../config.json", "Path to json configuration file.")
)

// The main function that reads the file and parses the log entries
func main() {
    flag.Parse()
    settings := NewConfig(*ConfigFile)

    inputFile, err := os.Open(settings.Source)
    if err != nil {
        log.Fatal(err)
    }
    defer inputFile.Close()

    scanner := bufio.NewScanner(inputFile)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }

    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}

// Saves the current progress
func SaveProgress() {

}

// Get the line count from the progress to make sure
func GetCounter() {

}

我在扫描程序包中找不到任何处理行号的方法。我知道我可以声明一个整数，比如 counter := 0并在每次读取一行时递增它，如 counter++ .但是下次我如何告诉扫描仪从特定行开始？例如，如果我读到 30 行下次我使用相同的输入文件运行脚本时，如何让扫描仪从行 31 开始读取?

更新

我能想到的一个解决方案是使用上面所说的计数器并使用如下 if 条件。

    scanner := bufio.NewScanner(inputFile)
    for scanner.Scan() {
        if counter > progress {
            fmt.Println(scanner.Text())
        }
    }

我很确定这样的事情会起作用，但它仍然会遍历我们已经阅读过的行。请提出更好的方法。

Answer 1

如果您不想阅读而只是跳过之前阅读的行，则需要获取您离开的位置。

不同的解决方案以函数的形式呈现，该函数接受要读取的输入和开始读取行的起始位置(字节位置)，例如:

func solution(input io.ReadSeeker, start int64) error

一个特殊的io.Reader使用的输入也实现了io.Seeker , 允许跳过数据而无需读取它们的通用接口(interface)。 *os.File实现了这一点，因此您可以将 *File 传递给这些函数。好的。 io.Reader 和 io.Seeker 的“合并”接口(interface)是io.ReadSeeker .

如果您想要一个干净的开始(从文件的开头开始读取)，只需传递start = 0。如果您想恢复上一个处理，请传递上一个处理停止/中止的字节位置。这个位置就是下面函数(解决方案)中pos局部变量的值。

下面的所有示例及其测试代码都可以在 Go Playground 上找到.

1。使用 bufio.Scanner

bufio.Scanner不保持位置，但是我们可以很容易地扩展它来保持位置(读取的字节)，所以当我们下次要重新启动时，我们可以寻找到这个位置。

为了以最小的努力做到这一点，我们可以使用一个新的拆分函数，将输入拆分为标记(行)。我们可以使用Scanner.Split()设置拆分器功能(决定标记/行边界的逻辑)。默认拆分函数为bufio.ScanLines() .

我们看一下split函数声明:bufio.SplitFunc

type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)

它返回要前进的字节数:advance。正是我们需要维护文件位置。所以我们可以使用内置的bufio.ScanLines()创建一个新的split函数，这样我们甚至不用实现它的逻辑，只需使用advance的返回值即可保持位置:

func withScanner(input io.ReadSeeker, start int64) error {
    fmt.Println("--SCANNER, start:", start)
    if _, err := input.Seek(start, 0); err != nil {
        return err
    }
    scanner := bufio.NewScanner(input)

    pos := start
    scanLines := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
        advance, token, err = bufio.ScanLines(data, atEOF)
        pos += int64(advance)
        return
    }
    scanner.Split(scanLines)

    for scanner.Scan() {
        fmt.Printf("Pos: %d, Scanned: %s\n", pos, scanner.Text())
    }
    return scanner.Err()
}

2。使用 bufio.Reader

在这个解决方案中，我们使用 bufio.Reader键入而不是 Scanner。 bufio.Reader 已经有一个 ReadBytes()如果我们将 '\n' 字节作为分隔符传递，则该方法与“读取一行”功能非常相似。

此解决方案类似于 JimB 的解决方案，增加了处理所有有效的行终止符序列并将它们从读取行中剥离(很少需要它们)；在正则表达式表示法中，它是 \r?\n。

func withReader(input io.ReadSeeker, start int64) error {
    fmt.Println("--READER, start:", start)
    if _, err := input.Seek(start, 0); err != nil {
        return err
    }

    r := bufio.NewReader(input)
    pos := start
    for {
        data, err := r.ReadBytes('\n')
        pos += int64(len(data))
        if err == nil || err == io.EOF {
            if len(data) > 0 && data[len(data)-1] == '\n' {
                data = data[:len(data)-1]
            }
            if len(data) > 0 && data[len(data)-1] == '\r' {
                data = data[:len(data)-1]
            }
            fmt.Printf("Pos: %d, Read: %s\n", pos, data)
        }
        if err != nil {
            if err != io.EOF {
                return err
            }
            break
        }
    }
    return nil
}

注意:如果内容以空行(行终止符)结尾，此解决方案将处理空行。如果你不想要这个，你可以像这样简单地检查它:

if len(data) != 0 {
    fmt.Printf("Pos: %d, Read: %s\n", pos, data)
} else {
    // Last line is empty, omit it
}

测试解决方案:

测试代码将简单地使用 "first\r\nsecond\nthird\nfourth" 内容，该内容包含多行和不同的行终止。我们将使用 strings.NewReader()获取一个io.ReadSeeker，其来源是一个string。

测试代码首先调用 withScanner() 和 withReader() 传递 0 开始位置:干净开始 .在下一轮中，我们将传递 start = 14 的起始位置，即第 3 行的位置，因此我们不会看到前 2 行已处理(打印):resume 模拟。

func main() {
    const content = "first\r\nsecond\nthird\nfourth"

    if err := withScanner(strings.NewReader(content), 0); err != nil {
        fmt.Println("Scanner error:", err)
    }
    if err := withReader(strings.NewReader(content), 0); err != nil {
        fmt.Println("Reader error:", err)
    }

    if err := withScanner(strings.NewReader(content), 14); err != nil {
        fmt.Println("Scanner error:", err)
    }
    if err := withReader(strings.NewReader(content), 14); err != nil {
        fmt.Println("Reader error:", err)
    }
}

输出:

--SCANNER, start: 0
Pos: 7, Scanned: first
Pos: 14, Scanned: second
Pos: 20, Scanned: third
Pos: 26, Scanned: fourth
--READER, start: 0
Pos: 7, Read: first
Pos: 14, Read: second
Pos: 20, Read: third
Pos: 26, Read: fourth
--SCANNER, start: 14
Pos: 20, Scanned: third
Pos: 26, Scanned: fourth
--READER, start: 14
Pos: 20, Read: third
Pos: 26, Read: fourth

尝试 Go Playground 上的解决方案和测试代码.