从大文本中删除所有非字母数字字符的有效方法

一分耕耘，一分收获！既然打开了这篇文章《从大文本中删除所有非字母数字字符的有效方法》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

我需要处理大量文本，步骤之一是删除所有非字母数字字符。我正在努力寻找一种有效的方法来做到这一点。

到目前为止我有两个功能：

func stripmap(str, chr string) string {
    return strings.map(func(r rune) rune {
        if strings.indexrune(chr, r) < 0 {
            return r
        }
        return -1
    }, str)
}

在这里，我实际上必须输入一串所有非字母字符。

和普通的旧正则表达式

func stripregex(in string) string {
    reg, _ := regexp.compile("[^a-za-z0-9 ]+")
    return reg.replaceallstring(in, "")
}

正则表达式似乎慢得多

BenchmarkStripMap-8        30000         37907 ns/op        8192 B/op          2 allocs/op

BenchmarkStripRegex-8          10000        131449 ns/op       57552 B/op         35 allocs/op

寻找建议。还有其他更好的方法吗？改进上述内容？

解决方案

由于幸存的符文少于utf8.RuneSelf，所以可以通过对字节进行操作来解决这个问题。如果 [^a-za-z0-9 ] 中没有任何字节，则该字节是要删除的符文的一部分。

func strip(s string) string {
    var result strings.builder
    for i := 0; i < len(s); i++ {
        b := s[i]
        if ('a' <= b && b <= 'z') ||
            ('a' <= b && b <= 'z') ||
            ('0' <= b && b <= '9') ||
            b == ' ' {
            result.writebyte(b)
        }
    }
    return result.string()
}

此函数的一个变体是通过调用 result.grow 来预分配结果：

func strip(s string) string {
    var result strings.builder
    result.grow(len(s))
    ...

这可确保该函数进行一次内存分配，但如果幸存符文与源符文的比率较低，则内存分配可能会明显大于所需的内存分配。

此答案中的 strip 函数编写为与 string 参数和结果类型一起使用，因为这些是问题中使用的类型。

如果应用程序正在处理 []byte 源文本并且可以修改该源文本，则就地更新 []byte 会更有效。为此，请将剩余字节复制到切片的开头，并在完成后重新切片。这避免了 strings.builder 中的内存分配和开销。这种变化与 peterso 对此问题的回答中的一种类似。

func strip(s []byte) []byte {
    n := 0
    for _, b := range s {
        if ('a' <= b && b <= 'z') ||
            ('a' <= b && b <= 'z') ||
            ('0' <= b && b <= '9') ||
            b == ' ' {
            s[n] = b
            n++
        }
    }
    return s[:n]
}

根据使用的实际数据，此答案中的方法之一可能比问题中的方法更快。

在 go 中，“高效方式”意味着我们运行 go testing 包基准测试。

您对大文本的描述含糊不清。我们假设它以来自文件或其他 byte 切片的文本开始。

您可能会产生 string([]byte)、几个 make([]byte) 和 string([]byte) 的开销。

您可以使用 strings.builder 来减少 string([]byte) 和多个 make([]byte) 的开销。

您可以通过从 clean([]byte) string 函数开始，将其进一步减少为 string([]byte)。

例如，

func clean(s []byte) string {
    j := 0
    for _, b := range s {
        if ('a' <= b && b <= 'z') ||
            ('a' <= b && b <= 'z') ||
            ('0' <= b && b <= '9') ||
            b == ' ' {
            s[j] = b
            j++
        }
    }
    return string(s[:j])
}

对于大文本，莎士比亚全集为[]byte，

$ go fmt && go test strip_test.go -bench=. -benchmem
benchmarksendeckymap-8       20     65988121 ns/op    11730958 b/op      2 allocs/op
benchmarksendeckyregex-8      5    242834302 ns/op    40013144 b/op    130 allocs/op
benchmarkthunder-8          100     21791532 ns/op    34682926 b/op     43 allocs/op
benchmarkpeterso-8          100     16172591 ns/op     5283840 b/op      1 allocs/op
$

strip_test.go：

package main

import (
    "io/ioutil"
    "regexp"
    "strings"
    "testing"
)

func stripMap(str, chr string) string {
    return strings.Map(func(r rune) rune {
        if strings.IndexRune(chr, r) >= 0 {
            return r
        }
        return -1
    }, str)
}

var alphanum = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "

func BenchmarkSendeckyMap(b *testing.B) {
    for N := 0; N < b.N; N++ {
        b.StopTimer()
        bytShakespeare := []byte(strShakespeare)
        b.StartTimer()
        strShakespeare = string(bytShakespeare)
        stripMap(strShakespeare, alphanum)
    }
}

func stripRegex(in string) string {
    reg, _ := regexp.Compile("[^a-zA-Z0-9 ]+")
    return reg.ReplaceAllString(in, "")
}

func BenchmarkSendeckyRegex(b *testing.B) {
    for N := 0; N < b.N; N++ {
        b.StopTimer()
        bytShakespeare := []byte(strShakespeare)
        b.StartTimer()
        strShakespeare = string(bytShakespeare)
        stripRegex(strShakespeare)
    }
}

func strip(s string) string {
    var result strings.Builder
    for i := 0; i < len(s); i++ {
        b := s[i]
        if ('a' <= b && b <= 'z') ||
            ('A' <= b && b <= 'Z') ||
            ('0' <= b && b <= '9') ||
            b == ' ' {
            result.WriteByte(b)
        }
    }
    return result.String()
}

func BenchmarkThunder(b *testing.B) {
    for N := 0; N < b.N; N++ {
        b.StopTimer()
        bytShakespeare := []byte(strShakespeare)
        b.StartTimer()
        strShakespeare = string(bytShakespeare)
        strip(strShakespeare)
    }
}

func clean(s []byte) string {
    j := 0
    for _, b := range s {
        if ('a' <= b && b <= 'z') ||
            ('A' <= b && b <= 'Z') ||
            ('0' <= b && b <= '9') ||
            b == ' ' {
            s[j] = b
            j++
        }
    }
    return string(s[:j])
}

func BenchmarkPeterSO(b *testing.B) {
    for N := 0; N < b.N; N++ {
        b.StopTimer()
        bytShakespeare := []byte(strShakespeare)
        b.StartTimer()
        clean(bytShakespeare)
    }
}

var strShakespeare = func() string {
    // The Complete Works of William Shakespeare by William Shakespeare
    // http://www.gutenberg.org/files/100/100-0.txt
    data, err := ioutil.ReadFile(`/home/peter/shakespeare.100-0.txt`)
    if err != nil {
        panic(err)
    }
    return string(data)
}()

到这里，我们也就讲完了《从大文本中删除所有非字母数字字符的有效方法》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！