unicode

unicode包提供数据和功能来测试Unicode代码点的某些属性。

Constants

const (
    MaxRune         = '\U0010FFFF' // 最大的合法unicode码值
    ReplacementChar = '\uFFFD'     // 表示不合法的unicode码值
    MaxASCII        = '\u007F'     // 最大的ASCII值
    MaxLatin1       = '\u00FF'     // 最大的Latin-1值
)
const (
    UpperCase = iota
    LowerCase
    TitleCase
    MaxCase
)

下值可用于CaseRange类型里的数组类型Delta字段，用于码值映射。

const (
    UpperLower = MaxRune + 1 // 不能是合法的delta值
)

如果一个CaseRange类型的的Delta字段使用了UpperLower，就表示该CaseRange表示的序列格式为：Upper Lower Upper Lower

const Version = "6.3.0"

Version是本包采用的unicode版本（以及Variables栏里那些乱七八糟的字符集的来源）。

Variables

var (
    Cc     = _Cc // Cc is the set of Unicode characters in category Cc.
    Cf     = _Cf // Cf is the set of Unicode characters in category Cf.
    //......
    Zs     = _Zs // Zs is the set of Unicode characters in category Zs.
)

这些变量的类型是*RangeTable。

var (
    Arabic                 = _Arabic                 // Arabic is the set of Unicode characters in script Arabic.
    Armenian               = _Armenian               // Armenian is the set of Unicode characters in script Armenian.
    // ......
    Yi                     = _Yi                     // Yi is the set of Unicode characters in script Yi.
)

这些变量的类型也是*RangeTable。

var (
    ASCII_Hex_Digit                    = _ASCII_Hex_Digit                    // ASCII_Hex_Digit is the set of Unicode characters with property ASCII_Hex_Digit.
    Bidi_Control                       = _Bidi_Control                       // Bidi_Control is the set of Unicode characters with property Bidi_Control.
    // ......
    White_Space                        = _White_Space                        // White_Space is the set of Unicode characters with property White_Space.
)

这些变量的类型还是*RangeTable。

var CaseRanges = _CaseRanges

CaseRanges是描述非字母映射的所有字母的大小写映射的表。

var Categories = map[string]*RangeTable{
    "C":  C,
    // ......
    "Zs": Zs,
}

Categories 是Unicode类别表的集合。

var FoldCategory = map[string]*RangeTable{
    "Common":    foldCommon,
    "Greek":     foldGreek,
    "Inherited": foldInherited,
    "L":         foldL,
    "Ll":        foldLl,
    "Lt":        foldLt,
    "Lu":        foldLu,
    "M":         foldM,
    "Mn":        foldMn,
}

FoldCategory将类别名称映射到类别外部的代码点表，这些代码点在简单的大小写折叠下等同于类别内部的代码点。 如果没有类别名称的条目，则没有这些点。

var FoldScript = map[string]*RangeTable{}

FoldScript将脚本名称映射到脚本外部的代码点表，这些代码点在简单的大小写折叠下等同于脚本内部的代码点。 如果没有脚本名称的条目，则没有这些要点。

var GraphicRanges = []*RangeTable{
    L, M, N, P, S, Zs,
}

GraphicRanges根据Unicode定义图形字符集。

var PrintRanges = []*RangeTable{
    L, M, N, P, S,
}

PrintRanges根据Go定义可打印字符集。 ASCII空间U + 0020是分开处理的。

var Properties = map[string]*RangeTable{
    "ASCII_Hex_Digit":                    ASCII_Hex_Digit,
    "Bidi_Control":                       Bidi_Control,
    // ......
    "White_Space":                        White_Space,
}

属性是Unicode属性表的集合。

var Scripts = map[string]*RangeTable{
    "Arabic":                 Arabic,
    "Armenian":               Armenian,
    // ......
    "Yi":                     Yi,
}

Scripts 是Unicode脚本表的集合。

type CaseRange

type CaseRange struct {
    Lo    uint32
    Hi    uint32
    Delta d // d为[MaxCase]rune的命名类型
}

代表简单的unicode码值的一一映射。范围为[Lo, Hi]，步长为1。

该范围内的每个值+Delta[UpperCase]表示对应的大写字母；

该范围内的每个值+Delta[LowerCase]表示对应的小写字母；

该范围内的每个值+Delta[TitleCase]表示对应的标题字母。

Delta数组里的值可为负数或零。如果Delta数组是：

{UpperLower, UpperLower, UpperLower}

表示[Lo, Hi]范围的字符序列是交替的、对应的大写字母小写字母对。否则常数UpperLower不能用Delta数组里。

type Range16

type Range16 struct {
    Lo     uint16
    Hi     uint16
    Stride uint16
}

代表一系列16位unicode码值，范围为Lo到Hi（可以是Lo/Hi），步长为Stride。

type Range32

type Range32 struct {
    Lo     uint32
    Hi     uint32
    Stride uint32
}

代表一系列32位unicode码值，范围为Lo到Hi（可以是Lo/Hi），步长为Stride；Lo和Hi必须大于等于1<<16。

type RangeTable

type RangeTable struct {
    R16         []Range16
    R32         []Range32  // R32不能包含低于0x10000（即1<<16）的值
    LatinOffset int // R16字段中Hi <= MaxLatin1的成员数
}

通过列出集合中码值的范围，定义了一个unicode码值的集合。出于节省空间，范围保存在两个切片里，分别保存16位字符的范围和32位字符的范围。R16和R32必须是有序排列的，且互不重叠的。

type SpecialCase

type SpecialCase []CaseRange

SpecialCase代表特定语言的字符映射，如土耳其语。本类型的方法（通过覆盖）定制了标准映射。

var AzeriCase SpecialCase = _TurkishCase
var TurkishCase SpecialCase = _TurkishCase

func (SpecialCase) ToLower

func (special SpecialCase) ToLower(r rune) rune

按特定映射，返回对应的小写字母。

func (SpecialCase) ToUpper

func (special SpecialCase) ToUpper(r rune) rune

按特定映射，返回对应的大写字母。

func (SpecialCase) ToTitle

func (special SpecialCase) ToTitle(r rune) rune

按特定映射，返回对应的标题字母。

func Is

func Is(rangeTab *RangeTable, r rune) bool

函数报告r是否在rangeTab指定的字符范围内。

func In

func In(r rune, ranges ...*RangeTable) bool

函数报告r是否是给出的某个字母集的成员。

func IsOneOf

func IsOneOf(ranges []*RangeTable, r rune) bool

函数报告r是否是ranges某个成员指定的字符范围内。本函数的功能类似In，应优先使用In函数。

func IsSpace

func IsSpace(r rune) bool

IsSpace报告一个字符是否是空白字符。在Latin-1字符空间中，空白字符为：

'\t', '\n', '\v', '\f', '\r', ' ', U+0085 (NEL), U+00A0 (NBSP).

其它的空白字符请参见策略Z和属性Pattern_White_Space。

func IsDigit

func IsDigit(r rune) bool

IsDigit报告一个字符是否是十进制数字字符。

func IsNumber

func IsNumber(r rune) bool

IsNumber报告一个字符是否是数字字符，参见策略N。

func IsLetter

func IsLetter(r rune) bool

IsLetter报告一个字符是否是字母，参见策略L。

func IsGraphic

func IsGraphic(r rune) bool

报告一个字符是否是unicode图形。包括字母、标记、数字、符号、标点、空白，参见L、M、N、P、S、Zs。

func IsMark

func IsMark(r rune) bool

IsMark报告一个字符是否是标记字符，参见策略M。

func IsPrint

func IsPrint(r rune) bool

IsPrint一个字符是否是go的可打印字符。本函数基本和IsGraphic一致，只是ASCII空白字符U+0020会返回假。

func IsControl

func IsControl(r rune) bool

IsControl报告一个字符是否是控制字符，主要是策略C的字符和一些其他的字符如代理字符。

func IsPunct

func IsPunct(r rune) bool

IsPunct报告一个字符是否是unicode标点字符，参见策略P。

func IsSymbol

func IsSymbol(r rune) bool

IsSymbol报告一个字符是否是unicode符号字符。

func IsLower

func IsLower(r rune) bool

返回字符是否是小写字母。

func IsUpper

func IsUpper(r rune) bool

返回字符是否是大写字母。

func IsTitle

func IsTitle(r rune) bool

返回字符是否是标题字母。

func To

func To(_case int, r rune) rune

返回_case指定的对应类型的字母：UpperCase、LowerCase、TitleCase。

func ToLower

func ToLower(r rune) rune

返回对应的小写字母。

func ToUpper

func ToUpper(r rune) rune

返回对应的大写字母。

func ToTitle

func ToTitle(r rune) rune

返回对应的标题字母。

func SimpleFold

func SimpleFold(r rune) rune

SimpleFold函数迭代在unicode标准字符映射中互相对应的unicode码值。在与r对应的码值中（包括r自身），会返回最小的那个大于r的字符（如果有）；否则返回映射中最小的字符。

举例：

SimpleFold('A') = 'a'
SimpleFold('a') = 'A'
SimpleFold('K') = 'k'
SimpleFold('k') = '\u212A' (Kelvin symbol, K)
SimpleFold('\u212A') = 'K'
SimpleFold('1') = '1'

Bugs

☞ 没有全字符（包含多个rune的字符）折叠的机制。

• utf16
• utf8

utf16

utf16包实现了UTF-16序列的编解码。

func IsSurrogate

func IsSurrogate(r rune) bool

返回r是否可以编码为一个utf-16的代理对。

func DecodeRune

func DecodeRune(r1, r2 rune) rune

将utf-16代理对(r1, r2)解码为unicode码值。如果代理对不合法，会返回U+FFFD。

func Decode

func Decode(s []uint16) []rune

将utf-16序列解码为unicode码值序列。

func EncodeRune

func EncodeRune(r rune) (r1, r2 rune)

将unicode码值r编码为一个utf-16的代理对。如果不能编码，会返回(U+FFFD, U+FFFD)。

func Encode

func Encode(s []rune) []uint16

将unicode码值序列编码为utf-16序列。

utf8

utf8包实现了对utf-8文本的常用函数和常数的支持，包括rune和utf-8编码byte序列之间互相翻译的函数。

Constants

const (
    RuneError = '\uFFFD'     // 错误的Rune或"Unicode replacement character"
    RuneSelf  = 0x80         // 低于RunSelf的字符用代表单字节的同一值表示
    MaxRune   = '\U0010FFFF' // 最大的合法unicode码值
    UTFMax    = 4            // 最大的utf-8编码的unicode字符的长度
)

编码的基础常数。

func ValidRune

func ValidRune(r rune) bool

判断r是否可以编码为合法的utf-8序列。

func main() {
   valid := 'a'
   invalid := rune(0xfffffff)
   fmt.Println(utf8.ValidRune(valid))
   fmt.Println(utf8.ValidRune(invalid))
}

func RuneLen

func RuneLen(r rune) int

返回r编码后的字节数。如果r不是一个合法的可编码为utf-8序列的值，会返回-1。

func main() {
   fmt.Println(utf8.RuneLen('a'))
   fmt.Println(utf8.RuneLen('界'))
}

func RuneStart

func RuneStart(b byte) bool

报告字节b是否可以作为某个rune编码后的第一个字节。第二个即之后的字节总是将左端两个字位设为10。

func main() {
   buf := []byte("a界")
   fmt.Println(utf8.RuneStart(buf[0]))
   fmt.Println(utf8.RuneStart(buf[1]))
   fmt.Println(utf8.RuneStart(buf[2]))
}

func FullRune

func FullRune(p []byte) bool

报告切片p是否以一个码值的完整utf-8编码开始。不合法的编码因为会被转换为宽度1的错误码值而被视为完整的。

func main() {
   buf := []byte{228, 184, 150} // 世
   fmt.Println(utf8.FullRune(buf))
   fmt.Println(utf8.FullRune(buf[:2]))
}

func FullRuneInString

func FullRuneInString(s string) bool

函数类似FullRune但输入参数是字符串。

func main() {
   str := "世"
   fmt.Println(utf8.FullRuneInString(str))
   fmt.Println(utf8.FullRuneInString(str[:2]))
}

func RuneCount

func RuneCount(p []byte) int

返回p中的utf-8编码的码值的个数。错误或者不完整的编码会被视为宽度1字节的单个码值。

func main() {
   buf := []byte("Hello, 世界")
   fmt.Println("bytes =", len(buf))
   fmt.Println("runes =", utf8.RuneCount(buf))
}

func RuneCountInString

func RuneCountInString(s string) (n int)

函数类似RuneCount但输入参数是一个字符串。

func main() {
   str := "Hello, 世界"
   fmt.Println("bytes =", len(str))
   fmt.Println("runes =", utf8.RuneCountInString(str))
}

func Valid

func Valid(p []byte) bool

返回切片p是否包含完整且合法的utf-8编码序列。

func main() {
   valid := []byte("Hello, 世界")
   invalid := []byte{0xff, 0xfe, 0xfd}
   fmt.Println(utf8.Valid(valid))
   fmt.Println(utf8.Valid(invalid))
}

func ValidString

func ValidString(s string) bool

报告s是否包含完整且合法的utf-8编码序列。

func main() {
   valid := "Hello, 世界"
   invalid := string([]byte{0xff, 0xfe, 0xfd})
   fmt.Println(utf8.ValidString(valid))
   fmt.Println(utf8.ValidString(invalid))
}

func EncodeRune

func EncodeRune(p []byte, r rune) int

EncodeRune将r的utf-8编码序列写入p（p必须有足够的长度），并返回写入的字节数。

func main() {
   r := '世'
   buf := make([]byte, 3)
   n := utf8.EncodeRune(buf, r)
   fmt.Println(buf)
   fmt.Println(n)
}

func DecodeRune

func DecodeRune(p []byte) (r rune, size int)

函数解码p开始位置的第一个utf-8编码的码值，返回该码值和编码的字节数。如果编码不合法，会返回(RuneError, 1)。该返回值在正确的utf-8编码情况下是不可能返回的。

如果一个utf-8编码序列格式不正确，或者编码的码值超出utf-8合法码值的范围，或者不是该码值的最短编码，该编码序列即是不合法的。函数不会执行其他的验证。

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

func DecodeRuneInString

func DecodeRuneInString(s string) (r rune, size int)

函数类似DecodeRune但输入参数是字符串。

func main() {
    str := "Hello, 世界"
    for len(str) > 0 {
        r, size := utf8.DecodeRuneInString(str)
        fmt.Printf("%c %v\n", r, size)
        str = str[size:]
    }
}

func DecodeLastRune

func DecodeLastRune(p []byte) (r rune, size int)

函数解码p中最后一个utf-8编码序列，返回该码值和编码序列的长度。

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

func DecodeLastRuneInString

func DecodeLastRuneInString(s string) (r rune, size int)

函数类似DecodeLastRune但输入参数是字符串。

func main() {
   str := "Hello, 世界"
   for len(str) > 0 {
      r, size := utf8.DecodeLastRuneInString(str)
      fmt.Printf("%c %v\n", r, size)
      str = str[:len(str)-size]
   }
}