Go语言字符串的用法还是比较简单的，罕用也就是字符串相加，字符串与byte切片、rune切片相互转换，字符串输入等等操作。那有什么可学的呢？其实还是有一些细节须要关注，比方字符串"只读"个性，字符串编码等等。
基本操作
字符串只读？是的，就是你想的那样，只读就是不能批改的意思。那上面程序怎么解释呢？
package mainimport "fmt"func main() { str := "hello" str += " world" fmt.Println(str) //hello world}看到了吧，我的确扭转了字符串str的值。是的，字符串str的确扭转了，而字符串的确也是只读的；这里可能存在一些歧义，筹备的说，应该是字符串变量str指向了新的字符串。字符串"hello"并没有扭转，只是创立了一个新的字符串"hello world"，同时让字符串变量str指向这个新的字符串。还有一个办法验证这个说法：
go tool compile -S -N -l test.gogo.string."hello" SRODATA dupok size=5 0x0000 68 65 6c 6c 6f hellogo.string." world" SRODATA dupok size=6 0x0000 20 77 6f 72 6c 64 worldgo.string."hello"所属内存区域是SRODATA，RO就是read only只读的意思。再举一个事例：字符串不能依照索引操作，如果将将字符串转换为byte切片，按理说byte切片与字符串底层数据应该共用，那么批改该byte切片，字符串也应该同步扭转。
package mainimport "fmt"func main() { str := "hello world" //字符串转化为byte切片，批改切片元素 b := []byte(str) b[0] = 69 fmt.Println(str) //hello world for _, c := range b { fmt.Printf("%c", c) //Eello world }}byte切片的确被批改了，而字符串变量str却没有扭转，为什么呢？因为字符串是只读的，所以在[]byte(str)强制类型转化时，会执行了数据的拷贝，防止批改byte切片影响原字符串。
最初在应用字符串时，还须要留神一个问题：len用于获取字符串长度，纯英文字符串一切正常，然而当字符串中蕴含中文时，状况就有些不同了。
package mainimport "fmt"func main() { str := "Go语言还是挺不错的" fmt.Println(len(str)) //26}str字符串蕴含2个英文字母，8个中文汉字，输入显示字符串长度是26。这就有Go语言字符串编码无关了，Go语言字符串采取utf-8编码，一个中文汉字占3个字节，所以算下来字符串长度就是26了。那的确想获取字符串的字符数目呢？可通过上面形式：
package mainimport "fmt"func main() { str := "Go语言还是挺不错的" r := []rune(str) //rune其实就是int32，4字节示意一个字符；r相当于字符切片 fmt.Println(len(r)) n := 0 for _, _ = range str { //range遍历字符串，返回字符索引，与以后字符 n ++ } fmt.Println(n)}实现原理
上面咱们将联合底层实现原理，一一解释下面的几种状况：字符串相加，字符串与byte切片转换，字符串与rune切片相互转换。
字符串构造定义以及基本操作能够在文件runtime/string.go查看，字符串构造定义比切片相似，略微简略些，因为字符串只读，所以没有必要预调配空间，也就不须要cap字段：
type stringStruct struct { str unsafe.Pointer len int}str指向底层真正存储字符串的数组，只是咱们不能获取到该数组援用，所以也就无奈间接批改字符串。而字符串在作为输出参数时，传递的也是该构造；len函数获取字符串长度时，字符串变量地址 +8字节就是了，这些都和上一大节切片的基本原理十分相似。
s字符串相加，编译阶段会替换为函数调用concatstrings，其实现也挺简略的，计算所有字符串长度之和，申请内存，拷贝原始多个字符串到新的内存，结构字符串构造体stringStruct返回。函数concatstrings外围逻辑如下：
func concatstrings(a []string) string { l := 0 //计算所有字符串长度之和 for _, x := range a { n := len(x) l += n } var s string var b []byte //申请内存 p := mallocgc(uintptr(l), nil, false) //结构字符串stringStruct构造 (*stringStruct)(unsafe.Pointer(s)).str = p (*stringStruct)(unsafe.Pointer(s)).len = l //借切片拷贝 *(*slice)(unsafe.Pointer(&b)) = slice{p, l, l} for _, x := range a { copy(b, x) b = b[len(x):] } return s}看到了吧，字符串相加，是申请了新的内存，并执行了数据拷贝，原始字符串没有产生任何扭转，往往扭转的只是字符串变量指向的内存地址。
字符串转化为byte切片，批改切片，为什么字符串却没有扭转，要答复这个问题，只能看字符串转化切片的实现函数了。通过[]byte("")模式类型强转，编译阶段会替换为函数调用stringtoslicebyte，而该函数其实也是申请新的内存，拷贝数据，结构切片构造返回。函数stringtoslicebyte外围逻辑如下：
func stringtoslicebyte(s string) []byte { var b []byte //申请内存 cap := roundupsize(uintptr(len(s))) p := mallocgc(cap, nil, false) //结构切片构造 & 拷贝数据 *(*slice)(unsafe.Pointer(&b)) = slice{p, len(s), int(cap)} copy(b, s) return b}字符串转化为rune切片的逻辑与stringtoslicebyte十分相似，只是rune类型占4个字节罢了。这里就不再赘述了。
罕用库函数 & stringBuilder
包strings定义了一些罕用的字符串库函数，如下：
//字符串比拟func Compare(a, b string) int//字符串是否以xxx开始func HasPrefix(s, prefix string) bool//字符串是否以xxx完结func HasSuffix(s, suffix string) bool//字符串是否蕴含指定子串func Contains(s, substr string) bool//返回子串在字符串是的地位，-1字符串不蕴含子串，还有更高级的字符串查找stringFinderfunc Index(s, substr string) int//字符串数组转换为字符串，按sep分隔func Join(elems []string, sep string) string//字符串分隔为字符串数组func Split(s, sep string) []string//字符串替换，还有更高级的字符串替换Replacerfunc Replace(s, old, new string, n int) string//字符串大小写转换func ToLower(s string) stringfunc ToUpper(s string) string……这些库函数非常简单，我就不一一介绍了，这里次要提一下字符串构建stringBuilder。下面咱们说过Go语言字符串是只读的，不能批改的，字符串相加也是通过申请内存与数据拷贝形式实现，那么如果存在大量的字符串相加呢？每次都申请内存拷贝数据效率会十分差，这也是stringBuilder存在的起因。stringBuilder底层保护了一个[]byte，追加字符串只是追加到该切片，最终一次性转换该切片为字符串，防止了两头N屡次的内存申请与数据拷贝。
咱们写一个小事例，测试验证大量字符串相加状况下，stringBuilder带来的性能晋升：
package mainimport ( "fmt" "strings" "time")func main() { count := 100000 start := time.Now() s := "" for i := 0; i < count; i ++ { s += "abc" } fmt.Println(time.Now().Sub(start).Microseconds()) //1466286奥妙 start1 := time.Now() b := strings.Builder{} for i := 0; i < count; i ++ { b.WriteString("abc") } fmt.Println(time.Now().Sub(start1).Microseconds()) //492奥妙，效率晋升非常明显。}字符串编码
下面咱们介绍到，Go语言一个汉字占3字节，所有字符串蕴含汉字时，len返回字符串长度大于字符数。咱们都晓得计算机存储只辨认二进制，所以字符须要编码为二进制，那么Go语言字符串到底采取哪种编码方式呢？
先简略介绍下几个罕用编码。最简略的编码就是ASCII码了，只需一个字节，能够示意一些根本的字符、数字与字母，如"? \ ! . 10 A b c"。那么中文怎么办？一个字节必定是无奈满足的。于是诞生了unicode编码，占两个字节，能够包容所有语言的大部分文字。在unicode编码方式下，所有字符都须要两个字节，不管汉字还是字母（高字节全0，低字节就是ASCII码），显然对于字母有些节约空间了。所以又诞生了utf-8编码，这时候字符能够占1-4字节（可变的），中文汉字在utf-8编码方式占3个字节，英文字母占1个字节，Go语言采纳的就是该编码方式。这下终于明确了如何计算蕴含汉字的字符串长度了。
话不多说，再来个小事例测试一下：
package mainimport "fmt"func main() { str := "Go语言还是挺不错的" r := []rune(str) for _, v := range r{ fmt.Printf("%x ", v) }}//47 6f 8bed 8a00 8fd8 662f 633a 4e0d 9519 7684如同有些许不对劲，这些汉字貌似只占了2字节，这些是utf-8编码吗？其实下面输入的都是unicode编码，所有字符都占2字节。读者能够找一些工具测试下，将下面字符串转换为unicode，比照看后果是否统一。
必须要阐明的是，rune其实就是int32，该类型原本就占4字节。Go语言字符串在存储时，的确是采纳utf-8编码，然而当转化为[]rune操作时，又将所有字符转化为unicode编码。字符串与[]rune转化函数为stringtoslicerune/slicerunetostring。unicode编码与utf-8编码转化函数定义在文件runtime/utf8.go，别离为decoderune/encoderune。
这里就不具体介绍这几个函数的具体实现了。不过须要留神的是，在应用range遍历字符串时，返回的是字符，也存在utf-8到unicode编码转换。range的实现逻辑在源码中找不到，是编译阶段主动生成的，如下：
//参考：cmd/compile/internal/walk/range.go:walkRange// Transform string range statements like "for v1, v2 = range a" into//// ha := a// for hv1 := 0; hv1 < len(ha); {// hv1t := hv1// hv2 := rune(ha[hv1])// if hv2 < utf8.RuneSelf {// hv1++// } else {// hv2, hv1 = decoderune(ha, hv1)// }// v1, v2 = hv1t, hv2// // original body// }总结
字符串的根本应用与实现原理就解说到这里了，要牢记字符串是不可读的，而字符串相加，字符串与[]byte/[]rune相互转换都是通过申请内存以及数据拷贝形式实现的。另外要留神中文汉字编码占3个字节，所以蕴含中文汉字的字符串，其长度与字符数是不同的。