2.1 strings — 字符串操作

字符串常见操作有:

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

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

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

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

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

有三个函数做这件事:

// 子串substr在s中,返回true
func Contains(s, substr string) bool
// chars中任何一个Unicode代码点在s中,返回true
func ContainsAny(s, chars string) bool
// Unicode代码点r在s中,返回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相关函数的实现,我们后面介绍。

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

2.1.3 字符串分割为[]string

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

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

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 源码留给读者自己阅读。

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" " "]
[""]

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
}

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 的代码点。

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

2.1.7 字符串重复几次

函数签名如下:

func Repeat(s string, count int) string

这个函数使用很简单:

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

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;,可以调用上面的函数两次。但标准库提供了另外的方法进行这种替换。

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 中。

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 两个属性来控制。

导航


书籍推荐