.例如 1.日志文件

• 开始
• 第 1 行
• 2号线
• 3号线
• 结束

当我从头读取文件时，我能够得到 Line1 的查找位置。

func getSeekLocation() int64 {
    start := int64(0)
    input, err := os.Open(logFile)
    if err != nil {
        fmt.Println(err)
    }
    if _, err := input.Seek(start, io.SeekStart); err != nil {
        fmt.Println(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() {
       if strings.Contains(scanner.Text(), "Line1") {
        break
       }
    }
    size, err := getFileSize()
    if err != nil {
        fmt.Println(err)
    }
    return size - pos
}

但这不是解决问题的有效方法，因为随着文件大小的增加，获取位置的时间也会增加。 我想从 EOF 位置获取线路的位置，我认为这会更有效率。

最佳答案

注意:我优化和改进了以下解决方案，并将其作为库发布在这里:github.com/icza/backscanner

bufio.Scanner使用 io.Reader作为其来源，它不支持从任意位置查找和/或读取，因此它无法从末尾扫描行。 bufio.Scanner 只能在输入的所有数据都已被读取后才能读取输入的任何部分(也就是说，如果它首先读取了文件的所有内容，它只能读取文件的末尾)。

所以我们需要一个定制的解决方案来实现这样的功能。还好os.File确实支持从任意位置读取，因为它实现了 io.Seeker和 io.ReaderAt (它们中的任何一个都足以满足我们的需要)。

返回行向后的扫描器，从末尾开始

让我们构建一个 Scanner，它从最后一行开始向后扫描行。为此，我们将使用 io.ReaderAt。以下实现使用一个内部缓冲区，从输入的末尾开始，将数据按 block 读取到该缓冲区中。输入的大小也必须传递(这基本上是我们要开始读取的位置，不一定是结束位置)。

type Scanner struct {
    r   io.ReaderAt
    pos int
    err error
    buf []byte
}

func NewScanner(r io.ReaderAt, pos int) *Scanner {
    return &Scanner{r: r, pos: pos}
}

func (s *Scanner) readMore() {
    if s.pos == 0 {
        s.err = io.EOF
        return
    }
    size := 1024
    if size > s.pos {
        size = s.pos
    }
    s.pos -= size
    buf2 := make([]byte, size, size+len(s.buf))

    // ReadAt attempts to read full buff!
    _, s.err = s.r.ReadAt(buf2, int64(s.pos))
    if s.err == nil {
        s.buf = append(buf2, s.buf...)
    }
}

func (s *Scanner) Line() (line string, start int, err error) {
    if s.err != nil {
        return "", 0, s.err
    }
    for {
        lineStart := bytes.LastIndexByte(s.buf, '\n')
        if lineStart >= 0 {
            // We have a complete line:
            var line string
            line, s.buf = string(dropCR(s.buf[lineStart+1:])), s.buf[:lineStart]
            return line, s.pos + lineStart + 1, nil
        }
        // Need more data:
        s.readMore()
        if s.err != nil {
            if s.err == io.EOF {
                if len(s.buf) > 0 {
                    return string(dropCR(s.buf)), 0, nil
                }
            }
            return "", 0, s.err
        }
    }
}

// dropCR drops a terminal \r from the data.
func dropCR(data []byte) []byte {
    if len(data) > 0 && data[len(data)-1] == '\r' {
        return data[0 : len(data)-1]
    }
    return data
}

使用示例:

func main() {
    scanner := NewScanner(strings.NewReader(src), len(src))
    for {
        line, pos, err := scanner.Line()
        if err != nil {
            fmt.Println("Error:", err)
            break
        }
        fmt.Printf("Line start: %2d, line: %s\n", pos, line)
    }
}

const src = `Start
Line1
Line2
Line3
End`

输出(在 Go Playground 上尝试):

Line start: 24, line: End
Line start: 18, line: Line3
Line start: 12, line: Line2
Line start:  6, line: Line1
Line start:  0, line: Start
Error: EOF

注意事项:

• 上面的Scanner 不限制行的最大长度，它处理所有行。
• 上面的 Scanner 处理 \n 和 \r\n 行尾(由 dropCR()功能)。
• 您可以传递任何起始位置，而不仅仅是尺寸/长度，列表行将从那里执行(续)。
• 上面的Scanner 不重用缓冲区，总是在需要时创建新缓冲区。 (预)分配 2 个缓冲区并明智地使用它们就足够了。实现会变得更加复杂，并且会引入最大行长度限制。

与文件一起使用

要对文件使用此扫描仪，您可以使用os.Open() 打开文件。请注意，*File 实现了 io.ReaderAt()。那么你可以使用 File.Stat()获取有关文件 ( os.FileInfo ) 的信息，包括其大小(长度):

f, err := os.Open("a.txt")
if err != nil {
    panic(err)
}
fi, err := f.Stat()
if err != nil {
    panic(err)
}
defer f.Close()

scanner := NewScanner(f, int(fi.Size()))

在一行中寻找子串

如果您要查找一行中的子字符串，则只需使用上面的 Scanner，它会返回每行的起始位置，从末尾读取行。

您可以使用 strings.Index() 检查每一行中的子字符串，它返回行内的子字符串位置，如果找到，则将行开始位置添加到此。

假设我们正在寻找 "ine2" 子字符串(它是 "Line2" 行的一部分)。以下是您可以如何做到这一点:

scanner := NewScanner(strings.NewReader(src), len(src))
what := "ine2"
for {
    line, pos, err := scanner.Line()
    if err != nil {
        fmt.Println("Error:", err)
        break
    }
    fmt.Printf("Line start: %2d, line: %s\n", pos, line)

    if i := strings.Index(line, what); i >= 0 {
        fmt.Printf("Found %q at line position: %d, global position: %d\n",
            what, i, pos+i)
        break
    }
}

输出(在 Go Playground 上尝试):

Line start: 24, line: End
Line start: 18, line: Line3
Line start: 12, line: Line2
Found "ine2" at line position: 1, global position: 13

关于file - 从末尾读取日志文件并获取特定字符串的偏移量，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46764241/