1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
|
//------------------------------------------------------------
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 ＡＢＣ！" {
// 判断字符是否为大写
if unicode.IsUpper(r) {
fmt.Printf("%c", r) // HＡＢＣ
}
}
for _, r := range "Hello ａｂｃ！" {
// 判断字符是否为小写
if unicode.IsLower(r) {
fmt.Printf("%c", r) // elloａｂｃ
}
}
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)
}
} // DžLjNjDzᾈᾉᾊᾋᾌᾍᾎᾏᾘᾙᾚᾛᾜᾝᾞᾟᾨᾩᾪᾫᾬᾭᾮᾯᾼῌῼ
}
//------------------------------
// 示例：转换大小写
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') = 'K' (开尔文符号)
// SimpleFold('K') = 'K'
//
// SimpleFold('1') = '1'
func SimpleFold(r rune) rune
//------------------------------
// 示例：SimpleFold
func main() {
s := "ΦφϕkKK"
// 看看 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, 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 123１２３一二三！" {
if unicode.IsDigit(r) {
fmt.Printf("%c", r)
}
} // 123１２３
fmt.Println() // 数字
for _, r := range "Hello 123１２３一二三！" {
if unicode.IsNumber(r) {
fmt.Printf("%c", r)
}
} // 123１２３
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)
}
}
}
}
//------------------------------------------------------------
|