标签：buffer 区分 计算 iso 两种 数据 相等 i++ import
Go 中使用 UTF-8 对字符进行编码
首先，我们需要对字符编码有一定相关的了解，并明白为什么 Go 选中 UTF-8 作为字符编码方式。
在计算机行业在美国兴起时，人们使用「ASCII」对字符集进行处理：ASCII 使用 7 位 128 个字符（大小写英文字母、数字、标点以及设备控制符）。这对当时的行业来说已经足够使用了，但随着计算机行业的兴起，世界上使用其他语言的人无法在计算机上使用自己的文书体系。
为了解决这个问题，人们开始使用「Unicode」，如今已经定义到了第 8 版，定义了超过一百种语言文字的 12 万个字符的码点。Unicode 需要 32 位比特，也就是 4 个字节，计算机中的int32便很适合保存这种数据类型，Go 中便是这样认为的，因此为int32设置了别名rune。
但如果我们将所有的字符都按照「Unicode」进行编码，这种编码方式称为 UTF-32 或者 UCS-4，每个 Unicode 码点都需要占 4 个字节；但，大多数计算机的可读文本为 ASCII，只需要 1 个字节便可以满足编码要求，而广泛使用的字符也只需要 16 位字符即可，因此这种方式导致了不必要的存储空间消耗。
UTF-8 以字节为单位对 Unicode 码点进行变长编码，是现行的一种 Unicode 标准。它每个符号用 1～4 个字节表示，例如 ASCII 的编码仅需 1 个字节，其他常用的文字编码是 2 或者 3 个字节。
在 UTF-8 中，「首字节的最高位」指明后面还有多少字节：
若最高位为 0，则表示它是 7 位的 ASCII 码，那么它只需要使用一个字节；
若最高几位是 110，那么它占用了两个字节，则文字符号占用 2 个字节进行编码，第二个字节以 10 开始，更长的编码也是以此类推。
因此，对于需要不同空间的字符，UTF-8 的编码方式如下：
0xxxxxxx 文字符号 0 ～ 127 ASCII
110xxxxx 10xxxxxx 128 ~ 2047 少于 128 个未使用的值
1110xxxx 110xxxxx 10xxxxxx 2048 ~ 65535 少于 2048 个未使用的值
11110xxx 1110xxxx 110xxxxx 10xxxxxx 65536 ~ 0x10ffff 其他未使用的值显然，对于 UTF-8，我们不能按下标直接访问第 n 个字符，以此为代价，我们得到了许多方便的特性：
UTF-8 编码紧凑，兼容 ASCII，且自同步：最多追溯 3 字节，就能定位一个字符的起始位置；
UTF-8是前缀编码，故能够从左往右解码而不产生歧义，也无需超前预读；
UTF-8 的编码顺序与字典序一致（Unicode 的码点顺序和字典序一致）；
UTF-8编码本身不会嵌入 NUL 字节（0 值），因此我们可以使用 NUL 标记字符串结尾。
Go 的源文件总是以 UTF-8 进行编码，同时，其操作的文本字符串也是优先使用 UTF-8。
如何表示 UTF-8 字符
Go 中，string 字面量的转义让我们可以使用码点来指明 Unicode 字符。有两种形式：\uhhhh表示 16 位码点，\uhhhhhhhh表示 32 位码点（h 表示一个十六进制的数字），32 位的码点基本用不到。这两种形式都能用 UTF-8 表示给定的码点，因此，下面三个字符串表示的是长度为 6 的相同串：
"世界"
"\xe4\xb8\x96\xe7\x95\x8c"
"\u4e16\u754c"
"\U00004e16\U0000754c"「码点值小于 256 的文字符号」（也就是 ASCII 码）可以写成单个十六进制转义的形式，如将‘A‘写成‘\x41‘；更高的码点必须使用\u或者\U进行转义，这也导致前面的\xe4\xb8\x96不是合法的文字符号。
常用操作
由于 UTF-8 的优良特性，许多字符串操作都无需解码，下面是strings包中一些源码。
可以直接判断某个字符串是否为另一个前缀：
func HasPrefix(s, prefix string) bool {
return len(s) >= len(prefix) && s[:len(prefix)] == prefix
}或者判断是否为另一个字符串的后缀：
func HasSuffix(s, suffix string) bool {
return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
}或者是否为另一个字符串的字串（实际上的实现使用了散列让搜索更高效）：
func Contains(s, substr string) bool {
for i := 0; i < len(s)-len(substr); i++ {
if HasPrefix(s, substr) {
return true
}
}
return false
}处理 Unicode 字符
Go 中的unicode包拥有对单个文字符号的函数（例如区分字母和数字，转换大小写），unicode/utf8包提供了按 UTF-8 编码和解码文字符号的函数。
在实际处理 Unicode 字符时，我们需要注意它实际上的字节数；看下面的例子：
import "unicode/utf8"
s := "世界"
fmt.Println(len(s)) // 输出：6
fmt.Println(utf8.RuneCountInStrings(s)) // 输出：2可以看到，我们需要按做 UTF-8 解读，才能得到符合常规认知的字符长度。
如果我们需要逐个处理这些字符，就需要使用 UTF-8 的解码器，例如unicode/utf8中的：
s := "世界, hello"
for i := 0; i < len(s) {
r, size := utf8.DecodeRuneInString(s[i:])
fmt.Printf("%d\t%c\n", i, r)
i += size
}每次调用DecodeRuneInString的调用都会返回 r（文字符号本身）和一个值 size（表示 r 按照 UTF-8 所占的字节数）。我们用 size 来更新 slice 的下标，这样就能够正确的打印字符：
0 世
3 界
6 ,
7
8 h
9 e
10 l
11 l
12 o幸好 Go 中的「range 循环」也适用于字符串，对 UTF-8 进行隐式解码，所以下述语句也能达到同样的效果：
for i, r := range s {
fmt.Printf("%d\t%q\t%d\n", i, r, r)
}这里的r可以用%q或者%d来表示，前者会打印字符（如世），后者打印对应的 unicode（如19990）。
也因为 range 循环有对 UTF-8 的隐式编码，因此我们可以直接使用它来统计字符串中的文字符号数：
n := 0
for range s {
n++
}Go 语言中 4 个标准包对字符串操作很重要：bytes、strings、strconv 与 unicode
「strings」：提供用于搜索、替换、比较、修整、切分与连接字符串的函数
「bytes」：用于操作字节slice（[]byte 类型的某些属性和字符串相同）。例如可以使用bytes.Buffer高效地按增量方式构建字符串。
「strconv」：主要用于 string 与布尔值、整数、浮点数之间的相互转换，或者是用于为字符串添加/去除引号。
「unicode」：主要用于判别文字符号特性；例如IsDigit、IsLetter、IsUpper和IsLower。这些函数以单个字符作为参数，并返回布尔值。
下面我们用一些例子说明这些包的用法。
下例中，basename 函数模仿 UNIX shell 中的同名实用程序，移除文件的系统路径和可能存在的后缀：
1.首先我们看看不依赖任何库的初版 basename：
/*
basename 移除路径部分以及 .后缀
e.g., a=>a, a.go=>a, a/b/c.go=>c
*/
func basename(s string) string {
for i := len(s) - 1; i >= 0; i-- {
if s[i] == '/' {
s = s[i + 1:]
break
}
}
for i := len(s) - 1; i >= 0; i-- {
if s[i] == '.' {
s = s[:i]
break
}
}
return s
}2.接下来我们使用库函数string.LastIndex来简化代码：
func basename(s string) string {
slash := strings.LastIndex(s, "/") // 如果没找到"\"，slash 的取值为 -1
s = s[slash+1:]
if dot := string.LastIndex(s, "."); dot >= 0 {
s = s[:dot]
}
return s
}这个例子中，我们对子字符串进行操作：接受一个表示整数的字符串，如12345，从右侧开始每隔三个数字就插入一个逗号，形如12,345：
func comma(s string) string {
n := len(3)
if n <= 3 {
return s
}
return comma(s[:n-3]) + "," + s[n-3:]
}在 Go 语言中，字符串可以和字节 slice 相互转换：
s := "abc"
b := []byte(s)
s2 := string(b)正常情况下，这种 string 和 slice 的相互转换都会进行拷贝，这样可以保证即使 b 的字节在转换后发生改变，s 也不会一起变化。
但如果我们不需要这种特性，就会产生不必要的内存消耗，为了避免这种情况，bytes和strings包中都包含了相应的使用函数，它们两两对应。例如，string包中有下面 6 个函数：
func Contains(s, substr string) bool
func Count(s, sep string) bool
func Fields(s string) []string
func HasPrefix(s, prefix string) bool
func Index(s, sep string) int
func Join(a []string, sep string) stringbytes包中的对应函数为：
func Contains(b, subslice []byte) bool
func Count(b, sep []byte) bool
func Fields(b []byte) [][]byte
func HasPrefix(b, prefix []byte) bool
func Index(b, sep []byte) int
func Join(a [][]byte, sep []byte) []byte唯一不同的是，操作对象由字符串变为了 slice
bytes包为高效处理字节 slice 提供了「Buffer」类型。它起始为空，大小随着各种类型数据的写入而增长，如 string、byte 和 []byte。如下例，bytes.Buffer变量无需初始化，因为零值本来就有效：
// intsToString 与 fmt.Sprintf(values) 类似，但插入了逗号
func intsToString(values []int) string {
var buf bytes.Buffer
buf.WriteByte('[')
for i, v := range values {
if i > 0 {
buf.WriteString(", ")
}
fmt.Fprintf(&buf, "%d", v)
}
buf.WriteByte(']')
}
func main() {
fmt.Println(intsToString([]int{1, 2, 3})) // 输出： [1, 2, 3]
}如果要在byte.Buffer变量后添加任意文字符号的 UTF-8 编码，最好使用WriteRune方法，而追加 ASCII 字符，则使用WriteByte即可。
通常，要将整数转换成字符串，一种选择是使用fmt.Sprintf，另一种做法是用函数strconv.Itoa：
x := 123
y := fmt.Sprintf("%d", x)
fmt.Println(y, strconv(x)) // 输出： 123 123而FormatInt和FormatUnit可以按不同的进位制格式化数字：
fmt.Println(strconv.FormatInt(int64(x), 2)) // 输出 x 的二进制表示： 1111011// 1. 自建方法“==”，区分大小写，最简单的方法
fmt.Println("go"=="go") // true
fmt.Println("GO"=="go") // false
// 2. Compare函数，区分大小写，比自建方法“==”的速度要快，下面是注释
// Compare is included only for symmetry with package bytes.
// It is usually clearer and always faster to use the built-in
// string comparison operators ==, <, >, and so on.
// func Compare(a, b string) int
fmt.Println(strings.Compare("GO","go")) // -1 ，也就是 "GO" < "go" （因为是字典序）
fmt.Println(strings.Compare("go","go")) // 0
// 3. 比较UTF-8编码在小写的条件下是否相等，不区分大小写，下面是注释
// EqualFold reports whether s and t, interpreted as UTF-8 strings,
// are equal under Unicode case-folding.
// func EqualFold(s, t string) bool
fmt.Println(strings.EqualFold("GO","go")) // true，因为不区分大小写输出：
true
false
-1
0
true标签：buffer 区分 计算 iso 两种 数据 相等 i++ import
原文地址：https://www.cnblogs.com/Bylight/p/12090480.html
