golang unicode/utf8源码分析|牛气冲天新年征文

3,459 阅读5分钟

简介

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