如何使用Scanner从特定行号开始读取文件？

我是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())
        }
    }

我很确定这样的东西会起作用,但它仍然会绕过我们已经读过的行.请建议一个更好的方法.

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

不同的解决方案以函数的形式呈现,该函数将输入读取并从起始位置(字节位置)开始读取行,例如:

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

使用了一个特殊的io.Reader输入,它也实现io.Seeker了通用接口,允许跳过数据而不必读取它们.*os.File实现这一点,所以你可以传递*File给这些函数.好.两者的"合并"接口io.Reader和io.Seeker是io.ReadSeeker.

如果你想要一个干净的开始(从文件的开头开始阅读),只需传递start = 0.如果要恢复先前的处理,请传递上次处理停止/中止的字节位置.该位置是pos下面函数(解决方案)中局部变量的值.

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

随着 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.正是我们需要保持文件位置.所以我们可以使用内置函数创建一个新的split函数bufio.ScanLines(),所以我们甚至不必实现它的逻辑,只需使用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()
}

随着 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来源为a的string.

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

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上试用解决方案和测试代码.