简介
包utf-8
实现了功能和常量用于支持文本utf8编码,它包含runes和utf8字节序列的转换功能.
在unicode中,一个中文占两个字节,utf-8中一个中文占三个字节,golang默认的编码是utf-8编码,因此默认一个中文占三个字节,但是golang中的字符串底层实际上是一个byte数组.
耐心看完这篇文章,不信你不懂如何使用
常量定义
- RuneSelf=
0x80
:该值的字节码值为128,在判断是否是常规的ascii码是使用。hicb(0xBF
)字节码值为191.FF
的对应的字节码为255。
// The conditions RuneError==unicode.ReplacementChar and
// MaxRune==unicode.MaxRune are verified in the tests.
// Defining them locally avoids this package depending on package unicode.
// Numbers fundamental to the encoding.
const (
RuneError = '\uFFFD' // the "error" Rune or "Unicode replacement character"
RuneSelf = 0x80 // 字符在Runeself以下的代表他们自身,使用单字节形式
MaxRune = '\U0010FFFF' // 最大的有效Unicode码点
UTFMax = 4 // UTF-8编码的Unicode字符的最大字节数。
)
// Code points in the surrogate range are not valid for UTF-8.
const (
surrogateMin = 0xD800
surrogateMax = 0xDFFF
)
const (
t1 = 0x00 // 0000 0000
tx = 0x80 // 1000 0000
t2 = 0xC0 // 1100 0000
t3 = 0xE0 // 1110 0000
t4 = 0xF0 // 1111 0000
t5 = 0xF8 // 1111 1000
maskx = 0x3F // 0011 1111
mask2 = 0x1F // 0001 1111
mask3 = 0x0F // 0000 1111
mask4 = 0x07 // 0000 0111
rune1Max = 1<<7 - 1
rune2Max = 1<<11 - 1
rune3Max = 1<<16 - 1
// 默认的最低和最高连续字节。
locb = 0x80 // 1000 0000
hicb = 0xBF // 1011 1111
// 选择这些常量的名称是为了在下表中保持良好的对齐。
// 第一个半字节是特殊的单字节情况下acceptRanges或F的索引。
// 第二个半字节是符文长度或特殊一字节大小写的状态。
xx = 0xF1 // invalid: size 1
as = 0xF0 // ASCII: size 1
s1 = 0x02 // accept 0, size 2
s2 = 0x13 // accept 1, size 3
s3 = 0x03 // accept 0, size 3
s4 = 0x23 // accept 2, size 3
s5 = 0x34 // accept 3, size 4
s6 = 0x04 // accept 0, size 4
s7 = 0x44 // accept 4, size 4
)
// first 是有关UTF-8序列中第一个字节的信息。
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
}
// acceptRange给出了一个utf8序列中第二个字节的有效范围
type acceptRange struct {
lo uint8 // lowest value for second byte.
hi uint8 // highest value for second byte.
}
// acceptRanges用来判断第二个字节的有效范围,具体用法看看下面的具体函数介绍
var acceptRanges = [...]acceptRange{
0: {locb, hicb},
1: {0xA0, hicb},
2: {locb, 0x9F},
3: {0x90, hicb},
4: {locb, 0x8F},
}
DecodeRune
DecodeRune解压缩p中的第一个UTF-8编码,并返回rune值和其宽度(以字节为单位)。如果p为空,它返回(RuneError, 0)。 否则,如果编码无效,则返回(RuneError, 1)。对于正确的、非空的UTF-8,两者都是不可能的结果。如果不是一个有效的utf-8,编码超出范围的rune,或者该值不是最短的UTF-8编码则编码无效。不执行其他任何验证。
func DecodeRune(p []byte) (r rune, size int) {
n := len(p)
if n < 1 {
return RuneError, 0
}
p0 := p[0]
x := first[p0]
if x >= as {
// 以下代码模拟附加检查x==xx并处理ASCII和无效的情况,这种mask-and-or方法防止了额外的分支。
mask := rune(x) << 31 >> 31 // Create 0x0000 or 0xFFFF.
return rune(p[0])&^mask | RuneError&mask, 1
}
sz := x & 7 // 获取字长
accept := acceptRanges[x>>4] // x>>4获取acceptRanges数组的索引,具体可以看看xx,as等常量的定义、accept用来判断后续的第二个字节有效范围
if n < int(sz) {
return RuneError, 1
}
b1 := p[1]
if b1 < accept.lo || accept.hi < b1 { // 如果字节数组中第二个元素的值不在accept有效的范围则是非法的
return RuneError, 1
}
if sz == 2 { // 我们来看看是如果获取rune值的,第一个元素和mask2与操作左移6位,第二个元素和maskx与操作,然后或操作
return rune(p0&mask2)<<6 | rune(b1&maskx), 2
}
b2 := p[2]
if b2 < locb || hicb < b2 {
return RuneError, 1
}
if sz == 3 {
return rune(p0&mask3)<<12 | rune(b1&maskx)<<6 | rune(b2&maskx), 3
}
b3 := p[3]
if b3 < locb || hicb < b3 {
return RuneError, 1
}
return rune(p0&mask4)<<18 | rune(b1&maskx)<<12 | rune(b2&maskx)<<6 | rune(b3&maskx), 4
}
示例: 在把字节切片转化为rune切片时,我们可以依次处理字节数组
func str2runes(s []byte) []rune {
var p []int32
for len(s) > 0 {
fmt.Println(s)
r, size := utf8.DecodeRune(s)
fmt.Println(r,size)
p = append(p, int32(r))
s = s[size:]
}
return []rune(p)
}
但是因为底层数据结构的不同,这种形式的转换必然导致内存的重分配
DecodeRuneInString
和DecodeRune一样,只不过,参数是字符串。
EncodeRune
EncodeRune将rune的UTF-8编码写入p(必须足够大)。它返回写入的字节数。
func EncodeRune(p []byte, r rune) int {
// Negative values are erroneous. Making it unsigned addresses the problem.
switch i := uint32(r); {
case i <= rune1Max: // rune1Max = 111 1111(127)
p[0] = byte(r)
return 1
case i <= rune2Max: // rune2Max = 10000000000 (1024)
_ = p[1] // eliminate bounds checks
p[0] = t2 | byte(r>>6) // t2= 0xC0
p[1] = tx | byte(r)&maskx // tx= 0x80
return 2
case i > MaxRune, surrogateMin <= i && i <= surrogateMax:
r = RuneError
fallthrough
case i <= rune3Max: // rune3Max = 1000000000000000 (32768)
_ = p[2] // eliminate bounds checks
p[0] = t3 | byte(r>>12) // t3 = 0xE0
p[1] = tx | byte(r>>6)&maskx
p[2] = tx | byte(r)&maskx
return 3
default:
_ = p[3] // eliminate bounds checks
p[0] = t4 | byte(r>>18)
p[1] = tx | byte(r>>12)&maskx
p[2] = tx | byte(r>>6)&maskx
p[3] = tx | byte(r)&maskx
return 4
}
}
RuneCountInString
计算字符串中的rune数量
原理:首先取出字符串的码值,然后判断是不是个小于128的,如果是小于则直接continue.rune个数++.
如果是个十六进制f1.的则是无效字符,直接continue.rune个数++,也就是说一个无效的字符也当成一个字长为1的rune.
如果字符的码值在first列表中的值和7按位与的结果为其字长,原理如下:
比如上面示例中的钢
。len("钢")函数的返回值为3.s[0]
的结果为233
也就是说明first
数组中,索引为233的值为x=s3(0x03
),0x03
与7按位与后的值为3.
从这个结果值可以看出来,本字符的字长为3。
x 右移4位后的值作为索引,从acceptRanges数组中取出的值为{locb, hicb}。也就是{0x80
,0xbf
}。
继续取后续的字节码值,c = s[1]
的值为146. accept.lo为128,accept.hi为191
不满足
if c := s[i+1]; c < accept.lo || accept.hi < c {
size = 1
}
继续判断c=s[2]
的值为162,也不满足
} else if c := s[i+2]; c < locb || hicb < c {
size = 1
}
满足size==3就能判断其需要跳过的字节,直接i+=size
其他函数的处理流程差不多,不再过多叙述。
// RuneCountInString is like RuneCount but its input is a string.
func RuneCountInString(s string) (n int) {
ns := len(s)
fmt.Println(ns)
for i := 0; i < ns; n++ {
c := s[i]
if c < RuneSelf {
// ASCII fast path
i++
continue
}
fmt.Println("c=", c)
x := first[c]
fmt.Println("x=", x)
if x == xx {
i++ // invalid.
continue
}
size := int(x & 7)
fmt.Println("size=", size)
if i+size > ns {
i++ // Short or invalid.
continue
}
accept := acceptRanges[x>>4]
fmt.Println("accept: ", accept)
if c := s[i+1]; c < accept.lo || accept.hi < c {
size = 1
} else if size == 2 {
} else if c := s[i+2]; c < locb || hicb < c {
size = 1
} else if size == 3 {
} else if c := s[i+3]; c < locb || hicb < c {
size = 1
}
i += size
}
return n
}
示例:
package main
import (
"fmt"
"unicode/utf8"
)
func main(){
str := "Hello, 钢铁侠"
fmt.Println(utf8.RuneCountInString(str)) // 10
}
ValidString
ValidString返回值表明参数字符串是否是一个合法的可utf8编码的字符串。
// ValidString reports whether s consists entirely of valid UTF-8-encoded runes.
func ValidString(s string) bool {
n := len(s)
for i := 0; i < n; {
si := s[i]
if si < RuneSelf {
i++
continue
}
x := first[si]
if x == xx {
return false // Illegal starter byte.
}
size := int(x & 7)
if i+size > n {
return false // Short or invalid.
}
accept := acceptRanges[x>>4]
if c := s[i+1]; c < accept.lo || accept.hi < c {
return false
} else if size == 2 {
} else if c := s[i+2]; c < locb || hicb < c {
return false
} else if size == 3 {
} else if c := s[i+3]; c < locb || hicb < c {
return false
}
i += size
}
return true
}
RuneCount
RuneCount返回参数中包含的rune数量,第一个例子中将utf8.RuneCountInString
,改成该方法调用,返回的结果相同。错误的和短的被当成一个长一字节的rune.单个字符H
就表示一个长度为1字节的rune.
// RuneCount returns the number of runes in p. Erroneous and short
// encodings are treated as single runes of width 1 byte.
func RuneCount(p []byte) int {
np := len(p)
var n int
for i := 0; i < np; {
n++
c := p[i]
if c < RuneSelf {
// ASCII fast path
i++
continue
}
x := first[c]
if x == xx {
i++ // invalid.
continue
}
size := int(x & 7)
if i+size > np {
i++ // Short or invalid.
continue
}
accept := acceptRanges[x>>4]
if c := p[i+1]; c < accept.lo || accept.hi < c {
size = 1
} else if size == 2 {
} else if c := p[i+2]; c < locb || hicb < c {
size = 1
} else if size == 3 {
} else if c := p[i+3]; c < locb || hicb < c {
size = 1
}
i += size
}
return n
}
FullRune
该函数标识参数是否以一个可编码的rune开头,如果字符串是以一个ascii码值在0-127内的字符开头,在执行
first[p[0]]
时,在first列表中,127之前的值都相同都为0xF0
,十进制标识为240,与7按位与后值为0,所以,直接返回true
.
有种特殊的情况,如果是一个无效的编码也被视为一个full Rune,因为它会转换为一个字节的错误rune.
func FullRune(p []byte) bool {
n := len(p)
if n == 0 {
return false
}
x := first[p[0]]
if n >= int(x&7) {
return true // ASCII, invalid or valid.
}
// Must be short or invalid.
accept := acceptRanges[x>>4]
if n > 1 && (p[1] < accept.lo || accept.hi < p[1]) {
return true
} else if n > 2 && (p[2] < locb || hicb < p[2]) {
return true
}
return false
}
FullRuneInString
和FullRune类似,只是参数为字符串形式
// FullRuneInString is like FullRune but its input is a string.
func FullRuneInString(s string) bool {
n := len(s)
if n == 0 {
return false
}
x := first[s[0]]
if n >= int(x&7) {
fmt.Println("--------")
return true // ASCII, invalid, or valid.
}
// Must be short or invalid.
accept := acceptRanges[x>>4]
if n > 1 && (s[1] < accept.lo || accept.hi < s[1]) {
fmt.Println("xxxxxx")
return true
} else if n > 2 && (s[2] < locb || hicb < s[2]) {
fmt.Println("eeeee")
return true
}
return false
}
一个全面的示例:
package main
import (
"fmt"
"reflect"
"unicode/utf8"
)
// Numbers fundamental to the encoding.
const (
RuneError = '\uFFFD' // the "error" Rune or "Unicode replacement character"
RuneSelf = 0x80 // characters below Runeself are represented as themselves in a single byte.
MaxRune = '\U0010FFFF' // Maximum valid Unicode code point.
UTFMax = 4 // maximum number of bytes of a UTF-8 encoded Unicode character.
)
const (
t1 = 0x00 // 0000 0000
tx = 0x80 // 1000 0000
t2 = 0xC0 // 1100 0000
t3 = 0xE0 // 1110 0000
t4 = 0xF0 // 1111 0000
t5 = 0xF8 // 1111 1000
maskx = 0x3F // 0011 1111
mask2 = 0x1F // 0001 1111
mask3 = 0x0F // 0000 1111
mask4 = 0x07 // 0000 0111
rune1Max = 1<<7 - 1
rune2Max = 1<<11 - 1
rune3Max = 1<<16 - 1
// The default lowest and highest continuation byte.
locb = 0x80 // 1000 0000
hicb = 0xBF // 1011 1111
// These names of these constants are chosen to give nice alignment in the
// table below. The first nibble is an index into acceptRanges or F for
// special one-byte cases. The second nibble is the Rune length or the
// Status for the special one-byte case.
xx = 0xF1 // invalid: size 1
as = 0xF0 // ASCII: size 1
s1 = 0x02 // accept 0, size 2
s2 = 0x13 // accept 1, size 3
s3 = 0x03 // accept 0, size 3
s4 = 0x23 // accept 2, size 3
s5 = 0x34 // accept 3, size 4
s6 = 0x04 // accept 0, size 4
s7 = 0x44 // accept 4, size 4
)
type acceptRange struct {
lo uint8 // lowest value for second byte.
hi uint8 // highest value for second byte.
}
var acceptRanges = [...]acceptRange{
0: {locb, hicb},
1: {0xA0, hicb},
2: {locb, 0x9F},
3: {0x90, hicb},
4: {locb, 0x8F},
}
// first is information about the first byte in a UTF-8 sequence.
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
}
// RuneCountInString is like RuneCount but its input is a string.
func RuneCountInString(s string) (n int) {
ns := len(s)
fmt.Println(ns)
for i := 0; i < ns; n++ {
c := s[i]
if c < RuneSelf {
// ASCII fast path
i++
continue
}
fmt.Println("c=", c)
x := first[c]
fmt.Println("x=", x)
if x == xx {
i++ // invalid.
continue
}
size := int(x & 7)
fmt.Println("size=", size)
if i+size > ns {
i++ // Short or invalid.
continue
}
accept := acceptRanges[x>>4]
fmt.Println("accept: ", accept)
if c := s[i+1]; c < accept.lo || accept.hi < c {
size = 1
} else if size == 2 {
} else if c := s[i+2]; c < locb || hicb < c {
size = 1
} else if size == 3 {
} else if c := s[i+3]; c < locb || hicb < c {
size = 1
}
i += size
}
return n
}
func FullRune(p []byte) bool {
n := len(p)
if n == 0 {
return false
}
fmt.Println("po=", p[0])
x := first[p[0]]
if n >= int(x&7) {
return true // ASCII, invalid or valid.
}
// Must be short or invalid.
accept := acceptRanges[x>>4]
if n > 1 && (p[1] < accept.lo || accept.hi < p[1]) {
return true
} else if n > 2 && (p[2] < locb || hicb < p[2]) {
return true
}
return false
}
// FullRuneInString is like FullRune but its input is a string.
func FullRuneInString(s string) bool {
n := len(s)
if n == 0 {
return false
}
x := first[s[0]]
fmt.Println("xxx= ", x)
fmt.Println("x&7= ", x&7)
if n >= int(x&7) {
fmt.Println("--------")
return true // ASCII, invalid, or valid.
}
// Must be short or invalid.
accept := acceptRanges[x>>4]
if n > 1 && (s[1] < accept.lo || accept.hi < s[1]) {
fmt.Println("xxxxxx")
return true
} else if n > 2 && (s[2] < locb || hicb < s[2]) {
fmt.Println("eeeee")
return true
}
return false
}
func main(){
fmt.Println(reflect.TypeOf(acceptRanges))
str := "Hello, 钢铁侠"
fmt.Println(FullRuneInString(`\ubbbbbbb`))
fmt.Println(FullRune([]byte(str)))
fmt.Println(utf8.RuneCount([]byte(str)))
fmt.Println(str)
for i:=0;i<len(str);i++ {
fmt.Println(str[i])
}
fmt.Println([]byte(str))
for _, s := range str {
fmt.Println(s)
}
fmt.Println(reflect.TypeOf([]rune(str)[4]))
fmt.Println([]rune(str))
fmt.Println([]int32(str))
fmt.Println(utf8.RuneCountInString(str))
//fmt.Println(first[uint8(str[6])])
//accept := acceptRanges[4]
fmt.Println(RuneCountInString(str))
fmt.Println(utf8.ValidString(str))
}
Output:
[5]main.acceptRange
xxx= 240
x&7= 0
--------
true
po= 72
true
10
Hello, 钢铁侠
72
101
108
108
111
44
32
233
146
162
233
147
129
228
190
160
[72 101 108 108 111 44 32 233 146 162 233 147 129 228 190 160]
72
101
108
108
111
44
32
38050
38081
20384
int32
[72 101 108 108 111 44 32 38050 38081 20384]
[72 101 108 108 111 44 32 38050 38081 20384]
10
16
c= 233
x= 3
size= 3
accept: {128 191}
c= 233
x= 3
size= 3
accept: {128 191}
c= 228
x= 3
size= 3
accept: {128 191}
10
true