字符串

寒江蓑笠翁大约 12 分钟

字符串

在Go中,字符串本质上是一个不可变的只读的字节数组,也是一片连续的内存空间。


字面量

前面提到过字符串有两种字面量表达方式,分为普通字符串和原生字符串。


普通字符串

普通字符串由""双引号表示,支持转义,不支持多行书写,下列是一些普通字符串

"这是一个普通字符串\n"
"abcdefghijlmn\nopqrst\t\\uvwxyz"
这是一个普通字符串
abcdefghijlmn
opqrst  \uvwxyz

原生字符串

原生字符串由反引号表示,不支持转义,支持多行书写,原生字符串里面所有的字符都会原封不动的输出,包括换行和缩进。

`这是一个原生字符串,换行
	tab缩进,\t制表符但是无效,换行
	"这是一个普通字符串"
	
	结束
`
这是一个原生字符串,换行
        tab缩进,\t制表符但是无效,换行
        "这是一个普通字符串"

        结束

访问

因为字符串本质是字节数组,所以字符串的访问形式跟数组切片完全一致,例如访问字符串第一个元素

func main() {
   str := "this is a string"
   fmt.Println(str[0])
}

输出是字节而不是字符

116

切割字符串

func main() {
   str := "this is a string"
   fmt.Println(string(str[0:4]))
}
this

尝试修改字符串元素

func main() {
   str := "this is a string"
   str[0] = 'a' // 无法通过编译
   fmt.Println(str)
}
main.go:7:2: cannot assign to str[0] (value of type byte)

虽然没法修改字符串,但是可以覆盖

func main() {
   str := "this is a string"
   str = "that is a string"
   fmt.Println(str)
}
that is a string

转换

字符串可以转换为字节切片,而字节切片或字节数组也可以转换为字符串,例子如下:

func main() {
   str := "this is a string"
   // 显式类型转换为字节切片
   bytes := []byte(str)
   fmt.Println(bytes)
   // 显式类型转换为字符串
   fmt.Println(string(bytes))
}

字符串的内容是只读的不可变的,无法修改,但是字节切片是可以修改的。

func main() {
	str := "this is a string"
	fmt.Println(&str)
	bytes := []byte(str)
    // 修改字节切片
	bytes = append(bytes, 96, 97, 98, 99)
    // 赋值给原字符串
	str = string(bytes)
	fmt.Println(str)
}

将字符串转换成字节切片以后,两者之间毫无关联,因为Go会新分配一片内存空间给字节切片,再将字符串的内存复制过去,对字节切片进行修改不会对原字符串产生任何影响,这么做是为了内存安全。

在这种情况下,如果要转换的字符串或字节切片很大,那么性能开销就会很高。不过你也可以通过unsafe库来实现无复制转换,不过背后的安全问题需要自己承担,比如下面的例子,b1和s1的地址是一样的。

func main() {
	s1 := "hello world"
	b1 := unsafe.Slice(unsafe.StringData(s1), len(s1))
	fmt.Printf("%p %p", unsafe.StringData(s1), unsafe.SliceData(b1))
}
0xe27bb2 0xe27bb2

长度

字符串的长度,其实并不是字面量的长度,而是字节数组的长度,只是大多数时候都是ANSCII字符,刚好能用一个字节表示,所以恰好与字面量长度相等,求字符串长度使用内置函数len,例子如下:

func main() {
   str := "this is a string" // 看起来长度是16
   str2 := "这是一个字符串" // 看起来长度是7
   fmt.Println(len(str), len(str2))
}
16 21

看起来中文字符串比英文字符串短,但是实际求得的长度却比英文字符串长。这是因为在unicode编码中,一个汉字在大多数情况下占3个字节,一个英文字符只占一个字节,通过输出字符串第一个元素可以看出结果:

func main() {
   str := "this is a string"
   str2 := "这是一个字符串"
   fmt.Println(string(str[0]))
   fmt.Println(string(str2[0]))
   fmt.Println(string(str2[0:3]))
}
t // 字母t
è // 意大利语
这 // 中文汉字

拷贝

类似数组切片的拷贝方式,字符串拷贝其实是字节切片拷贝,使用内置函数copy

func main() {
   var dst, src string
   src = "this is a string"
   desBytes := make([]byte, len(src))
   copy(desBytes, src)
   dst = string(desBytes)
   fmt.Println(src, dst)
}

也可以使用strings.clone函数,但其实内部实现都差不多

func main() {
   var dst, src string
   src = "this is a string"
   dst = strings.Clone(src)
   fmt.Println(src, dst)
}

拼接

字符串的拼接使用+操作符

func main() {
   str := "this is a string"
   str = str + " that is a int"
   fmt.Println(str)
}

也可以转换为字节切片再进行添加元素

func main() {
   str := "this is a string"
   bytes := []byte(str)
   bytes = append(bytes, "that is a int"...)
   str = string(bytes)
   fmt.Println(str)
}

以上两种拼接方式性能都很差,一般情况下可以使用,但如果对应性能有更高要求,可以使用strings.Builder

func main() {
   builder := strings.Builder{}
   builder.WriteString("this is a string ")
   builder.WriteString("that is a int")
   fmt.Println(builder.String())
}
this is a string that is a int

遍历

在本文开头就已经提到过,Go中的字符串就是一个只读的字节切片,也就是说字符串的组成单位是字节而不是字符。这种情况经常会在遍历字符串时遇到,例如下方的代码

func main() {
	str := "hello world!"
	for i := 0; i < len(str); i++ {
		fmt.Printf("%d,%x,%s\n", str[i], str[i], string(str[i]))
	}
}

例子中分别输出了字节的十进制形式和十六进制形式。

104,68,h
101,65,e
108,6c,l
108,6c,l
111,6f,o
32,20,  
119,77,w
111,6f,o
114,72,r
108,6c,l
100,64,d
33,21,! 

由于例子中的字符都是属于ASCII字符,只需要一个字节就能表示,所以结果恰巧每一个字节对应一个字符。但如果包含非ASCII字符结果就不同了,如下

func main() {
	str := "hello 世界!"
	for i := 0; i < len(str); i++ {
		fmt.Printf("%d,%x,%s\n", str[i], str[i], string(str[i]))
	}
}

通常情况下,一个中文字符会占用3个字节,所以就可能会看到以下结果

104,68,h
101,65,e
108,6c,l
108,6c,l
111,6f,o
32,20,
228,e4,ä
184,b8,¸
150,96,–
231,e7,ç
149,95,•
140,8c,Œ
33,21,!

按照字节来遍历会把中文字符拆开,这显然会出现乱码。Go字符串是明确支持utf8的,应对这种情况就需要用到rune类型,在使用for range进行遍历时,其默认的遍历单位类型就是一个rune,例如下方代码

func main() {
   str := "hello 世界!"
   for _, r := range str {
      fmt.Printf("%d,%x,%s\n", r, r, string(r))
   }
}

输出如下

104,68,h
101,65,e     
108,6c,l     
108,6c,l     
111,6f,o     
32,20,       
19990,4e16,世
30028,754c,界
33,21,!  

rune本质上是int32的类型别名,unicode字符集的范围位于0x0000 - 0x10FFFF之间,最大也只有三个字节,合法的UTF8编码最大字节数只有4个字节,所以使用int32来存储是理所当然,上述例子中将字符串转换成[]rune再遍历也是一样的道理,如下

func main() {
   str := "hello 世界!"
   runes := []rune(str)
   for i := 0; i < len(runes); i++ {
      fmt.Println(string(runes[i]))
   }
}

还可以使用uft8包下的工具,例如

func main() {
	str := "hello 世界!"
	for i, w := 0, 0; i < len(str); i += w {
		r, width := utf8.DecodeRuneInString(str[i:])
		fmt.Println(string(r))
		w = width
	}
}

这两个例子的输出都是相同的。

提示

关于字符串的更多细节,可以前往Strings, bytes, runes and characters in Goopen in new window了解。