Golang 02_Golang字符串

一、Golang字符类型及字符编码简介

1.1 Golang字符类型

字符并不是 Go语言的一个类型，只是整数的特殊用例。

在Golang中的字符类型有以下两种：

一种是 uint8 类型，或者叫 byte 型，该类型变量可存放标准 ASCII码 的一个字符；
另一种是 rune 类型，代表一个 UTF-8字符，当需要处理中文、日文或者其它复合字符时，则需要用到 rune 类型。

Tips: rune 类型实际是一个 int32类型。

byte 类型是 uint8 的别名，对于只占用 1 个字节的传统 ASCII编码 的字符来说，使用 byte 完全没有问题。例如：

1

var ch byte = 'A'  // 字符使用单引号括起来

在 ASCII 码表中，字符 M 的值是 77，使用 16 进制表示则为 4d，使用 8 进制表示则为 115，所以下面的写法是等效的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


var ch byte = 'M'

// 或
var ch byte = 77

// 或
var ch byte = '\x4d' // 或者 `\x4D`, \x 总是紧跟着长度为 2 的 16 进制数，x 必须小写, 16进制数里的字母大小写均可

// 或
var ch byte = '\115' // \ 后面紧跟着长度为 3 的 8 进制数

Golang 同时也支持 Unicode编码，因此，在Golang中字符同样称为 Unicode 代码点或者 runes，在内存中实际是使用 int 类型来表示。

中文字符在Unicode下占2个字节，在UTF-8编码下占3个字节。（Golang默认编码是UTF-8）。

在文档中，一般使用格式 U+hhhh 来表示一个字符，其中 h 表示一个 16 进制数[0-9,A-F]。

Tips: rune 也是 Go 当中的一个类型，并且是 int32 的别名。

在书写 Unicode字符时，需要在 16 进制数之前加上前缀 \u 或者 \U。

因为 Unicode 一般至少占用 2 个字节，所以使用 int16 或者 int 类型来表示。如果需要使用到 4 字节，则会加上 \u 前缀；前缀 \u 总是紧跟着长度为 4 的 16 进制数，前缀 \U 紧跟着长度为 8 的 16 进制数。

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


var ch rune = '\u0041'
var ch2 rune = '\u03B2'
var ch3 int = '\U00101234'
fmt.Printf("%d - %d - %d\n", ch, ch2, ch3) // integer
fmt.Printf("%c - %c - %c\n", ch, ch2, ch3) // character
fmt.Printf("%X - %X - %X\n", ch, ch2, ch3) // UTF-8 bytes
fmt.Printf("%U - %U - %U", ch, ch2, ch3) // UTF-8 code point

// 输出：
/*
65 - 946 - 1053236
A - β - r
41 - 3B2 - 101234
U+0041 - U+03B2 - U+101234
*/

格式化说明符:

%c 用于输出字符；当和字符配合使用时，
%v 或 %d 会输出用于表示该字符的整数；
%U 输出格式为 U+hhhh 的字符串；

unicode包包含了一些针对测试字符的非常有用的函数（其中 ch 代表字符）：

判断是否为字母：unicode.IsLetter(ch)
判断是否为数字：unicode.IsDigit(ch)
判断是否为空白符号：unicode.IsSpace(ch)

字符类型使用细节：

字符常量是用单引号(’’)括起来的单个字符例如: var c1 byte = 'a'
GO中允许使用转义字符’\‘来将后面的字符转换为特殊型常量例如：var c3 byte = '\n' \n 表示换行符
Go语言的字符使用UTF-8编码
在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码的值
可以直接给某个变量赋一个数字，然后按 %c 格式化输出时，会输出该数字对应的unicode字符
字符类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码（一个整数数值）

Tips:

UTF-8 是 Unicode 的实现方式之一，UTF-8 最大的一个特点，就是它是一种变长的编码方式，它可以使用 1~4 个字节表示一个符号，根据不同的符号而变化字节长度。

UTF-8编码 字符集完全兼容 标准ASCII码，也就是说 标准ASCII码 是 UTF8编码集的子集。

1.2 计算机字符编码集简介

比特(bit)是计算机处理的最小单位、值为 0 或者 1，一个字节包含8个bit，最大值（11111111）为 255，最小值（00000000）为 0；

一个字节能代表 256（0-255）个数字，二个字节可以表示 65536（0-65535）个数字，更多的字节可以有更多种组合，也就可以表示更大的数值范围，整数可以这样存，那么字符呢？

一堆二进制 0 或者 1，无论怎么也算不出 A，那就通过数字中转一下，只要给 A 指定一个数值编号（字符与编号组成一种映射关系），存储 A 时就存储这个映射的编号值，读取时也是读取到编号数值、再按照这个编号数值与字符的映射关系找到这个字符 A，像这样收录许多字符然后给它们一一编号（建立映字符与编码的映射），就得到一个字符编号对照表，这就是一个 字符集。

知道字符，通过字符集映射就可找到对也得编码，反之，找到字符编号，通过字符集映射也可以找到字符。

常见字符集相关发展过程如下：

ASCII字符集：标准ASSCII字符集只收录了128个字符，其扩展字符集也只有256个；
GB2312字符集：由于ASCII里没有汉字，所以为了存储汉字出现了 GB2312字符集；
BIG5字符集：由于GB2312里没有繁体字，所以出现了BIG5字符集；
Unicode字符集：但是BIG5还有许多字符没有被收录，与其不断的推出收录更多字符的字符集，不如本着全球化统一标准的目的，制作一个通用字符集，Unicode学术学会就是这样做的，这个字符集就是 Unicode；Unicode字符集于1990年开始研发并于1994年正式公布，实现了跨语言跨平台的文本转换与处理。

下图为字符集发展历程：

1.3 计算机字符编码简介

1）定长编码 所谓定长编码就是用固定的长度去存储编译字符，最常见和广泛使用的的定长编码就是 ASCII码。

ASCII码一览表，ASCII码对照表: https://c.biancheng.net/c/ascii/

在ACSII中将一个字符表示成8位特定的二进制数，举例说明如下：

字符	十进制	二进制
A	65	01000001
B	66	01000010
C	67	01000011

定长编码的优点是简单、高效，不需要额外的数据协商和传输开销。但是，它也有一些缺点：

首先，它不够灵活，不能适应变长的数据结构和协议；
其次，它浪费空间，因为某些数据元素可能没有充分利用其分配的固定长度；

例如，ASCII编码是1个字节，而Unicode编码通常是2个字节：

字母 A 用ASCII编码是十进制的 65，二进制的 01000001；
字符 0 用ASCII编码是十进制的 48，二进制的 00110000；
汉字 中 已经超出了ASCII编码的范围，用Unicode编码是十进制的 20013，二进制的 01001110 00101101；

如果把ASCII编码的 A 用Unicode编码，只需要在前面补0就可以，因此，A 的Unicode编码是 00000000 01000001。

2）变长编码及 UTF8编码规则简介 在定长编码下，如果写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算，所以出现了 变长编码。

变长编码（Variable-length encoding） 是指在编码时，不同的符号可能占用不同的比特位数，它的主要特点是可以提高编码效率，因为在实际应用中不同的符号出现频率可能是不同的（小编号少占字节，大编号多占字节）。如果使用固定长度编码，则会浪费很多比特，降低数据传输效率。

在计算机科学中，常见的 变长编码 有 霍夫曼编码、算术编码、游程编码等。在文本编码中广泛使用的 UTF-8 也是一种变长编码。

在 UTF-8 编码中，一个字符所占用的字节数是变化的，可以是 1、2、3 或 4 个字节，具体取决于字符的 Unicode 编码值，UTF-8 是一种非常常用的变长编码方式。

UTF-8编码模版格式如下：

占用字节数	十进制编码范围	模版
1字节	[0, 127]	0xxxxxxx
2字节	[128,2047]	110xxxxx 10xxxxxx
3字节	[2048, 65535]	1110xxxx 10xxxxxx 10xxxxxx
4字节	[65536, 2097151]	11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
5字节	[2097152, 67108863]	111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
6字节	[67108863, 2147483647]	1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx

上述UTF-8字符编码字节模版的使用规则：

对于单字节字符，最高位为 0，后面7位为这个字符的Unicode码；例如：字母 e，属于标准ASCII码，UTF-8编码兼容标准ASCII码，两者在 0-127编码值对应的字符是一致的；字母 e 的编码为101，该编码在 [0，127] 范围内、属于单字节字符，按照UTF-8编码规则对应模版 0xxxxxxx，现将101转为二进制：1100101，则UTF-8编码为：01100101, UNICODE编码为：U+0065，如下图所示：
对于n字节字符（n > 1），第一个字节的前n位均为1，第n+1位为0，后面n-1字节的前两位均为10，剩下的位则为这个字符的Unicode码；例如：汉字 “好” 字的Unicode编码十进制编码为：22909，该编码十进制在 [2048, 65535]范围内，属于3字节长度编码，使用三字节模版 1110xxxx 10xxxxxx 10xxxxxx，将十进制 22909 转为二进制转为二进制 1011001 01111101，最终得到UTF-8编码为：11100101 10100101 10111101，UNICODE编码为：U+597D，如图：

1.4 Golang UTF-8字符的判定

Go语言实现了 UTF-8编码验证算法 用于 检查UTF-8编码数据，主要基于UTF-8的可变长编码特点设计了验证算法，UTF-8编码使用1到4个字节 为每个字符编码，ASCII标准编码部分跟UTF-8编码一致，占用长度为1个字节。

Tips: UTF-8除了开始128个单字节编码与 ASCII标准相同（兼容）以外，其它的使用自己的编码；

在Go中检验字符串是否为符合UTF-8规则的函数为：utf8.ValidString，源码如下：

 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


const (
 RuneSelf  = 0x80 //定义0x80为常量 RuneSelf
)

...

func ValidString(s string) bool {
    // 遍历字符串 s，每次取 8 个字节
    for len(s) >= 8 {
        // 将这 8 个字节转化为两个 uint32 类型的整数，然后判断是否有非 ASCII 字符
        first32 := uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 | uint32(s[3])<<24
        second32 := uint32(s[4]) | uint32(s[5])<<8 | uint32(s[6])<<16 | uint32(s[7])<<24
        if (first32|second32) & 0x80808080 != 0 {
            break
        }
        s = s[8:]
    }

    n := len(s)
    for i := 0; i < n; {
        si := s[i]
        if si < RuneSelf { // 如果值小于 RuneSelf(0x80) 即为标准ASCII编码
            i++
            continue
        }
        x := first[si]
        // 如果该字符的 x 值是 xx，说明该字符不合法，返回 false
        if x == xx {
            return false
        }
        size := int(x & 7)
        if i+size > n {
            return false
        }
        accept := acceptRanges[x>>4]
        // 如果该字符的下一个字符不在该字符的合法范围内，返回 false
        if c := s[i+1]; c < accept.lo || accept.hi < c {
            return false
        } else if size == 2 {
            // 如果该字符长度为 2，直接跳到下一个字符
        } else if c := s[i+2]; c < locb || hicb < c {
            // 如果该字符长度为 3，判断第三个字符是否在合法范围内
            return false
        } else if size == 3 {
            // 如果该字符长度为 4，判断第三个和第四个字符是否在合法范围内
            if c := s[i+3]; c < locb || hicb < c {
                return false
            }
        }
        i += size
    }
    return true
}

函数流程大致为：

遍历字符串 s，每次取 8 个字节编码数据判断其中是否存在非标准ASCII的编码数据。

为什么每次取8个字节呢？为什么不一个一个字节取去判断呢？ 在现实环境中，在校验一篇长篇英文文章的场景下（验证大量标准ASCII编码数据），如果验证算法采用单个字符比较的方式检查编码，直到循环检查完整个数据，算法的运行耗时大，性能有待提升。针对UTF-8编码验证算法中处理标准ASCII编码字符检查次数多、运行耗时大的问题，可以利用并行化编程思想，一次同时处理多个标准ASCII编码字符的检查，减少比较的次数，加快验证速度，提升算法性能。 Go语言的UTF-8验证算法应用了基于并行化编程思想的算法优化方案，一次同时检查8个标准ASCII编码，大大提升了算法的运行性能。

2. 那如何实现一次同时检查8个标准ASCII编码呢？这时候位运算就显示出它的特点来了。 前面讲到，单个标准ASCII编码字符十进制最大的值为127（即0x80），最简单的办法直接比较字符编码的十进制值大小，如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


const (
 RuneSelf  = 0x80 //定义0x80为常量 RuneSelf
)

n := len(s)
for i := 0; i < n; {
 si := s[i]
 if si < RuneSelf { // 如果值小于 RuneSelf(0x80) 即为标准ASCII编码
     i++
 }
}

如果字节的数值小于 0x80（128）即为ASCII编码。

还有一种办法就是利用位运算：

将要比较的字符转为二进制模式，再跟0x80（10000000 ）的二进制进行 & 运算，如果符合ASCII标准，则结果为0，如果结果不是0，则这个字符并不是标准ASCII编码范围内，则进行其它类型检测。

一次如何处理8个字节呢？举个例子说明golang中是怎么处理的。例如：字符串 “ABCDEFGH你好世界”, 要同时检查8个标准ASCII编码，则流程如下：

每次取8个字节数据进行操作，此处首8个字节数据为： ABCDEFGH, ASCII码以及二进制如下：
将取到的8字节数据按每4个字节组成一组组成一个unit32的整数，此处 ABCD组成一个4字节（32bit）二进制数据first32，而EFGH组成另外一个4字节二进制数据second32, 方法如下:

1
2


first32 := A | B << 8 | C << 16 | D << 24
second32 := E | F << 8 | G << 16 | H << 24

将两组4字节的二进制数据进行 | 操作 （first32 |second32 ），并将最终结果中的每个字节数据与 0x80 进行 & 操作，四个字节则与 0x80808080 进行一次 & 运算，如果值为0，则8字节数据全部为标准ASCII编码，否则这些字符中含有其它非标准ASCII编码数据。

1

(first32|second32)&0x80808080

如果该字节数据编码非标准ASCII编码（超出127范围），检查是否符合UTF-8编码的其它码点规则：

UTF-8编码码点判断规则如下：

UTF-8最多可用到6个字节，其有效bit数为31，而一般文字以及符号编码都用到了1-4字节；
0xC0(192), 0xC1(193), 0xF5—0xFF(245-255)不会出现在UTF8编码中；
首字节不会存在 0x80—0xBF(128-191)范围，而次字节范围必须在0x80—0xBF(128-191)范围内；
首字节值为 0xE0（224），次字节取值必须在 0xA0 - 0xBF（160-191）之间；
首字节值为 0xED（237），次字节取值必须在 0x80 - 0x9F（128-159）之间；
首字节值为 0xF0 （240），次字节取值必须在 0x90 - 0xBF（144-191）之间；
首字节值为 0xF4 （244），次字节取值必须在 0x80 - 0x8F（128-143）之间；

根据这些规则，Go语言定义出了次字节取值范围的 acceptRanges 变量以及一些常用的相关变量：

 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


const(
    // UTF-8字符的次字节的一般取值范围,即UTF-8编码模版中[110xxxxx  10xxxxxx]的 10XXXXXX的最大值和最小值
    locb = 0b10000000  // UTF-8字符的次字节最小取值128，十六进制表示为0x80
    hicb = 0b10111111  //UTF-8字符的次字节最大取值191，十六进制表示为0xBF
)

// acceptRange 给出次字节的取值范围
type acceptRange struct {
    lo uint8  // 次字节最小取值
    hi uint8 // 次字节最大取值
}

var acceptRanges = [16]acceptRange{
    //普通字符次字节取值范围[128-191]，范围之外为无效编码(即二进制位不是以 10 开头)
    0: {locb, hicb}, 
    /**
    三字节特殊字符（首字节为 0xE0[ASCII:224]）的次字节
    1:如果次字节低于 0xA0（ASCII:160） 则该字符应该用两个字节表示，而不是三个字节
    2:如果次字节高于 hicb（ASCII:191） 则该字节为无效编码（即二进制位不是以 10 开头）
    */
    1: {0xA0, hicb}, 
    /**
    三字节特殊字符（首字节为 0xED[ASCII:237]）的次字节
    1:如果次字节低于 locb（ASCII:128） 则该字节为无效编码（即二进制位不是以 10 开头）
    2:如果次字节高于 0x9F（ASCII:159） 则该字符为代理区字符（[ED(237) A0(160) 80(128)] - [ED(237) BF(191) BF(191)]）
    */
    2: {locb, 0x9F},
    /**
    四字节特殊字符（首字节为 0xF0[ASCII:240]）的次字节
    1:如果次字节低于 0x90（ASCII:144） 则该字符应该用三个字节表示，而不是四个字节。
    2:如果次字节高于 hicb（ASCII:191） 则该字节为无效编码（即二进制位不是以 10 开头）
    */
    3: {0x90, hicb},
    /**
    四字节特殊字符（首字节为 0xF4[ASCII:244]）的次字节
    1:如果次字节低于 locb（ASCII:128） 则该字节为无效编码（即二进制位不是以 10 开头）
    2:如果次字节高于 0x8F（ASCII:143） 则该字符超出 Unicode 范围（超出 MaxRune）
    */
    4: {locb, 0x8F},
}

除了定义上述变量以外，Go还将编码值为【0-255】范围内的所有首字节编码根据字节长度以及次字节取值范围等信息进行进行分类, 这样可以根据UTF-8首字节就能很快确定该编码的字节长度以及次字节等信息。

首字节编码分为：xx、as、s1、s2、s3、s4、s5、s6、s7 共九类，用十六进制常量的高位和低位分别表示。

高位：“次字节取值范围列表” 的索引，如果高位是 F 则表示字符是单字节字符;
低位：字符的编码长度，如果高位是 F 则低位表示单字节字符的状态：0(有效)、1(无效) 分类代码如下：

 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


const(
    xx = 0xF1  // 无索引，长度1，表示无效 UTF-8编码
    as = 0xF0  // 无索引，长度1，表示普通标准ASCII字符(ASCII编码 0-127范围内)
    s1 = 0x02  // 索引值0，长度2， 表示普通 "双字节字符"的首字节
    s2 = 0x13  // 索引值1，长度3， 表示特殊 "三字节字符"的首字节
    s3 = 0x03  // 索引值0，长度3， 表示普通 "三字节字符"的首字节
    s4 = 0x23  // 索引值2，长度3， 表示特殊 "三字节字符"的首字节
    s5 = 0x34  // 索引值3，长度4， 表示特殊 "四字节字符"的首字节
    s6 = 0x04  // 索引值0，长度4， 表示普通 "四字节字符"的首字节
    s7 = 0x44  // 索引值4，长度4， 表示特殊 "四字节字符"的首字节
)

var first = [256]uint8{
    //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
    as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x00-0x0F
    as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x10-0x1F
    as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x20-0x2F
    as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x30-0x3F
    as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x40-0x4F
    as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x50-0x5F
    as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x60-0x6F
    as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x70-0x7F
    //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x80-0x8F
    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x90-0x9F
    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xA0-0xAF
    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xB0-0xBF
    xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xC0-0xCF
    s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xD0-0xDF
    s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3, // 0xE0-0xEF
    s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xF0-0xFF
}

除了 utf8.ValidString 函数外，其实 utf8.Valid函数判断也类似。

二、Golang字符串（string）类型

2.1 Golang中的字符串简介

在Golang中，字符串是一种基本数据类型，它由一串Unicode字符（UTF-8）组成。

Golang中 string的底层是通过byte数组实现的（所以获取字符串长度是按照字节来的）。

中文字符在unicode下占2个字节，在utf-8编码下占3个字节（golang默认编码是UTF-8）。

字符串定义：

1

var str string

string 类型的零值为长度为零的字符串，即空字符串 “"。

Golang中的字符串值是不可变的，也就是说，一旦创建了一个此类型的值，就不可能再对它本身做任何修改。

Golang 中 字符串（string） 是 UTF-8 字符的一个序列（当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节），每个中文汉字占用三个字节。

字符串有两种表示方式：双引号（""） 和 反引号（``），反引号也叫原意符号，反引号表示的字符串叫原意字符串。

双引号用于创建普通字符串，而反引号用于创建原始字符串（它们可以包含特殊字符和换行符等）。

如下代码:

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


package main

import "fmt"

func main() {
    var str1 = "hello world"  // 双引号用于创建普通字符串
    var str2 = `
    窗前明月光
    疑是地上霜
    举头望明月
    低头思故乡
    ` // 反引号用于创建原始字符串，这其中包含了换行符

    fmt.Println("str1 = ", str1)
    fmt.Println("str2 = ", str2)
}

Tips: 反引号 定义的字符，会以字符串的原生形式输出，包括换行符和特殊字符，可以防止攻击、输出源代码等效果。

Golang中一个字符串类型的值可以代表一个字符序列，这些字符必须是被Unicode编码规范支持的。

虽然从表象上来说是字符序列，但是在底层，一个字符串值却是由若干个字节来表现和存储的。

一个字符串（也可以说字符序列）会被Go语言用Unicode编码规范中的UTF-8编码格式编码为字节数组。

一个字符串值或者一个字符串类型的变量之上应用Go语言的内置函数 len() 函数将会得到存储它的那个字节数组的长度。

len("hello 世界") 获得的是 hello 世界 占用的内存空间为 12（字节）。

计算字符串的长度（字符个数）：

ASCII 字符串长度使用内置 len() 函数获取，此时字符串占用的字节数和字符数相同；
Unicode 字符串长度使用 utf8.RuneCountInString() 函数或使用 []rune 对其进行强制转换后再使用 len()函数获取；

for 索引 / for range 遍历字符串：

ASCII 字符串遍历直接使用下标索引或 for range 均可；
Unicode 字符串遍历用 for range 或使用 []rune 对其进行强制转换后再使用 for 索引；

处理有中文（Unicode编码）的问题([]rune)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


str := "hello呗"  
str2 := []rune(str)   // rune会将str的字符串中的中文进行处理为1个占3个字节的 utf8编码字符
                      // 如果不处理，那么循环拿到的就是3个占1字节的乱码

for i :=0; i < len(str2); i++ {
    fmt.Printf("idx=%v, char=%c/%v\n", i, str2[i], str2[i])
}

for idx, ch := range str {
    fmt.Printf("idx=%v, char=%c/%v\n", idx, ch, ch)
}

字符串转 byte 与 byte 转字符串

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


package main
 
import (
    "fmt"
)
 
func main()  {
    var bytes = []byte("hello go")  // byte中存放的是 ASCLL码 值
    fmt.Printf("bytes=%v\n",bytes)  // bytes=[104 101 108 108 111 32 103 111]

    str := string([]byte{97,98,99}) // 这里将ASCLL码转换成对应的一个字符 abc
    fmt.Printf("bytes=%v\n",str)    // bytes=abc
}

字符串转二进制[]byte: var bytes = []byte("hello go)，强制转换为切片，用于将字符串写入二进制文件

2.2 Golang中string底层原理

当查看string类型的变量所占的空间大小时，会发现是16字节（64位机器）。

1
2
3
4
5


str := "hello"
fmt.Println(unsafe.Sizeof(str)) // 16

str = "hellohellohellohellohellohellohello"
fmt.Println(unsafe.Sizeof(str)) // 16

字符串（string） 是 Go 语言提供的一种基础数据类型，它是一个不可变的字符序列。

实际上，string 是一个结构体，在Golang 1.17及之前版本中定义的字符串底层结构为：

1
2
3
4
5
6


// file: /runtime/string.go

type stringStruct struct {
    str unsafe.Pointer  // 指向字符串地址的指针
    len int             // 记录字符串的长度
}

在 Golang 1.18 中引入的字符串底层数据结构，与 stringStruct 基本相同，但是将指向字符串数据的指针类型从 unsafe.Pointer 改为了 uintptr，使得更方便地在不同平台上进行字符串内存地址的转换，定义为：

1
2
3
4
5


// file: /reflect/value.go
type StringHeader struct {
    Data uintptr    // 指向字符串地址的指针
    Len  int        // 记录字符串的长度
}

Data：是一个指针，指向存储实际字符串的内存地址，该内存地址存储的值是一个[]byte类型切片，指针在64位机器下占8个字节；
Len: 字符串的长度，64位机器下int占8个字节。与切片类似，在代码中可以使用len()函数获取这个值。注意，len存储实际的字节数，而非字符数，对于非单字节编码的字符，结果可能让人疑惑。

需要注意的是，stringStruct 和 StringHeader 虽然定义方式不同，但它们所表示的字符串底层结构是等价的。

在 Go 1.18 之前的版本中，可以通过 (*stringStruct)(unsafe.Pointer(&str)) 将字符串转换为 stringStruct，然后进行底层操作；
在 Go 1.18 及之后版本中，可以通过 (*StringHeader)(unsafe.Pointer(&str)) 将字符串转换为 StringHeader，然后进行底层操作；

示例：

1
2
3
4
5
6
7
8


package main

import "fmt"

func main() {
    s := "hello"
    fmt.Println(s)
}

执行 go build -gcflags=-S main.go 查看 hello 字符串底层结构的内存存储的信息为：

1
2
3
4
5


go build -gcflags=-S main.go
......
go:string."hello" SRODATA dupok size=5
        0x0000 68 65 6c 6c 6f       hello
......

从上述编译信息可以看出:

存储字符串的实际上是一片连续的内存空间；
如上信息 go:string."hello" SRODATA dupok size=5，SRODATA 标识代表只读，意味着字符串会分配到只读的内存空间，是一个不可改变的字节序列，不可修改；
由于只读的特性，相同字符串都被存储为同一个地址上，可以得出相同字符串面值常量通常对应同一个字符串常量；

2.3 字符串部分函数

1）不区分大小写的字符串比较函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main
 
import (
    "fmt"
    "strings"
)
 
func main() {
    b := strings.EqualFold("abc", "ABC")
    fmt.Printf("b=%v\n", b) // b=true
}

使用了不区分大小写的EqualFold 函数比较字符串是否相同。

2）将字符串的字母进行大小写的转换的函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main
 
import (
    "fmt"
    "strings"
)
 
func main()  {
    str := "goLang Hello"
 
    // 转换为全小写
    str2 := strings.ToLower(str) 
    fmt.Printf("index=%v\n",str2) // index=golang hello
 
    // 转换为全大写
    str3 := strings.ToUpper(str)
    fmt.Printf("index=%v\n",str3)  // index=GOLANG HELLO
}

3）按照指定的某个字符为分割标识，将一个字符串拆分成数组

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


package main
 
import (
    "fmt"
    "strings"
)
 
func main()  {
 
    strArr := strings.Split("hello,wrold,ok", ",") // 以逗号拆分字符串赋值到strArr数组
 
    fmt.Printf("index=%v\n",strArr) // index=[hello wrold ok]
}

4）将指定的子串替换成另一个字符串

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


package main
 
import (
    "fmt"
    "strings"
)
 
func main()  {
    str2 := strings.Replace("go go hello", "go", "北京",1)   
    //替换第一个的话, 结尾的值设置为1，替换两个输入2，-1全部替换
 
    fmt.Printf("index=%v\n",str2) // index=北京 go hello
}

5）将字符串左右的空格去掉

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main
 
import (
    "fmt"
    "strings"
)
 
func main()  {
    str := strings.TrimSpace(" tn a lone gopher ntrn  ")
    fmt.Printf("str=%v\n",str) // str=tn a lone gopher ntrn
}

6）将字符串两边指定的字符串去掉

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main
 
import (
    "fmt"
    "strings"
)
 
func main()  {
    str1 := strings.Trim("! hello !", " !")  //字符串  "! hello !"
                                          //我想将第一个字符串左右两边的空格和感叹号都去掉
                                          //那么在第二个位置就填写空格和感叹号
 
    fmt.Printf("str=%v\n",str1) // str=hello

    str2 := strings.TrimLeft("! hello !", " !")  
                                         //strings.TrimLeft 将左边的值去除
    fmt.Printf("str=%v\n",str2)  // str=hello !
 
 
 
    str3 := strings.TrimRight("! hello !", " !") 
                                         //strings.TrimRight 将右边的值去除
    fmt.Printf("str=%v\n",str3) // str=! hello
}

7）判断字符串是否以指定的字符串开头

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


package main
 
import (
    "fmt"
    "strings"
)
 
func main()  {
    str := strings.HasPrefix("ftp://192.168.10.1","ftp")
 
    fmt.Printf("str=%v\n",str) // str=true
}

8）判断字符串是否以指定的字符串结束

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


package main
 
import (
    "fmt"
    "strings"
 
)
 
func main()  {
    str := strings.HasSuffix("NLT_abc.jpg","abc")
 
    fmt.Printf("str=%v\n",str) // str=false
}

9）将指定的子串替换成另一个字符串

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


package main
 
import (
    "fmt"
    "strings"
)
 
func main()  {
    str2 := strings.Replace("go go hello", "go", "北京",1)   
    //替换第一个的话, 结尾的值设置为1，替换两个输入2，-1全部替换
 
    fmt.Printf("index=%v\n",str2) // index=北京 go hello
}