php小编苹果在Go语言中，我们经常需要处理大型文本文件。有时，我们只对包含特定模式的行感兴趣，而忽略其他行。幸运的是，在Go中，我们可以使用正则表达式和bufio.Scanner来实现这个目标。通过使用正则表达式来匹配行，并通过Scanner来逐行处理文件，我们可以轻松地过滤掉我们不感兴趣的行。这个技巧不仅可以提高效率，还可以使我们的代码更加简洁和可读。接下来，让我们一起来看看如何在Go中实现忽略长文本文件中包含模式的行。
问题内容
我正在尝试实现一个函数来忽略 go 中长文本文件（保证 ascii）中包含模式的行
我在 withoutignore 和 withignore 下面的函数都接受文件名参数输入并返回 *byte.buffer，随后可用于写入 io.writer。
withignore 函数采用附加参数 pattern 从文件中排除包含模式的行。该函数可以工作，但通过基准测试，发现它比 慢 5 倍而不忽略 。有什么办法可以改进吗？
package main
import (
"bufio"
"bytes"
"io"
"log"
"os"
)
func withoutignore(f string) (*bytes.buffer, error) {
rfd, err := os.open(f)
if err != nil {
log.fatal(err)
}
defer func() {
if err := rfd.close(); err != nil {
log.fatal(err)
}
}()
inputbuffer := make([]byte, 1048576)
var bytesread int
var bs []byte
opbuffer := bytes.newbuffer(bs)
for {
bytesread, err = rfd.read(inputbuffer)
if err == io.eof {
return opbuffer, nil
}
if err != nil {
return nil, nil
}
_, err = opbuffer.write(inputbuffer[:bytesread])
if err != nil {
return nil, err
}
}
return opbuffer, nil
}
func withignore(f, pattern string) (*bytes.buffer, error) {
rfd, err := os.open(f)
if err != nil {
log.fatal(err)
}
defer func() {
if err := rfd.close(); err != nil {
log.fatal(err)
}
}()
scanner := bufio.newscanner(rfd)
var bs []byte
buffer := bytes.newbuffer(bs)
for scanner.scan() {
if !bytes.contains(scanner.bytes(), []byte(pattern)) {
_, err := buffer.writestring(scanner.text() + "\n")
if err != nil {
return nil, nil
}
}
}
return buffer, nil
}
func main() {
// buff, err := withoutignore("base64dump.log")
buff, err := withignore("base64dump.log", "audit")
if err != nil {
log.fatal(err)
}
_, err = buff.writeto(os.stdout)
if err != nil {
log.fatal(err)
}
}
基准测试
package main
import "testing"
func benchmarktestwithoutignore(b *testing.b) {
for i := 0; i < b.n; i++ {
_, err := withoutignore("base64dump.log")
if err != nil {
b.fatal(err)
}
}
}
func benchmarktestwithignore(b *testing.b) {
for i := 0; i < b.n; i++ {
_, err := withignore("base64dump.log", "audit")
if err != nil {
b.fatal(err)
}
}
}
并且可以在命令行中使用“base64dump.log”生成
base64 /dev/urandom | head -c 10000000 > base64dump.log
解决方法
由于ascii是有保证的，所以可以直接在byte级别工作。
不过，如果在读取输入时检查每个字节是否有换行符，然后再次在行内搜索模式，则操作将应用于每个字节。
另一方面，如果读取输入块并对文本中的模式执行优化搜索，甚至不检查每个输入字节，则可以最大限度地减少每个输入字节的操作。
例如，boyer-moore 字符串搜索算法。 go内置的bytes.index函数也进行了优化。所达到的速度当然取决于输入数据和实际模式。对于问题中指定的输入，测量时`bytes.index 的性能显着提高。
程序
- 读取一个块，其中块大小应明显长于最大行长度，值 >= 64kb 可能应该不错，在测试中使用了问题中的 1mb。
- 一个块通常不会以换行符结束，因此从块的末尾搜索到下一个换行符，将搜索限制在这个切片并记住下一次传递的剩余数据
- 最后一个块不一定以换行符结尾
- 在高性能 go 函数
bytes.index的帮助下，您可以找到该模式在块中出现的位置 - 从找到的位置搜索前面和后面的换行符
- 然后该块被输出到相应的行开头
- 并且从出现模式的行尾继续搜索
- 如果搜索没有找到其他位置，则输出其余位置
- 读取下一个块并再次应用所描述的步骤，直到到达文件末尾
值得注意
读取操作返回的数据可能少于块大小，因此重复读取操作直到读取块大小的数据是有意义的。
基准
优化后的代码通常要复杂得多，但性能也明显更好，我们稍后会看到。
benchmarktestwithoutignore-8 270 4137267 ns/op benchmarktestwithignore-8 54 22403931 ns/op benchmarktestfilter-8 150 7947454 ns/op
这里，优化后的代码benchmarktestfilter-8只比没有过滤的操作慢1.9倍左右，而benchmarktestwithignore-8方法比没有过滤的比较值慢5.4倍。
从另一个角度来看：优化后的代码比未优化的代码快2.8 倍。
代码
当然，这是您自己测试的代码：
func filterfile(f, pattern string) (*bytes.buffer, error) {
rfd, err := os.open(f)
if err != nil {
log.fatal(err)
}
defer func() {
if err := rfd.close(); err != nil {
log.fatal(err)
}
}()
reader := bufio.newreader(rfd)
return filter(reader, []byte(pattern), 1024*1024)
}
// chunksize must be larger than the longest line
// a reasonable size is probably >= 64k
func filter(reader io.reader, pattern []byte, chunksize int) (*bytes.buffer, error) {
var bs []byte
buffer := bytes.newbuffer(bs)
chunk := make([]byte, chunksize)
var remaining []byte
for lastchunk := false; !lastchunk; {
n, err := readchunk(reader, chunk, remaining, chunksize)
if err != nil {
if err == io.eof {
lastchunk = true
} else {
return nil, err
}
}
remaining = remaining[:0]
if !lastchunk {
for i := n - 1; i > 0; i-- {
if chunk[i] == '\n' {
remaining = append(remaining, chunk[i+1:n]...)
n = i + 1
break
}
}
}
s := 0
for s < n {
hit := bytes.index(chunk[s:n], pattern)
if hit < 0 {
break
}
hit += s
startofline := hit
for ; startofline > 0; startofline-- {
if chunk[startofline] == '\n' {
startofline++
break
}
}
endofline := hit + len(pattern)
for ; endofline < n; endofline++ {
if chunk[endofline] == '\n' {
break
}
}
endofline++
_, err = buffer.write(chunk[s:startofline])
if err != nil {
return nil, err
}
s = endofline
}
if s < n {
_, err = buffer.write(chunk[s:n])
if err != nil {
return nil, err
}
}
}
return buffer, nil
}
func readchunk(reader io.reader, chunk, remaining []byte, chunksize int) (int, error) {
copy(chunk, remaining)
r := len(remaining)
for r < chunksize {
n, err := reader.read(chunk[r:])
r += n
if err != nil {
return r, err
}
}
return r, nil
}
基准部分可能看起来像这样：
func BenchmarkTestFilter(b *testing.B) {
for i := 0; i < b.N; i++ {
_, err := filterFile("base64dump.log", "AUDIT")
if err != nil {
b.Fatal(err)
}
}
}
过滤器函数被拆分，实际工作在 func filter(reader io.reader,pattern []byte, chunksize int) (*bytes.buffer, error) 中完成。
通过注入读取器和 chunksize，已经准备或考虑了单元测试的创建，这里缺少这一点，但在处理索引时绝对建议这样做。
但是，这里的要点是找到一种方法来显着提高性能。
