Go基础-字符串

发表于 | 分类于 | 评论数： | 阅读次数：
本文字数： 8.1k | 阅读时长 ≈ 7 分钟

摘要

本文内容转自网络，个人学习记录使用，请勿传播

字符串通常有两种设计，一种是「字符」串，一种是「字节」串。「字符」串中的每个字都是定长的，而「字节」串中每个字是不定长的。Go 语言里的字符串是「字节」串，英文字符占用 1 个字节，非英文字符占多个字节。这意味着无法通过位置来快速定位出一个完整的字符来，而必须通过遍历的方式来逐个获取单个字符。

byte与rune的关系

字符通常是指unicode，可以认为所有的英文和汉字在 unicode 字符集中都有一个唯一的整数编号，一个 unicode 通常用 4 个字节来表示，对应到go中的字符rune。

1
type rune int32

使用「字符」串来表示字符串势必会浪费空间，因为所有的英文字符本来只需要 1 个字节来表示，用 rune 字符来表示的话那么剩余的 3 个字节都是零。但是「字符」串有一个好处，那就是可以快速定位。

其中 codepoint 是每个「字」的真实偏移量

而 Go 语言的字符串采用 utf8 编码，中文汉字通常需要占用 3 个字节，英文只需要 1 个字节。len() 函数得到的是字节的数量，通过下标来访问字符串得到的是「字节」。

  • byte 等同于uint8，常用来处理ascii字符
  • rune 等同于int32,常用来处理unicode或utf-8字符

遍历

bytes

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func main() {
    var s = "嘻哈china"
    for i:=0;i<len(s);i++ {
        fmt.Printf("%x ", s[i])
    }
}
-----------
e5 98 bb e5 93 88 63 68 69 6e 61

rune

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
    var s = "嘻哈china"
    for codepoint, runeValue := range s {
        fmt.Printf("%d %d ", codepoint, int32(runeValue))
    }
}

-----------
0 22075 3 21704 6 99 7 104 8 105 9 110 10 97

对字符串进行 range 遍历，每次迭代出两个变量 codepoint 和 runeValue。codepoint 表示字符起始位置，runeValue 表示对应的 unicode 编码（类型是 rune）。

内存表示

如果字符串仅仅是字节数组，那字符串的长度信息是怎么得到呢？要是字符串都是字面量的话，长度尚可以在编译期计算出来，但是如果字符串是运行时构造的，那长度又是如何得到的呢？

1
2
3
4
5
6
7
var s1 = "hello" // 静态字面量
var s2 = ""
for i:=0;i<10;i++ {
  s2 += s1 // 动态构造
}
fmt.Println(len(s1))
fmt.Println(len(s2))

为解释这点，就必须了解字符串的内存结构，它不仅仅是前面提到的那个字节数组，编译器还为它分配了头部字段来存储长度信息和指向底层字节数组的指针，图示如下，结构非常类似于切片，区别是头部少了一个容量字段。

当我们将一个字符串变量赋值给另一个字符串变量时，底层的字节数组是共享的，它只是浅拷贝了头部字段。

字符串是只读的

你可以使用下标来读取字符串指定位置的字节，但是你无法修改这个位置上的字节内容。如果你尝试使用下标赋值，编译器在语法上直接拒绝你。

1
2
3
4
5
6
7
8
package main

func main() {
    var s = "hello"
    s[0] = 'H'
}
--------
./main.go:5:7: cannot assign to s[0]

切割

字符串在内存形式上比较接近于切片，它也可以像切片一样进行切割来获取子串。子串和母串共享底层字节数组。

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func main() {
    var s1 = "hello world"
    var s2 = s1[3:8]
    fmt.Println(s2)
}

-------
lo wo

字节切片和字符串的相互转换

在使用 Go 语言进行网络编程时，经常需要将来自网络的字节流转换成内存字符串，同时也需要将内存字符串转换成网络字节流。Go 语言直接内置了字节切片和字符串的相互转换语法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
    var s1 = "hello world"
    var b = []byte(s1)  // 字符串转字节切片
    var s2 = string(b)  // 字节切片转字符串
    fmt.Println(b)
    fmt.Println(s2)
}

--------
[104 101 108 108 111 32 119 111 114 108 100]
hello world

从节省内存的角度出发，你可能会认为字节切片和字符串的底层字节数组是共享的。但是事实不是这样的，底层字节数组会被拷贝。如果内容很大，那么转换操作是需要一定成本的。

那为什么需要拷贝呢？因为字节切片的底层数组内容是可以修改的，而字符串的底层字节数组是只读的，如果共享了，就会导致字符串的只读属性不再成立。

字符串拼接

直接使用运算符

1
2
3
4
5
6
7
func BenchmarkAddStringWithOperator(b *testing.B) {
    hello := "hello"
    world := "world"
    for i := 0; i < b.N; i++ {
        _ = hello + "," + world
    }
}

golang 里面的字符串都是不可变的，每次运算都会产生一个新的字符串，所以会产生很多临时的无用的字符串，不仅没有用，还会给 gc 带来额外的负担，所以性能比较差

fmt.Sprintf()

1
2
3
4
5
6
7
func BenchmarkAddStringWithSprintf(b *testing.B) {
    hello := "hello"
    world := "world"
    for i := 0; i < b.N; i++ {
        _ = fmt.Sprintf("%s,%s", hello, world)
    }
}

内部使用 []byte 实现，不像直接运算符这种会产生很多临时的字符串，但是内部的逻辑比较复杂，有很多额外的判断，还用到了 interface，所以性能也不是很好

strings.Join()

1
2
3
4
5
6
7
func BenchmarkAddStringWithJoin(b *testing.B) {
    hello := "hello"
    world := "world"
    for i := 0; i < b.N; i++ {
        _ = strings.Join([]string{hello, world}, ",")
    }
}

join会先根据字符串数组的内容，计算出一个拼接之后的长度，然后申请对应大小的内存，一个一个字符串填入，在已有一个数组的情况下，这种效率会很高，但是本来没有，去构造这个数据的代价也不小

buffer.WriteString()

1
2
3
4
5
6
7
8
9
10
11
func BenchmarkAddStringWithBuffer(b *testing.B) {
    hello := "hello"
    world := "world"
    for i := 0; i < 1000; i++ {
        var buffer bytes.Buffer
        buffer.WriteString(hello)
        buffer.WriteString(",")
        buffer.WriteString(world)
        _ = buffer.String()
    }
}

这个比较理想，可以当成可变字符使用，对内存的增长也有优化，如果能预估字符串的长度，还可以用 buffer.Grow() 接口来设置 capacity

大量字符串拼接性能测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/ fmt.Printf
func BenchmarkFmtSprintfMore(b *testing.B) {
    var s string
    for i := 0; i < b.N; i++ {
        s += fmt.Sprintf("%s%s", "hello", "world")
    }
    fmt.Errorf(s)
}
// 加号 拼接
func BenchmarkAddMore(b *testing.B) {
    var s string
    for i := 0; i < b.N; i++ {
        s += "hello" + "world"
    }
    fmt.Errorf(s)
}

// strings.Join
func BenchmarkStringsJoinMore(b *testing.B) {

    var s string
    for i := 0; i < b.N; i++ {
        s += strings.Join([]string{"hello", "world"}, "")

    }
    fmt.Errorf(s)
}

// bytes.Buffer
func BenchmarkBufferMore(b *testing.B) {

    buffer := bytes.Buffer{}
    for i := 0; i < b.N; i++ {
        buffer.WriteString("hello")
        buffer.WriteString("world")

    }
    fmt.Errorf(buffer.String())
}
1
2
3
4
5
6
7
8
9
10
~/gopath/src/test/stringgo test -bench="."
goos: darwin
goarch: amd64
pkg: test/string
BenchmarkFmtSprintfMore-4         300000        118493 ns/op
BenchmarkAddMore-4                300000        124940 ns/op
BenchmarkStringsJoinMore-4        300000        117050 ns/op
BenchmarkBufferMore-4           100000000           37.2 ns/op
PASS
ok      test/string 112.294s

单次字符串拼接性能测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
func BenchmarkFmtSprintf(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := fmt.Sprintf("%s%s", "hello", "world")
        fmt.Errorf(s)
    }

}

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := "hello" + "world"
        fmt.Errorf(s)
    }
}
func BenchmarkStringsJoin(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := strings.Join([]string{"hello", "world"}, "")
        fmt.Errorf(s)
    }
}
func BenchmarkBuffer(b *testing.B) {

    for i := 0; i < b.N; i++ {
        b := bytes.Buffer{}
        b.WriteString("hello")
        b.WriteString("world")
        fmt.Errorf(b.String())
    }
}
1
2
3
4
5
6
7
8
9
10
 ~/gopath/src/test/stringgo test -bench="."
goos: darwin
goarch: amd64
pkg: test/string
BenchmarkFmtSprintf-4       10000000           200 ns/op
BenchmarkAdd-4              20000000            93.6 ns/op
BenchmarkStringsJoin-4      10000000           152 ns/op
BenchmarkBuffer-4           10000000           175 ns/op
PASS
ok      test/string 7.818ss

结论

  • 在已有字符串数组的场合，使用 strings.Join() 能有比较好的性能
  • 在一些性能要求较高的场合，尽量使用 buffer.WriteString() 以获得更好的性能
  • 性能要求不太高的场合，直接使用运算符，代码更简短清晰，能获得比较好的可读性
  • 如果需要拼接的不仅仅是字符串，还有数字之类的其他需求的话，可以考虑 fmt.Sprintf()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package main

import (
	"fmt"
	s "strings"
	"unicode"
)

var f = fmt.Printf

func main() {
	upper := s.ToUpper("Hello there!")
	f("To Upper: %s\n", upper)
	f("To Lower: %s\n", s.ToLower("Hello THERE"))

	f("%s\n", s.Title("tHis wiLL be A title!"))

	f("EqualFold: %v\n", s.EqualFold("Mihalis", "MIHAlis"))
	f("EqualFold: %v\n", s.EqualFold("Mihalis", "MIHAli"))
	f("Prefix: %v\n", s.HasPrefix("Mihalis", "Mi"))
	f("Prefix: %v\n", s.HasPrefix("Mihalis", "mi"))
	f("Suffix: %v\n", s.HasSuffix("Mihalis", "is"))
	f("Suffix: %v\n", s.HasSuffix("Mihalis", "IS"))

	f("Index: %v\n", s.Index("Mihalis", "ha"))
	f("Index: %v\n", s.Index("Mihalis", "Ha"))
	f("Count: %v\n", s.Count("Mihalis", "i"))
	f("Count: %v\n", s.Count("Mihalis", "I"))
	f("Repeat: %s\n", s.Repeat("ab", 5))

	f("TrimSpace: %s\n", s.TrimSpace(" \tThis is a line. \n"))
	f("TrimLeft: %s", s.TrimLeft(" \tThis is a\t line. \n", "\n\t "))
	f("TrimRight: %s\n", s.TrimRight(" \tThis is a\t line. \n", "\n\t "))
	f("Compare: %v\n", s.Compare("Mihalis", "MIHALIS"))
	f("Compare: %v\n", s.Compare("Mihalis", "Mihalis"))
	f("Compare: %v\n", s.Compare("MIHALIS", "MIHalis"))

	f("Fields: %v\n", s.Fields("This is a string!"))
	f("Fields: %v\n", s.Fields("Thisis\na\tstring!"))

	f("%s\n", s.Split("abcd efg", ""))
	f("%s\n", s.Replace("abcd efg", "", "_", -1))
	f("%s\n", s.Replace("abcd efg", "", "_", 4))
	f("%s\n", s.Replace("abcd efg", "", "_", 2))
	lines := []string{"Line 1", "Line 2", "Line 3"}
	f("Join: %s\n", s.Join(lines, "+++"))

	f("SplitAfter: %s\n", s.SplitAfter("123++432++", "++"))

	trimFunction := func(c rune) bool {
		return !unicode.IsLetter(c)
	}
	f("TrimFunc: %s\n", s.TrimFunc("123 abc ABC \t .", trimFunction))
}