Golang中使用runes

Gorune教程展示了如何在Golang中使用runes。

$ go version
go version go1.18.1 linux/amd64

我们使用Go版本1.18。

符文是int32数据类型的别名。它代表一个Unicode代码点。Unicode代码点或代码位置是通常用于表示Unicode字符的数值。int32足以表示当前140,000个unicode字符的数量。

ASCII定义了128个字符，由代码点0∼127标识。Unicode是ASCII的超集，定义了1,114,112个代码点的代码空间。

原始的如尼文字是属于古代日耳曼各民族，尤其是斯堪的纳维亚人和盎格鲁撒克逊人的书面语言中的一个字母。

一个字符串是一个字节序列；更准确地说，是一片任意字节。InGo，源码为UTF8。字符串可以包含以UTF-8编码的Unicode文本，它使用一到四个字节对所有Unicode代码点进行编码。

Go符文常量

Gorune常量由一对单引号'字符分隔。

package main

import (
    "fmt"
    "reflect"
)

func main() {

    a1 := '🦍'
    var a2 = 'k'
    var a3 rune = '🦡'

    fmt.Printf("%c - %s\n", a1, reflect.TypeOf(a1))
    fmt.Printf("%c - %s\n", a2, reflect.TypeOf(a2))
    fmt.Printf("%c - %s\n", a3, reflect.TypeOf(a3))
}

我们定义了三个符文常量。

a1 := '🦍'
var a2 = 'k'
var a3 rune = '🦡'

我们有两个表情符号和一个ASCII字符。如果未明确指定，Go会自动推断出rune类型。

fmt.Printf("%c - %s\n", a1, reflect.TypeOf(a1))
fmt.Printf("%c - %s\n", a2, reflect.TypeOf(a2))
fmt.Printf("%c - %s\n", a3, reflect.TypeOf(a3))

我们打印字符及其类型。

$ go run rune_constant.go
🦍 - int32
k - int32
🦡 - int32

我们可以使用转义来定义符文常量。

package main

import (
    "fmt"
)

func main() {

    a1 := '🧺'
    a2 := '\u2665'
    a3 := '\U0001F3A8'

    fmt.Printf("%c\n", a1)
    fmt.Printf("%c\n", a2)
    fmt.Printf("%c\n", a3)
}

我们定义了三个常量；其中两个正在使用转义符。

a2 := '\u2665'

在第一种情况下，\u后面紧跟四个十六进制数字。

a3 := '\U0001F3A8'

在第二种情况下，\U后面紧跟八个十六进制数字。

$ go run rune_escapes.go
🧺
♥
🎨

GoruneUnicode代码点

Unicode码点是指Unicode表中的字符。

package main

import "fmt"

func main() {

    s1 := "falcon"
    r1 := []rune(s1)
    fmt.Printf("%U\n", r1)

    s2 := "🐧🐧🐧"
    r2 := []rune(s2)
    fmt.Printf("%U\n", r2)
}

通过%U格式动词，我们得到了Unicode代码点。

$ go run code_points.go 
[U+0066 U+0061 U+006C U+0063 U+006F U+006E]
[U+1F427 U+1F427 U+1F427]

去数符文

在下面的例子中，我们计算一个字符串中符文的数量。

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {

    msg := "one 🐜"
    n1 := len(msg)
    n2 := utf8.RuneCountInString(msg)

    fmt.Println(n1)
    fmt.Println(n2)
}

通过len函数，我们可以得到字节数。为了计算符文的数量，我们使用utf8.RuneCountInString函数。

$ go run count.go
8
5

Go符文和字节

Go中的一个字节是uint8的别名；它是一个“ASCII字节”。

package main

import (
    "fmt"
)

func main() {

    msg := "🐘 🦥 🐋"

    data := []rune(msg)
    fmt.Println(data)

    data2 := []byte(msg)
    fmt.Println(data2)
}

我们有一个由三个表情符号和两个空格组成的字符串。我们打印sliceofrunes和bytes以进行比较。

$ go run rune_bytes.go
[128024 32 129445 32 128011]
[240 159 144 152 32 240 159 166 165 32 240 159 144 139]

循环符文

for/range形式迭代符文。

package main

import (
    "fmt"
)

func main() {

    msg := "one 🐘 and three 🐋"

    for idx, e := range msg {
        fmt.Printf("Char:%s Byte pos: %d \n", string(e), idx)
    }
}

该示例遍历符文。它显示字符及其在字符串中的字节位置。

$ go run loop.go
Char:o Byte pos: 0
Char:n Byte pos: 1
Char:e Byte pos: 2
Char:  Byte pos: 3
Char:🐘 Byte pos: 4
Char:  Byte pos: 8
Char:a Byte pos: 9
Char:n Byte pos: 10
Char:d Byte pos: 11
Char:  Byte pos: 12
Char:t Byte pos: 13
Char:h Byte pos: 14
Char:r Byte pos: 15
Char:e Byte pos: 16
Char:e Byte pos: 17
Char:  Byte pos: 18
Char:🐋 Byte pos: 19

在下一个示例中，我们有另一种遍历符文的方法。

package main

import (
    "fmt"
)

func main() {

    msg := "one 🐘 and three 🐋"
    data := []rune(msg)

    for i := 0; i < len(data); i++ {
        fmt.Printf("Char %c Unicode: %U, Rune pos: %d\n", data[i], data[i], i)
    }

    fmt.Println()
}

我们将字符串转换为符文切片，然后使用for循环遍历该切片。

$ go run loop2.go 
Char o Unicode: U+006F, Rune pos: 0
Char n Unicode: U+006E, Rune pos: 1
Char e Unicode: U+0065, Rune pos: 2
Char   Unicode: U+0020, Rune pos: 3
Char 🐘 Unicode: U+1F418, Rune pos: 4
Char   Unicode: U+0020, Rune pos: 5
Char a Unicode: U+0061, Rune pos: 6
Char n Unicode: U+006E, Rune pos: 7
Char d Unicode: U+0064, Rune pos: 8
Char   Unicode: U+0020, Rune pos: 9
Char t Unicode: U+0074, Rune pos: 10
Char h Unicode: U+0068, Rune pos: 11
Char r Unicode: U+0072, Rune pos: 12
Char e Unicode: U+0065, Rune pos: 13
Char e Unicode: U+0065, Rune pos: 14
Char   Unicode: U+0020, Rune pos: 15
Char 🐋 Unicode: U+1F40B, Rune pos: 16

在本教程中，我们使用了Go符文。

列出所有Go教程。