Golang学习(13)——unicode包

1160636144 · · 1030 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

Golang学习聽-聽unicode聽包

------------------------------

const (聽

聽聽聽聽MaxRune聽 聽 聽 聽 聽= '\U0010FFFF'聽// Unicode 码点的最大值

聽聽聽聽ReplacementChar = '\uFFFD'聽 聽 聽// 表示无效的码点

聽聽聽聽MaxASCII聽 聽 聽 聽 = '\u007F'聽 聽 聽// 最大 ASCII 值

聽聽聽聽MaxLatin1聽 聽 聽 聽= '\u00FF'聽 聽 聽// 最大 Latin-1 值

)

------------------------------

// 判断字符 r 是否在 rangtab 范围内。

// 可用的 RangeTable 参见 go/src/unicode/tables.go。

func聽Is(rangeTab *RangeTable, r rune) bool

// RangeTable 定义一个 Unicode 码点集合,包含 16 位和 32 位两个范围列表。

// 这两个列表必须经过排序而且不能重叠。R32 中只能包含大于 16 位的值。

type RangeTable struct {聽

聽聽聽聽R16聽 聽 聽 聽 聽[]Range16聽

聽聽聽聽R32聽 聽 聽 聽 聽[]Range32 LatinOffset int

聽聽聽聽// R16 中 Hi <= MaxLatin1 的条目数。

}

// Range16 表示一个 16 位的 Unicode 码点范围。范围从 Lo 到 Hi,具有指定的步长。

type Range16 struct {聽

聽聽聽聽Lo聽 聽 聽uint16

聽聽聽聽Hi聽 聽 聽uint16

聽聽聽聽Stride uint16聽聽聽聽// 步长

}

// Range32 表示一个 32 位的 Unicode 码点范围。范围从 Lo 到 Hi,具有指定的步长。

// Lo 和 Hi 必须都大于 16 位。

type Range32 struct {聽

聽聽聽聽Lo聽 聽 聽uint32

聽聽聽聽Hi聽 聽 聽uint32

聽聽聽聽Stride uint32聽聽聽聽// 步长

}

------------------------------

// 判断字符 r 是否为大写格式

func聽IsUpper(r rune) bool

// 判断字符 r 是否为小写格式

func聽IsLower(r rune) bool

// 判断字符 r 是否为 Unicode 规定的 Title 字符

// 大部分字符的 Title 格式就是其大写格式

// 只有少数字符的 Title 格式是特殊字符

// 这里判断的就是特殊字符

func聽IsTitle(r rune) bool

// ToUpper 将字符 r 转换为大写格式

func聽ToUpper(r rune) rune

// ToLower 将字符 r 转换为小写格式

func聽ToLower(r rune) rune

// ToTitle 将字符 r 转换为 Title 格式

// 大部分字符的 Title 格式就是其大写格式

// 只有少数字符的 Title 格式是特殊字符

func聽ToTitle(r rune) rune

// To 将字符 r 转换为指定的格式

// _case 取值:UpperCase、LowerCase、TitleCase

func聽To(_case int, r rune) rune

------------------------------

// 示例:判断汉字

func聽main() {

聽聽聽聽for _, r := range"Hello 世界!" {

聽聽聽聽聽聽聽聽// 判断字符是否为汉字

聽聽聽聽聽聽聽聽if unicode.Is(unicode.Scripts["Han"], r) {聽

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r) // 世界

聽聽聽聽聽聽聽聽}聽

聽聽聽聽}

}

// 更多unicode.Scripts取值参考:http://www.cnblogs.com/golove/p/3269099.html

-----------------------------

// 示例:判断大小写

func聽main() {

聽聽聽聽for _, r := range"Hello ABC!" {

聽聽聽聽// 判断字符是否为大写

聽聽聽聽聽聽聽聽if unicode.IsUpper(r) {聽

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r) // HABC

聽聽聽聽聽聽聽聽}

聽聽聽聽}

聽聽聽聽for _, r := range"Hello abc!" {

聽聽聽聽聽聽聽聽// 判断字符是否为小写

聽聽聽聽聽聽聽聽if unicode.IsLower(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r) // elloabc

聽聽聽聽聽聽聽聽}

聽聽聽聽}

聽聽聽聽for _, r := range"Hello !" {

聽聽聽聽聽聽聽聽// 判断字符是否为标题

聽聽聽聽聽聽聽聽if unicode.IsTitle(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r) //

聽聽聽聽聽聽聽聽}

聽聽聽聽}

}

------------------------------

// 示例:输出 Unicode 规定的标题字符

func聽main() {

聽聽聽聽for _, cr := range unicode.Lt.R16 {

聽聽聽聽聽聽聽聽for i := cr.Lo; i <= cr.Hi; i += cr.Stride {聽

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", i)

聽聽聽聽聽聽聽聽}

聽聽聽聽}聽

聽聽聽聽//

}

------------------------------

// 示例:转换大小写

func聽main() {聽

聽聽聽聽s := "Hello 世界!"

聽聽聽聽for _, r := range s {聽

聽聽聽聽聽聽聽聽fmt.Printf("%c", unicode.ToUpper(r))

聽聽聽聽} // HELLO 世界!

聽聽聽聽for _, r := range s {

聽聽聽聽聽聽聽聽fmt.Printf("%c", unicode.ToLower(r))

聽聽聽聽} // hello 世界!

聽聽聽聽for _, r := range s {

聽聽聽聽聽聽聽聽fmt.Printf("%c", unicode.ToTitle(r))

聽聽聽聽} // HELLO 世界!

聽聽聽聽for _, r := range s {

聽聽聽聽聽聽聽聽fmt.Printf("%c", unicode.To(unicode.UpperCase, r))

聽聽聽聽} // HELLO 世界!

聽聽聽聽for _, r := range s {

聽聽聽聽聽聽聽聽fmt.Printf("%c", unicode.To(unicode.LowerCase, r))

聽聽聽聽} // hello 世界!

聽聽聽聽for _, r := range s {

聽聽聽聽聽聽聽聽fmt.Printf("%c", unicode.To(unicode.TitleCase, r))

聽聽聽聽} // HELLO 世界!

}聽

------------------------------

// ToUpper 将 r 转换为大写格式

// 优先使用指定的映射表 special

// 可用的 SpecialCase 参见 go/src/unicode/casetables.go。

func (special SpecialCase) ToUpper(r rune) rune

// ToLower 将 r 转换为小写格式

// 优先使用指定的映射表 special

func (special SpecialCase) ToLower(r rune) rune

// ToTitle 将 r 转换为 Title 格式

// 优先使用指定的映射表 special

func (special SpecialCase) ToTitle(r rune) rune

// SpecialCase 表示特定语言的大小写映射,比如土耳其语。

// SpecialCase 的方法可以自定义标准映射(通过重写)。

type SpecialCase []CaseRange

// CaseRange 表示一个简单的 Unicode 码点范围,用于大小写转换。

// 在 Lo 和 Hi 范围内的码点,如果要转换成大写,只需要加上 d[0] 即可

// 如果要转换为小写,只需要加上 d[1] 即可,如果要转换为 Title 格式,

// 只需要加上 d[2] 即可。

type CaseRange struct {聽

聽聽聽聽Lo聽 聽 uint32

聽聽聽聽Hi聽 聽 uint32

聽聽聽聽Delta d // [3]rune

}

// CaseRanges 中 Delta 数组的索引。

const (聽

聽聽聽聽UpperCase = iota聽

聽聽聽聽LowerCase聽

聽聽聽聽TitleCase聽

聽聽聽聽MaxCase聽

)

// 如果一个 CaseRange 中的 Delta 元素是 UpperLower,则表示这个 CaseRange 是

// 一个有着连续的大写小写大写小写的范围。也就是说,Lo 是大写,Lo+1 是小写,

// Lo+2 是大写,Lo+3 是小写 ... 一直到 Hi 为止。

const (聽

聽聽聽聽UpperLower = MaxRune + 1聽聽聽聽// 不是一个有效的 Delta 元素

)

------------------------------

// 示例

func聽main() {聽

聽聽聽聽s := "Hello 世界!"

聽聽聽聽for _, r := range s {

聽聽聽聽聽聽聽聽fmt.Printf("%c", unicode.SpecialCase(unicode.CaseRanges).ToUpper(r))

聽聽聽聽} // HELLO 世界!

聽聽聽聽for _, r := range s {

聽聽聽聽聽聽聽聽fmt.Printf("%c", unicode.SpecialCase(unicode.CaseRanges).ToLower(r))

聽聽聽聽} // hello 世界!

聽聽聽聽for _, r := range s {聽

聽聽聽聽聽聽聽聽fmt.Printf("%c", unicode.SpecialCase(unicode.CaseRanges).ToTitle(r))

聽聽聽聽} // HELLO 世界!

}

------------------------------

// SimpleFold 在 Unicode 字符表中从字符 r 开始环绕查找(到尾部后再从头开始)

// 下一个与 r 大小写相匹配的字符(一个字符的大写、小写、标题三者视为大小写相匹配),

// 这个函数遵循 Unicode 定义的大小写环绕匹配表。

// 例如:// SimpleFold('A') = 'a'

// SimpleFold('a') = 'A'

// SimpleFold('K') = 'k'

// SimpleFold('k') = '' (开尔文符号)

// SimpleFold('') = 'K'

// SimpleFold('1') = '1'

func聽SimpleFold(r rune) rune

------------------------------

// 示例:SimpleFold

func聽main() {聽

聽聽聽聽s := "ΦφkK"聽聽聽聽// 看看 s 里面是什么

聽聽聽聽for _, c := range s {

聽聽聽聽聽聽聽聽fmt.Printf("%x 聽", c)

聽聽聽聽}聽

聽聽聽聽fmt.Println() 聽 聽// 大写,小写,标题 | 当前字符 -> 下一个匹配字符

聽聽聽聽for _, v := range s {

聽聽聽聽聽聽聽聽fmt.Printf("%c, %c, %c | %c -> %c\n", unicode.ToUpper(v), unicode.ToLower(v), unicode.ToTitle(v), v, unicode.SimpleFold(v), )

聽聽聽聽}

}

// 输出结果:

// 3a6 聽3c6 聽3d5 聽6b 聽4b 聽212a

// Φ, φ, Φ | Φ -> φ// Φ, φ, Φ | φ ->

// Φ, , Φ | -> Φ// K, k, K | k ->

// K, k, K | K -> k// , k, | -> K

------------------------------

// IsDigit 判断 r 是否为一个十进制的数字字符

func聽IsDigit(r rune) bool

// IsNumber 判断 r 是否为一个数字字符 (类别 N)

func聽IsNumber(r rune) bool

// IsLetter 判断 r 是否为一个字母字符 (类别 L)

// 汉字也是一个字母字符

func聽IsLetter(r rune) bool

// IsSpace 判断 r 是否为一个空白字符

// 在 Latin-1 字符集中,空白字符为:\t, \n, \v, \f, \r,

// 空格, U+0085 (NEL), U+00A0 (NBSP)

// 其它空白字符的定义有“类别 Z”和“Pattern_White_Space 属性”

func聽IsSpace(r rune) bool

// IsControl 判断 r 是否为一个控制字符

// Unicode 类别 C 包含更多字符,比如代理字符

// 使用 Is(C, r) 来测试它们

func聽IsControl(r rune) bool

// IsGraphic 判断字符 r 是否为一个“图形字符”

// “图形字符”包括字母、标记、数字、标点、符号、空格

// 他们分别对应于 L、M、N、P、S、Zs 类别

// 这些类别是 RangeTable 类型,存储了相应类别的字符范围

func聽IsGraphic(r rune) bool

// IsPrint 判断字符 r 是否为 Go 所定义的“可打印字符”

// “可打印字符”包括字母、标记、数字、标点、符号和 ASCII 空格

// 他们分别对应于 L, M, N, P, S 类别和 ASCII 空格

// “可打印字符”和“图形字符”基本是相同的,不同之处在于

// “可打印字符”只包含 Zs 类别中的 ASCII 空格(U+0020)

func聽IsPrint(r rune) bool 聽聽// IsPunct 判断 r 是否为一个标点字符 (类别 P)

func聽IsPunct(r rune) bool 聽聽// IsSymbol 判断 r 是否为一个符号字符

func聽IsSymbol(r rune) bool 聽// IsMark 判断 r 是否为一个 mark 字符 (类别 M)

func聽IsMark(r rune) bool 聽 聽聽// IsOneOf 判断 r 是否在 set 范围内

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

------------------------------

// 示例

func聽main() { fmt.Println() // 数字

聽聽聽聽for _, r := range聽"Hello 123123一二三!" {

聽聽聽聽聽聽聽聽if unicode.IsDigit(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r)

聽聽聽聽聽聽聽聽}

聽聽聽聽} // 123123

聽聽聽聽fmt.Println() // 数字

聽聽聽聽for _, r := range聽"Hello 123123一二三!" {

聽聽聽聽聽聽聽聽if unicode.IsNumber(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r)

聽聽聽聽聽聽聽聽}

聽聽聽聽} // 123123

聽聽聽聽fmt.Println()聽

聽聽聽聽// 字母

聽聽聽聽for _, r := range聽"Hello\n\t世界!" {

聽聽聽聽聽聽聽聽if unicode.IsLetter(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r)

聽聽聽聽聽聽聽聽}

聽聽聽聽} // Hello世界

聽聽聽聽fmt.Println() // 空白

聽聽聽聽for _, r := range聽"Hello \t世 界!\n" {

聽聽聽聽聽聽聽聽if unicode.IsSpace(r) {聽

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%q", r)聽

聽聽聽聽聽聽聽聽}

聽聽聽聽} // ' ''\t''\u3000''\n'

聽聽聽聽fmt.Println()聽

聽聽聽聽// 控制字符

聽聽聽聽for _, r := range聽"Hello\n\t世界!" {

聽聽聽聽聽聽聽聽if unicode.IsControl(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%#q", r)

聽聽聽聽聽聽聽聽}

聽聽聽聽} // '\n''\t'

聽聽聽聽fmt.Println()聽

聽聽聽聽// 可打印

聽聽聽聽for _, r := range聽"Hello 世界!\t" {

聽聽聽聽聽聽聽聽if unicode.IsPrint(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r)

聽聽聽聽聽聽聽聽}

聽聽聽聽} // Hello世界!

聽聽聽聽fmt.Println()聽

聽聽聽聽// 图形

聽聽聽聽for _, r := range聽"Hello 世界!\t" {

聽聽聽聽聽聽聽聽if unicode.IsGraphic(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r)

聽聽聽聽聽聽聽聽}

聽聽聽聽} // Hello 世界!

聽聽聽聽fmt.Println()聽

聽聽聽聽// 掩码

聽聽聽聽for _, r := range聽"Hello !" {

聽聽聽聽聽聽聽聽if unicode.IsMark(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r)

聽聽聽聽聽聽聽聽}

聽聽聽聽} //

聽聽聽聽fmt.Println() // 标点

聽聽聽聽for _, r := range聽"Hello 世界!" {

聽聽聽聽聽聽聽聽if unicode.IsPunct(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r)

聽聽聽聽聽聽聽聽}

聽聽聽聽} // !

聽聽聽聽fmt.Println()聽

聽聽聽聽// 符号

聽聽聽聽for _, r := range聽"Hello (<世=界>)" {

聽聽聽聽聽聽聽聽if unicode.IsSymbol(r) {

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r)

聽聽聽聽聽聽聽聽}

聽聽聽聽} // <=>

}

------------------------------

// 示例:判断汉字和标点

func聽main() {

聽聽聽聽// 将 set 设置为“汉字、标点符号”

聽聽聽聽set := []*unicode.RangeTable{

聽聽聽聽聽聽聽聽unicode.Han, unicode.P

聽聽聽聽}

聽聽聽聽for _, r := range聽"Hello 世界!" {

聽聽聽聽聽聽聽聽if unicode.IsOneOf(set, r) {聽

聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", r)

聽聽聽聽聽聽聽聽}

聽聽聽聽} // 世界!

}

------------------------------

// 示例:输出所有 mark 字符

func聽main() {

聽聽聽聽for _, cr := range unicode.M.R16 {聽

聽聽聽聽聽聽聽聽Lo, Hi, Stride := rune(cr.Lo), rune(cr.Hi), rune(cr.Stride)

聽聽聽聽聽聽聽聽for i := Lo; i >= Lo && i <= Hi; i += Stride {

聽聽聽聽聽聽聽聽聽聽聽聽if unicode.IsMark(i) {聽

聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽fmt.Printf("%c", i)聽

聽聽聽聽聽聽聽聽聽聽聽聽}聽

聽聽聽聽聽聽聽聽}

聽聽聽聽}

}



有疑问加站长微信联系(非本文作者)

本文来自:51CTO博客

感谢作者:1160636144

查看原文:Golang学习(13)——unicode包

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

1030 次点击  
加入收藏 微博
下一篇:初识go语言
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传