1. 字符串 string 类型

Go 语言中字符串的内部实现使用 UTF-8 编码，通过 rune 类型，可以方便地对每个 UTF-8 字符进行访问。当然， Go 语言也支持按照传统的 ASCII 码方式逐字符进行访问。

1. 字符串是常量，可以通过类似数组索引访问其字节单元，但是不能修改某个字节的值；

var a string = "hello,world"
b := a[0]
a[1] = "a" // error

内置的 len 函数可以返回一个字符串中的字节数目（不是 rune 字符数目）。

s := "hello, world"
fmt.Println(len(s))     // "12"
fmt.Println(s[0], s[7]) // "104 119" ('h' and 'w')

注意：第 i 个字节并不一定是字符串的第 i 个字符，因为对于非 ASCII 字符的 UTF8 编码会要两个或多个字节。

2. 字符串转换为切片 []byte(s) 要慎用，每转换一次需要复制一份内存，尤其是字符串数据量较大时；

3. 字符串末尾不包含 NULL 字符，与 C/C++ 不一样；

4. 字符串类型底层实现是一个二元的数据结构，一个是指针指向字节数组的起点，另一个是字符串的长度；

// runtime/string.gotype stringStruct struct {str unsafe . Pointer //指向底层字节数组的指针len int //字节数组长度
}

5. 基于字符串创建的切片和原字符串指向相同的底层字符数组，一样不能修改，对字符串的切片操作返回的子串仍是 string ，而非 slice ；

6. 字符串和切片的转换：字符串可以转换为字节数组，也可以转换为 Unicode 数组；

a := "hello , 世界!"
b := []byte(a)
c :=[]rune(a)

7. 字符串支持连接运算，可以通过 len() 获取字符串的长度； len 是 Golang 内置的一个函数，这个函数返回字符串的长度，切片长度，数组长度，通道长度。如果用于获取字符串长度时，当字符串为空， len 返回值是 0。

8. 获取字符串中某个字节的地址属于非法行为，例如 &str[i] ；

9. 使用双引号""表示字符串时不能跨行，如果想要在源码中嵌入一个多行字符串时，就必须使用 ` 反引号(Esc 下面的字符)，代码如下：

package mainimport "fmt"func main() {str := `first line,second line,third line,\r	\n`
// 在这种方式下，反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。fmt.Println(str)
}

输出：

			first line,second line,third line,\r\n

示例代码如下：

package mainimport "fmt"func main() {var s string = "hello"var a string = ",world"s1 := s[0]s2 := s[:3]s3 := []byte(s)s4 := []rune(s)sLength := len(s)c := s + afmt.Printf("s1 is %v, s1 type is %T\n", s1, s1)fmt.Printf("s2 is %v, s2 type is %T\n", s2, s2)fmt.Printf("s3 is %v, s3 type is %T\n", s3, s3)fmt.Printf("s4 is %v, s4 type is %T\n", s4, s4)fmt.Printf("sLength is %v \n", sLength)fmt.Printf("c is %v \n", c)
}

输出结果：

s1 is 104, s1 type is uint8
s2 is hel, s2 type is string
s3 is [104 101 108 108 111], s3 type is []uint8
s4 is [104 101 108 108 111], s4 type is []int32
sLength is 5 
c is hello,world 

字符串值也可以用字符串面值方式编写，只要将一系列字节序列包含在双引号内即可：

"hello, 世界"

因为 Go 语言源文件总是用 UTF8 编码，并且 Go 语言的文本字符串也以 UTF8 编码的方式处理，因此我们可以将 Unicode 码点也写到字符串面值中。

在一个双引号包含的字符串面值中，可以用以反斜杠\开头的转义序列插入任意的数据。下面的换行、回车和制表符等是常见的 ASCII 控制代码的转义方式：

\a      响铃
\b      退格
\f      换页
\n      换行
\r      回车
\t      制表符
\v      垂直制表符
\'      单引号（只用在 '\'' 形式的rune符号面值中）
\"      双引号（只用在 "..." 形式的字符串面值中）
\\      反斜杠

可以通过十六进制或八进制转义在字符串面值中包含任意的字节。

• 一个十六进制的转义形式是\xhh，其中两个 h 表示十六进制数字（大写或小写都可以）；
• 一个八进制转义形式是\ooo，包含三个八进制的 o 数字（0 到 7），但是不能超过\377（译注：对应一个字节的范围，十进制为255）；

2. 字符 rune 类型

Go 默认的字符编码就是 UTF-8 类型。Go 语言的字符有以下两种：

• 一种是 uint8 类型，或者叫 byte 型（ byte 是 unit 的别名），代表了 ASCII 码的一个字符。

• 另一种是 rune 类型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。 rune 类型等价于 int32 类型，占用 4 个字节。

rune 类型是 int32 的一个别名， rune 主要用于表示 UTF-8 编码时的字符类型。通常情况下一个字符就是一个字节，在 Golang 中用 byte 关键字来表示字节，而 UTF-8 编码的字符，可能会存在一个字符用三个字节表示。如果使用 byte 类型来存储 UTF-8 编码的字符串，就会导致读取单个字节时值没有意义的情况。所以 Golang 中使用 rune 来存储 UTF-8 编码的字符。

3. 字节 byte 类型

byte 用来表示字节，一个字节是 8 位。定义一个字节类型变量的语法是：

var b1 byte
var b2 = 'c'
var b3 byte = 'c'
b4 := 'c'

byte 类型变量默认初始值是 0。byte 类型是 uint8 类型的一个别名。

4. UTF-8 和 Unicode 有何区别

Unicode 与 ASCII 类似，都是一种字符集。

Unicode 收集了这个世界上所有的符号系统，包括重音符号和其它变音符号，制表符和回车符，还有很多神秘的符号，每个符号都分配一个唯一的 Unicode 码点， Unicode 码点对应 Go 语言中的 rune 整数类型（ rune 是 int32 等价类型）。

我们可以将一个符号序列表示为一个 int32 序列。这种编码方式叫 UTF-32 或 UCS-4 ，每个 Unicode 码点都使用同样大小的 32bit 来表示。这种方式比较简单统一，但是它会浪费很多存储空间，因为大多数计算机可读的文本是 ASCII 字符，本来每个 ASCII 字符只需要 8bit 或 1 字节就能表示。而且即使是常用的字符也远少于 65,536 个，也就是说用 16bit 编码方式就能表达常用字符。但是，还有其它更好的编码方法吗？

UTF8 是一个将 Unicode 码点编码为字节序列的变长编码。 UTF8 编码使用 1 到 4 个字节来表示每个 Unicode 码点， ASCII 部分字符只使用 1 个字节，常用字符部分使用 2 或 3 个字节表示。

每个符号编码后第一个字节的高端 bit 位用于表示编码总共有多少个字节。如果第一个字节的高端 bit为 0，则表示对应 7bit 的 ASCII 字符， ASCII 字符每个字符依然是一个字节，和传统的 ASCII 编码兼容。如果第一个字节的高端 bit 是 110，则说明需要 2 个字节；后续的每个高端 bit 都以 10 开头。更大的 Unicode 码点也是采用类似的策略处理。

0xxxxxxx                             runes 0-127    (ASCII)
110xxxxx 10xxxxxx                    128-2047       (values <128 unused)
1110xxxx 10xxxxxx 10xxxxxx           2048-65535     (values <2048 unused)
11110xxx 10xxxxxx 10xxxxxx 10xxxxxx  65536-0x10ffff (other values unused)

变长的编码无法直接通过索引来访问第 n 个字符，但是 UTF8 编码获得了很多额外的优点：

1. 首先 UTF8 编码比较紧凑，完全兼容 ASCII 码，并且可以自动同步；
2. 它可以通过向前回朔最多 3 个字节就能确定当前字符编码的开始字节的位置。它也是一个前缀编码，所以当从左向右解码时不会有任何歧义也并不需要向前查看（译注：像 GBK 之类的编码，如果不知道起点位置则可能会出现歧义）。
3. 没有任何字符的编码是其它字符编码的子串，或是其它编码序列的字串，因此搜索一个字符时只要搜索它的字节编码序列即可，不用担心前后的上下文会对搜索结果产生干扰。同时 UTF8 编码的顺序和 Unicode 码点的顺序一致，因此可以直接排序 UTF8 编码序列。同时因为没有嵌入的 NULL (0)字节，可以很好地兼容那些使用 NULL 作为字符串结尾的编程语言。

Go 语言的源文件采用 UTF8 编码，并且 Go 语言处理 UTF8 编码的文本也很出色。 unicode 包提供了诸多处理 rune 字符相关功能的函数（比如区分字母和数字，或者是字母的大写和小写转换等）， unicode/utf8 包则提供了用于 rune 字符序列的 UTF8 编码和解码的功能。

Go 语言字符串面值中的 Unicode 转义字符让我们可以通过 Unicode 码点输入特殊的字符。有两种形式：

1. \uhhhh对应 16bit 的码点值；
2. \Uhhhhhhhh对应 32bit 的码点值；

其中 h 是一个十六进制数字，一般很少需要使用 32bit 的形式。每一个对应码点的 UTF8 编码。例如：下面的字母串面值都表示相同的值：

"世界"
"\xe4\xb8\x96\xe7\x95\x8c"
"\u4e16\u754c"
"\U00004e16\U0000754c"

上面三个转义序列都为第一个字符串提供替代写法，但是它们的值都是相同的。

Unicode 转义也可以使用在 rune 字符中。下面三个字符是等价的：

'世' '\u4e16' '\U00004e16'

对于小于 256 的码点值可以写在一个十六进制转义字节中，例如\x41对应字符 'A' ，但是对于更大的码点则必须使用\u或\U转义形式。因此，\xe4\xb8\x96并不是一个合法的 rune 字符，虽然这三个字节对应一个有效的 UTF8 编码的码点。

我们看下包含了中西两种字符。如下所示字符串包含 13 个字节，以 UTF8 形式编码，但是只对应 9 个 Unicode 字符：

import "unicode/utf8"
s := "Hello, 世界"
fmt.Println(len(s))                    // "13"
fmt.Println(utf8.RuneCountInString(s)) // "9"

为了处理这些真实的字符，我们需要一个 UTF8 解码器。 unicode/utf8 包提供了该功能，我们可以这样使用：

for i := 0; i < len(s); {r, size := utf8.DecodeRuneInString(s[i:])fmt.Printf("%d\t%c\n", i, r)i += size
}

字符集为每个字符分配一个唯一的 ID，我们使用到的所有字符在 Unicode 字符集中都有一个唯一的 ID，例如上面例子中的 a 在 Unicode 与 ASCII 中的编码都是 97。汉字“你”在 Unicode 中的编码为 20320，在不同国家的字符集中，字符所对应的 ID 也会不同。而无论任何情况下，Unicode 中的字符的 ID 都是不会变化的。

UTF-8 是编码规则，将 Unicode 中字符的 ID 以某种方式进行编码，UTF-8 的是一种变长编码规则，从 1 到 4 个字节不等。编码规则如下：

• 0xxxxxx 表示文字符号 0～127，兼容 ASCII 字符集。
• 从 128 到 0x10ffff 表示其他字符。

根据这个规则，拉丁文语系的字符编码一般情况下每个字符占用一个字节，而中文每个字符占用 3 个字节。

广义的 Unicode 指的是一个标准，它定义了字符集及编码规则，即 Unicode 字符集和 UTF-8、UTF-16 编码等。

5. golang 中获取字符串长度

5.1 不同编码符串定义

因为不同字符具有不同的编码格式。拉丁字母一个字符只要一个字节就行，而中文则可能需要两到三个字节；UNICODE 把所有字符设置为 2 个字节，UTF-8 格式则把所有字符设置为 1–3 个字节。

因此，字符串长度的获得，不等于按字节数查找，而要根据不同字符编码查找。

5.2 获取字符串长度的方法

golang 有自己的默认判断长度函数 len() ；但遗憾的是，len() 函数判断字符串长度的时候，是判断字符的字节数而不是字符长度。因此，在中文字符下，应该采用如下方法：

1. 使用 bytes.Count() 统计
2. 使用 strings.Count() 统计
3. 将字符串转换为 []rune 后调用 len 函数进行统计
4. 使用 utf8.RuneCountInString()统计

由于中文字符可能占用 1-3 个字节，所以 len() 获取的长度会比其它的大一些。

package mainimport ("bytes""fmt""strings""unicode/utf8"
)func main() {s := "hello,您好"s_length := len(s)fmt.Println(s_length)       // 12fmt.Println(len([]byte(s))) // 12byte_length := f1(s)fmt.Println(byte_length) // 8string_length := f2(s)fmt.Println(string_length) // 8rune_length := f3(s)fmt.Println(rune_length) // 8utf_length := f4(s)fmt.Println(utf_length) // 8
}func f1(s string) int {return bytes.Count([]byte(s), nil) - 1
}func f2(s string) int {return strings.Count(s, "") - 1
}func f3(s string) int {return len([]rune(s))
}func f4(s string) int {return utf8.RuneCountInString(s)
}

6. 字符串和Byte切片

标准库中有四个包对字符串处理尤为重要： bytes 、 strings 、 strconv 和 unicode 包。

• strings 包提供了许多如字符串的查询、替换、比较、截断、拆分和合并等功能。
• bytes 包也提供了很多类似功能的函数，但是针对和字符串有着相同结构的 []byte 类型。因为字符串是只读的，因此逐步构建字符串会导致很多分配和复制。在这种情况下，使用 bytes.Buffer 类型将会更有效。
• strconv 包提供了布尔型、整型数、浮点数和对应字符串的相互转换，还提供了双引号转义相关的转换。
• unicode 包提供了 IsDigit 、 IsLetter 、 IsUpper 和 IsLower 等类似功能，它们用于给字符分类。每个函数有一个单一的 rune 类型的参数，然后返回一个布尔值。而像 ToUpper 和 ToLower 之类的转换函数将用于 rune 字符的大小写转换。所有的这些函数都是遵循 Unicode 标准定义的字母、数字等分类规范。 strings 包也有类似的函数，它们是 ToUpper 和 ToLower ，将原始字符串的每个字符都做相应的转换，然后返回新的字符串。

下面例子的 basename 函数灵感源于 Unix shell 的同名工具。在我们实现的版本中， basename(s) 将看起来像是系统路径的前缀删除，同时将看似文件类型的后缀名部分删除：

fmt.Println(basename("a/b/c.go")) // "c"
fmt.Println(basename("c.d.go"))   // "c.d"
fmt.Println(basename("abc"))      // "abc"

path 和 path/filepath 包提供了关于文件路径名更一般的函数操作。使用斜杠分隔路径可以在任何操作系统上工作。斜杠本身不应该用于文件名，但是在其他一些领域可能会用于文件名，例如 URL 路径组件。

相比之下， path/filepath 包则使用操作系统本身的路径规则，例如 POSIX 系统使用 /foo/bar ，而 Microsoft Windows 使用c:\foo\bar等。

一个字符串是包含只读字节的数组，一旦创建，是不可变的。相比之下，一个字节 slice 的元素则可以自由地修改。
字符串和字节 slice 之间可以相互转换：

s := "abc"
b := []byte(s)
s2 := string(b)

从概念上讲，一个 []byte(s) 转换是分配了一个新的字节数组用于保存字符串数据的拷贝，然后引用这个底层的字节数组。编译器的优化可以避免在一些场景下分配和复制字符串数据，但总的来说需要确保在变量 b 被修改的情况下，原始的 s 字符串也不会改变。将一个字节 slice 转换到字符串的 string(b) 操作则是构造一个字符串拷贝，以确保 s2 字符串是只读的。

为了避免转换中不必要的内存分配， bytes 包和 strings 同时提供了许多实用函数。下面是 strings 包中的六个函数：

func Contains(s, substr string) bool
func Count(s, sep string) int
func Fields(s string) []string
func HasPrefix(s, prefix string) bool
func Index(s, sep string) int
func Join(a []string, sep string) string

bytes 包中也对应的六个函数：

func Contains(b, subslice []byte) bool
func Count(s, sep []byte) int
func Fields(s []byte) [][]byte
func HasPrefix(s, prefix []byte) bool
func Index(s, sep []byte) int
func Join(s [][]byte, sep []byte) []byte

它们之间唯一的区别是字符串类型参数被替换成了字节 slice 类型的参数。

bytes 包还提供了 Buffer 类型用于字节 slice 的缓存。一个 Buffer 开始是空的，但是随着 string 、 byte 或 []byte 等类型数据的写入可以动态增长，一个 bytes.Buffer 变量并不需要初始化，因为零值也是有效的：

// intsToString is like fmt.Sprint(values) but adds commas.
func intsToString(values []int) string {var buf bytes.Bufferbuf.WriteByte('[')for i, v := range values {if i > 0 {buf.WriteString(", ")}fmt.Fprintf(&buf, "%d", v)}buf.WriteByte(']')return buf.String()
}
func main() {fmt.Println(intsToString([]int{1, 2, 3})) // "[1, 2, 3]"
}

当向 bytes.Buffer 添加任意字符的 UTF8 编码时，最好使用 bytes.Buffer 的 WriteRune 方法，但是 WriteByte 方法对于写入类似 '[' 和 ']' 等 ASCII 字符则会更加有效。

7. 字符串和数字的转换

除了字符串、字符、字节之间的转换，字符串和数值之间的转换也比较常见。由 strconv 包提供这类转换功能。
将一个整数转为字符串有两种方法：

• 一种方法是用 fmt.Sprintf 返回一个格式化的字符串；
• 另一个方法是用 strconv.Itoa(“整数到ASCII”) ：

x := 123
y := fmt.Sprintf("%d", x)
fmt.Println(y, strconv.Itoa(x)) // "123 123"

FormatInt 和 FormatUint 函数可以用不同的进制来格式化数字：

fmt.Println(strconv.FormatInt(int64(x), 2)) // "1111011"

fmt.Printf 函数的 %b 、 %d 、 %o 和 %x 等参数提供功能往往比 strconv 包的 Format 函数方便很多，特别是在需要包含有附加额外信息的时候：

s := fmt.Sprintf("x=%b", x) // "x=1111011"

如果要将一个字符串解析为整数，可以使用 strconv 包的 Atoi 或 ParseInt 函数，还有用于解析无符号整数的 ParseUint 函数：

x, err := strconv.Atoi("123")             // x is an int
y, err := strconv.ParseInt("123", 10, 64) // base 10, up to 64 bits

ParseInt 函数的第三个参数是用于指定整型数的大小；例如 16 表示 int16 ，0 则表示 int 。在任何情况下，返回的结果 y 总是 int64 类型，你可以通过强制类型转换将它转为更小的整数类型。

有时候也会使用 fmt.Scanf 来解析输入的字符串和数字，特别是当字符串和数字混合在一行的时候，它可以灵活处理不完整或不规则的输入。

参考：
Go 语言圣经