• 1. 2.1 strings — 字符串操作

    字符串常见操作有:

    • 字符串长度;
    • 求子串;
    • 是否存在某个字符或子串;
    • 子串出现的次数(字符串匹配);
    • 字符串分割(切分)为[]string;
    • 字符串是否有某个前缀或后缀;
    • 字符或子串在字符串中首次出现的位置或最后一次出现的位置;
    • 通过某个字符串将[]string 连接起来;
    • 字符串重复几次;
    • 字符串中子串替换;
    • 大小写转换;
    • Trim 操作;
    • ...

    前面已经说过,由于 string 类型可以看成是一种特殊的 slice 类型,因此获取长度可以用内置的函数 len;同时支持 切片 操作,因此,子串获取很容易。

    其他的字符串常见操作就是我们这小节要介绍的,由于这些操作函数的使用比较简单,只会对某些函数举例说明;但会深入这些函数的内部实现,更好的掌握它们。

    说明:这里说的字符,指得是 rune 类型,即一个 UTF-8 字符(Unicode 代码点)。

    1.1. 2.1.1 是否存在某个字符或子串

    有三个函数做这件事:

        // 子串 substr 在 s 中,返回 true
        func Contains(s, substr string) bool
        // chars 中任何一个 Unicode 代码点在 s 中,返回 true
        func ContainsAny(s, chars string) bool
        // Unicode 代码点 rs 中,返回 true
        func ContainsRune(s string, r rune) bool
    

    这里对 ContainsAny 函数进行一下说明,看如下例子:

        fmt.Println(strings.ContainsAny("team", "i"))
        fmt.Println(strings.ContainsAny("failure", "u & i"))
        fmt.Println(strings.ContainsAny("in failure", "s g"))
        fmt.Println(strings.ContainsAny("foo", ""))
        fmt.Println(strings.ContainsAny("", ""))
    

    输出:

        false
        true
        true
        false
        false
    

    也就是说,第二个参数 chars 中任意一个字符(Unicode Code Point)如果在第一个参数 s 中存在,则返回 true。

    查看这三个函数的源码,发现它们只是调用了相应的 Index 函数(子串出现的位置),然后和 0 作比较返回 true 或 fale。如,Contains:

        func Contains(s, substr string) bool {
            return Index(s, substr) >= 0
        }
    

    关于 Index 相关函数的实现,我们后面介绍。

    1.2. 2.1.2 子串出现次数 ( 字符串匹配 )

    在数据结构与算法中,可能会讲解以下字符串匹配算法:

    • 朴素匹配算法
    • KMP 算法
    • Rabin-Karp 算法
    • Boyer-Moore 算法

    还有其他的算法,这里不一一列举,感兴趣的可以网上搜一下。

    在 Go 中,查找子串出现次数即字符串模式匹配,实现的是 Rabin-Karp 算法。Count 函数的签名如下:

        func Count(s, sep string) int
    

    在 Count 的实现中,处理了几种特殊情况,属于字符匹配预处理的一部分。这里要特别说明一下的是当 sep 为空时,Count 的返回值是:utf8.RuneCountInString(s) + 1

        fmt.Println(strings.Count("five", "")) // before & after each rune
    

    输出:

        5
    

    关于 Rabin-Karp 算法的实现,有兴趣的可以看看 Count 的源码。

    另外,Count 是计算子串在字符串中出现的无重叠的次数,比如:

        fmt.Println(strings.Count("fivevev", "vev"))
    

    输出:

        1
    

    1.3. 2.1.3 字符串分割为[]string

    这个需求很常见,倒不一定是为了得到[]string。

    该包提供了六个三组分割函数:Fields 和 FieldsFunc、Split 和 SplitAfter、SplitN 和 SplitAfterN。

    1.3.1. 2.1.3.1 Fields 和 FieldsFunc

    这两个函数的签名如下:

    func Fields(s string) []string
    func FieldsFunc(s string, f func(rune) bool) []string
    

    Fields 用一个或多个连续的空格分隔字符串 s,返回子字符串的数组(slice)。如果字符串 s 只包含空格,则返回空列表 ([]string 的长度为 0)。其中,空格的定义是 unicode.IsSpace,之前已经介绍过。

    由于是用空格分隔,因此结果中不会含有空格或空子字符串,例如:

    fmt.Printf("Fields are: %q", strings.Fields("  foo bar  baz   "))
    

    输出:

    Fields are: ["foo" "bar" "baz"]
    

    FieldsFunc 用这样的 Unicode 代码点 c 进行分隔:满足 f(c) 返回 true。该函数返回[]string。如果字符串 s 中所有的代码点 (unicode code points) 都满足 f(c) 或者 s 是空,则 FieldsFunc 返回空 slice。

    也就是说,我们可以通过实现一个回调函数来指定分隔字符串 s 的字符。比如上面的例子,我们通过 FieldsFunc 来实现:

    fmt.Println(strings.FieldsFunc("  foo bar  baz   ", unicode.IsSpace))
    

    实际上,Fields 函数就是调用 FieldsFunc 实现的:

    func Fields(s string) []string {
        return FieldsFunc(s, unicode.IsSpace)
    }
    

    对于 FieldsFunc 源码留给读者自己阅读。

    1.3.2. 2.1.3.2 Split 和 SplitAfter、 SplitN 和 SplitAfterN

    之所以将这四个函数放在一起讲,是因为它们都是通过一个同一个内部函数来实现的。它们的函数签名及其实现:

    func Split(s, sep string) []string { return genSplit(s, sep, 0, -1) }
    func SplitAfter(s, sep string) []string { return genSplit(s, sep, len(sep), -1) }
    func SplitN(s, sep string, n int) []string { return genSplit(s, sep, 0, n) }
    func SplitAfterN(s, sep string, n int) []string { return genSplit(s, sep, len(sep), n) }
    

    它们都调用了 genSplit 函数。

    这四个函数都是通过 sep 进行分割,返回[]string。如果 sep 为空,相当于分成一个个的 UTF-8 字符,如 Split("abc",""),得到的是[a b c]。

    Split(s, sep) 和 SplitN(s, sep, -1) 等价;SplitAfter(s, sep) 和 SplitAfterN(s, sep, -1) 等价。

    那么,Split 和 SplitAfter 有啥区别呢?通过这两句代码的结果就知道它们的区别了:

    fmt.Printf("%q\n", strings.Split("foo,bar,baz", ","))
    fmt.Printf("%q\n", strings.SplitAfter("foo,bar,baz", ","))
    

    输出:

    ["foo" "bar" "baz"]
    ["foo," "bar," "baz"]
    

    也就是说,Split 会将 s 中的 sep 去掉,而 SplitAfter 会保留 sep。

    带 N 的方法可以通过最后一个参数 n 控制返回的结果中的 slice 中的元素个数,当 n < 0 时,返回所有的子字符串;当 n == 0 时,返回的结果是 nil;当 n > 0 时,表示返回的 slice 中最多只有 n 个元素,其中,最后一个元素不会分割,比如:

    fmt.Printf("%q\n", strings.SplitN("foo,bar,baz", ",", 2))
    

    输出:

    ["foo" "bar,baz"]
    

    另外看一下官方文档提供的例子,注意一下输出结果:

    fmt.Printf("%q\n", strings.Split("a,b,c", ","))
    fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
    fmt.Printf("%q\n", strings.Split(" xyz ", ""))
    fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
    

    输出:

    ["a" "b" "c"]
    ["" "man " "plan " "canal panama"]
    [" " "x" "y" "z" " "]
    [""]
    

    1.4. 2.1.4 字符串是否有某个前缀或后缀

    这两个函数比较简单,源码如下:

    // s 中是否以 prefix 开始
    func HasPrefix(s, prefix string) bool {
        return len(s) >= len(prefix) && s[0:len(prefix)] == prefix
    }
    // s 中是否以 suffix 结尾
    func HasSuffix(s, suffix string) bool {
        return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
    }
    

    1.5. 2.1.5 字符或子串在字符串中出现的位置

    有一序列函数与该功能有关:

    // 在 s 中查找 sep 的第一次出现,返回第一次出现的索引
    func Index(s, sep string) int
    // chars 中任何一个 Unicode 代码点在 s 中首次出现的位置
    func IndexAny(s, chars string) int
    // 查找字符 c 在 s 中第一次出现的位置,其中 c 满足 f(c) 返回 true
    func IndexFunc(s string, f func(rune) bool) int
    // Unicode 代码点 r 在 s 中第一次出现的位置
    func IndexRune(s string, r rune) int
    
    // 有三个对应的查找最后一次出现的位置
    func LastIndex(s, sep string) int
    func LastIndexAny(s, chars string) int
    func LastIndexFunc(s string, f func(rune) bool) int
    

    在 2.1.1 小节提到过,Contain 相关的函数内部调用的是响应的 Index 函数。

    这一序列函数,只举 IndexFunc 的例子:

    fmt.Printf("%d\n", strings.IndexFunc("studygolang", func(c rune) bool {
        if c > 'u' {
            return true
        }
        return false
    }))
    

    输出:

    4
    

    因为 y 的 Unicode 代码点大于 u 的代码点。

    1.6. 2.1.6 字符串 JOIN 操作

    将字符串数组(或 slice)连接起来可以通过 Join 实现,函数签名如下:

    func Join(a []string, sep string) string
    

    假如没有这个库函数,我们自己实现一个,我们会这么实现:

    func Join(str []string, sep string) string {
        // 特殊情况应该做处理
        if len(str) == 0 {
            return ""
        }
        if len(str) == 1 {
            return str[0]
        }
        buffer := bytes.NewBufferString(str[0])
        for _, s := range str[1:] {
            buffer.WriteString(sep)
            buffer.WriteString(s)
        }
        return buffer.String()
    }
    

    这里,我们使用了 bytes 包的 Buffer 类型,避免大量的字符串连接操作(因为 Go 中字符串是不可变的)。我们再看一下标准库的实现:

    func Join(a []string, sep string) string {
        if len(a) == 0 {
            return ""
        }
        if len(a) == 1 {
            return a[0]
        }
        n := len(sep) * (len(a) - 1)
        for i := 0; i < len(a); i++ {
            n += len(a[i])
        }
    
        b := make([]byte, n)
        bp := copy(b, a[0])
        for _, s := range a[1:] {
            bp += copy(b[bp:], sep)
            bp += copy(b[bp:], s)
        }
        return string(b)
    }
    

    标准库的实现没有用 bytes 包,当然也不会简单的通过 + 号连接字符串。Go 中是不允许循环依赖的,标准库中很多时候会出现代码拷贝,而不是引入某个包。这里 Join 的实现方式挺好,我个人猜测,不直接使用 bytes 包,也是不想依赖 bytes 包(其实 bytes 中的实现也是 copy 方式)。

    简单使用示例:

    fmt.Println(Join([]string{"name=xxx", "age=xx"}, "&"))
    // 输出 name=xxx&age=xx
    

    1.7. 2.1.7 字符串重复几次

    函数签名如下:

    func Repeat(s string, count int) string
    

    这个函数使用很简单:

    // 输出 banana
    fmt.Println("ba" + strings.Repeat("na", 2))
    

    1.8. 2.1.8 字符串子串替换

    进行字符串替换时,考虑到性能问题,能不用正则尽量别用,应该用这里的函数。

    字符串替换的函数签名如下:

    // 用 new 替换 s 中的 old,一共替换 n 个。
    // 如果 n < 0,则不限制替换次数,即全部替换
    func Replace(s, old, new string, n int) string
    

    使用示例:

    fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
    fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
    

    输出:

    oinky oinky oink
    moo moo moo
    

    如果我们希望一次替换多个,比如我们希望替换 This is <b>HTML</b> 中的 <>&lt;&gt;,可以调用上面的函数两次。但标准库提供了另外的方法进行这种替换。

    1.9. 2.1.9 Replacer 类型

    这是一个结构,没有导出任何字段,实例化通过 func NewReplacer(oldnew ...string) *Replacer 函数进行,其中不定参数 oldnew 是 old-new 对,即进行多个替换。

    解决上面说的替换问题:

    r := strings.NewReplacer("<", "&lt;", ">", "&gt;")
    fmt.Println(r.Replace("This is <b>HTML</b>!"))
    

    另外,Replacer 还提供了另外一个方法:

    func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)
    

    它在替换之后将结果写入 io.Writer 中。

    1.10. 2.1.10 Reader 类型

    看到名字就能猜到,这是实现了 io 包中的接口。它实现了 io.Reader(Read 方法),io.ReaderAt(ReadAt 方法),io.Seeker(Seek 方法),io.WriterTo(WriteTo 方法),io.ByteReader(ReadByte 方法),io.ByteScanner(ReadByte 和 UnreadByte 方法),io.RuneReader(ReadRune 方法) 和 io.RuneScanner(ReadRune 和 UnreadRune 方法)。

    Reader 结构如下:

    type Reader struct {
        s        string    // Reader 读取的数据来源
        i        int // current reading index(当前读的索引位置)
        prevRune int // index of previous rune; or < 0(前一个读取的 rune 索引位置)
    }
    

    可见 Reader 结构没有导出任何字段,而是提供一个实例化方法:

    func NewReader(s string) *Reader
    

    该方法接收一个字符串,返回的 Reader 实例就是从该参数字符串读数据。在后面学习了 bytes 包之后,可以知道 bytes.NewBufferString 有类似的功能,不过,如果只是为了读取,NewReader 会更高效。

    其他方法不介绍了,都是之前接口的实现,有兴趣的可以看看源码实现,大部分都是根据 i、prevRune 两个属性来控制。

    2. 导航

  • 02.2.md)

Copyright © studygolang.com 2013 all right reserved,powered by Gitbook该文件修订时间: 2019-07-12 13:36:57

results matching ""

    No results matching ""