Go语言---unicode/utf8 unicode/utf16包

unicode/utf8

包utf8实现了函数和常量来支持UTF-8编码的文本。它包括在runes和UTF-8字节序列之间转换的函数。

utf8里面的函数就有一些字节和字符的转换。

//判断是否符合UTF编码的函数
// Valid 判断 p 是否为完整有效的 UTF8 编码序列。
func Valid(p []byte) bool
// ValidRune 判断 r 能否被正确的转换为 UTF8 编码
// 超出 Unicode 范围的码点或 UTF-16 代理区中的码点是不能转换的
func ValidRune(r rune) bool
// 参数是字符串
func ValidString(s string) bool

unicode字符编码范围：

unicode 字节位表
unicode 编码范围 十进制／十六进制
UTF-8 字节模板二进制／十六进制
字节数

一字节
(0)000000 – (127)00007F 
0xxxxxxx(00-7F)

两个字节
(128)000080 – (2047)0007FF 
110xxxxx(C2-DF)      10xxxxxx

三个字节
(2048)000800 – (55295)00D7FF (57344)00E000 – (65535)00FFFF 
1110xxxx(E0-EF)     10xxxxxx     10xxxxxx

四个字节
(65536)010000 – (1114111)10FFFF 
11110xxx(F0-F4) 10xxxxxx 10xxxxxx 10xxxxxx

程序示例：

//由 main 函数作为程序入口点启动
func main(){
	valid1 := []byte("Hello, 世界")
	invalid1 := []byte{0xff, 0xfe, 0xfd}

	fmt.Println(utf8.Valid(valid1))        // true
	fmt.Println(utf8.Valid(invalid1))      // false

	valid2 := 'a'
	invalid2 := rune(0xfffffff)

	fmt.Println(utf8.ValidRune(valid2))    // true
	fmt.Println(utf8.ValidRune(invalid2))  // false

	valid3 := "Hello, 世界"
	invalid3 := string([]byte{0xff, 0xfe, 0xfd})

	fmt.Println(utf8.ValidString(valid3))   // true
	fmt.Println(utf8.ValidString(invalid3)) // false

	b := []byte("你好")
	fmt.Printf("%t, ", utf8.Valid(b))     // true
	fmt.Printf("%t, ", utf8.Valid(b[1:])) // false
	fmt.Printf("%t, ", utf8.Valid(b[2:])) // false
	fmt.Printf("%t, ", utf8.Valid(b[:2])) // false
	fmt.Printf("%t, ", utf8.Valid(b[:1])) // false
	fmt.Printf("%t\n", utf8.Valid(b[3:])) // true

	fmt.Printf("%t, ", utf8.ValidRune('好'))        // true
	fmt.Printf("%t, ", utf8.ValidRune(0))          // true
	fmt.Printf("%t, ", utf8.ValidRune(0xD800))     // false  代理区字符
	fmt.Printf("%t\n", utf8.ValidRune(0x10FFFFFF)) // false  超出范围
}

// FullRune 检测 p 中第一个字符的 UTF-8 编码是否完整（完整并不表示有效）。
// 一个无效的编码也被认为是完整字符，因为它将被转换为一个 RuneError 字符。
// 只有“编码有效但长度不够”的字符才被认为是不完整字符。
// 也就是说，只有截去一个有效字符的一个或多个尾部字节，该字符才算是不完整字符。
// 举例：
// "好"     是完整字符
// "好"[1:] 是完整字符（首字节无效，可转换为 RuneError 字符）
// "好"[2:] 是完整字符（首字节无效，可转换为 RuneError 字符）
// "好"[:2] 是不完整字符（编码有效但长度不够）
// "好"[:1] 是不完整字符（编码有效但长度不够）
func FullRune(p []byte) bool

// 功能同上，参数为字符串
func FullRuneInString(s string) bool

// 返回 p 中的字符个数
// 错误的 UTF8 编码和长度不足的 UTF8 编码将被当作单字节的 RuneError 处理
func RuneCount(p []byte) int

// 功能同上，参数为字符串
func RuneCountInString(s string) (n int)

// RuneLen 返回需要多少字节来编码字符 r，如果 r 是无效的字符，则返回 -1
func RuneLen(r rune) int

// 判断 b 是否为 UTF8 字符的首字节编码，最高位(bit)是不是 10 的字节就是首字节。
func RuneStart(b byte) bool

程序示例：

func main(){
	b := []byte("好")
	fmt.Printf("%t, ", utf8.FullRune(b))     // true
	fmt.Printf("%t, ", utf8.FullRune(b[1:])) // true
	fmt.Printf("%t, ", utf8.FullRune(b[2:])) // true
	fmt.Printf("%t, ", utf8.FullRune(b[:2])) // false
	fmt.Printf("%t\n", utf8.FullRune(b[:1])) // false

	str := "世"
	fmt.Println(utf8.FullRuneInString(str))     //true
	fmt.Println(utf8.FullRuneInString(str[:2])) //false

	b = []byte("大家好")
	fmt.Println(utf8.RuneCount(b)) // 3

	fmt.Printf("%d, ", utf8.RuneLen('A'))          // 1
	fmt.Printf("%d, ", utf8.RuneLen('\u03A6'))     // 2
	fmt.Printf("%d, ", utf8.RuneLen('好'))          // 3
	fmt.Printf("%d, ", utf8.RuneLen('\U0010FFFF')) // 4
	fmt.Printf("%d\n", utf8.RuneLen(0x1FFFFFFF))   // -1

	fmt.Printf("%t, ", utf8.RuneStart("好"[0])) // true
	fmt.Printf("%t, ", utf8.RuneStart("好"[1])) // false
	fmt.Printf("%t\n", utf8.RuneStart("好"[2])) // false
}

程序示例：

//由 main 函数作为程序入口点启动
func main(){
	r := '世'
	buf := make([]byte, 3)
	n := utf8.EncodeRune(buf, r)
	fmt.Println(buf)
	fmt.Println(n)

	b := []byte("Hello, 世界")
	for len(b) > 0 {
		r, size := utf8.DecodeRune(b)    //解码 p 中的第一个字符，返回解码后的字符和 p 中被解码的字节数
		fmt.Printf("%c %v\n", r, size)

		b = b[size:]
	}

	str := "Hello, 世界"

	for len(str) > 0 {
		r, size := utf8.DecodeRuneInString(str)
		fmt.Printf("%c %v\n", r, size)

		str = str[size:]
	}

	b := []byte("Hello, 世界")
	for len(b) > 0 {
		r, size := utf8.DecodeLastRune(b)
		fmt.Printf("%c %v\n", r, size)

		b = b[:len(b)-size]
	}
}

unicode/utf16

// IsSurrogate 判断 r 是否为代理区字符
// 两个代理区字符可以用来组合成一个 utf16 编码
func IsSurrogate(r rune) bool

// EncodeRune 将字符 r 编码成 UTF-16 代理对
// r：要编码的字符
// 如果 r < 0x10000 ，则无需编码，其 UTF-16 序列就是其自身
// r1：编码后的 UTF-16 代理对的高位码元
// r2：编码后的 UTF-16 代理对的低位码元
// 如果 r 不是有效的 Unicode 字符，或者是代理区字符，或者无需编码
// 则返回 U+FFFD, U+FFFD
func EncodeRune(r rune) (r1, r2 rune)

// DecodeRune 将 UTF-16 代理对解码成一个 Unicode 字符
// r1：是 UTF-16 代理对的高位码元
// r2：是 UTF-16 代理对的低位码元
// 返回值为解码后的 Unicode 字符
// 如果 r1 或 r2 不是有效的 UTF-16 代理区字符，则返回 U+FFFD
func DecodeRune(r1, r2 rune) rune

// Decode 将 UTF-16 序列 s 解码成 Unicode 字符序列并返回
func Decode(s []uint16) []rune

// Encode 将 s 编码成 UTF-16 序列并返回
func Encode(s []rune) []uint16

相对来说，utf-16编码格式使用较少。

参考博客：http://www.cnblogs.com/golove/p/3272007.html

                https://golang.org/pkg/unicode/utf16/#IsSurrogate   官网资料