Rune en Go

1. Exemple d’utilisation de Rune dans Go
2. Utiliser Rune avec barre oblique inverse \ dans Go
3. Comparez byte() et rune() dans Go

Dans Go, une rune est un alias pour le type de données int32, représentant les points de code Unicode. Il fait référence à la valeur numérique attribuée à un caractère Unicode.

Il y a quelques années, nous avons utilisé le jeu de caractères ASCII, qui utilise sept bits pour représenter cent quatre-vingt-deux caractères, y compris les lettres majuscules, les valeurs numériques, etc. En revanche, le jeu de caractères ASCII s’est avéré incapable de gérer le nombre énorme du monde. des langues et des symboles.

Le codage de caractères Unicode a été créé pour surmonter ce problème. Il s’agit d’un sur-ensemble de codage de caractères ASCII, avec un maximum de 1114112 points de code Unicode.

Regardons quelques exemples pour mieux comprendre.

Exemple d’utilisation de Rune dans Go

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

func main() {
    r := 'b'

    fmt.Printf("Size: %d\n", unsafe.Sizeof(r))
    fmt.Printf("Type: %s\n", reflect.TypeOf(r))
    fmt.Printf("Unicode CodePoint: %U\n", r)
    fmt.Printf("Character: %c\n", r)

    s := "Jay Singh"

    fmt.Printf("%U\n", []rune(s))
    fmt.Println([]rune(s))
}

Production:

Size: 4
Type: int32
Unicode CodePoint: U+0062
Character: b
[U+004A U+0061 U+0079 U+0020 U+0053 U+0069 U+006E U+0067 U+0068]
[74 97 121 32 83 105 110 103 104]

Utiliser Rune avec barre oblique inverse \ dans Go

Toutes les séquences qui commencent par une barre oblique inverse sont interdites dans les littéraux runiques.

package main

import (
    "fmt"
    "reflect"
)

func main() {

    rune1 := 'J'
    rune2 := 'c'
    rune3 := '\\'

    fmt.Printf("Rune 1: %c; Unicode: %U; Type: %s", rune1,
        rune1, reflect.TypeOf(rune1))

    fmt.Printf("\nRune 2: %c; Unicode: %U; Type: %s", rune2,
        rune2, reflect.TypeOf(rune2))

    fmt.Printf("\nRune 3: Unicode: %U; Type: %s", rune3,
        rune3, reflect.TypeOf(rune3))
}

Production:

Rune 1: J; Unicode: U+004A; Type: int32
Rune 2: c; Unicode: U+0063; Type: int32
Rune 3: Unicode: U+005C; Type: %!s(int32=92)%!(EXTRA *reflect.rtype=int32)

Comparez byte() et rune() dans Go

Sortons le tableau d’octets et la rune d’une chaîne contenant des caractères non ASCII dans cet exemple. La valeur runique spéciale du caractère Unicode est 214 ; cependant, l’encodage prend deux octets.

package main

import (
    "fmt"
)

func main() {
    s := "GÖ"

    s_rune := []rune(s)
    s_byte := []byte(s)

    fmt.Println(s_rune)
    fmt.Println(s_byte)
}

Production:

[71 214]
[71 195 150]