Qu'est-ce qu'une rune?

Question

Qu'est-ce qu'une rune en Go?

J'ai cherché sur Google mais Golang dit seulement en une ligne: rune est un alias pour int32.

Mais comment se fait-il que des entiers soient utilisés partout comme dans le cas du changement de cas?

Voici une fonction swapcase. Qu'est-ce que tous les <= et -?

Et pourquoi le switch n'a-t-il pas d'arguments?

&& devrait signifier et mais que signifie r <= 'z'?

func SwapRune(r rune) rune {
    switch {
    case 'a' <= r && r <= 'z':
        return r - 'a' + 'A'
    case 'A' <= r && r <= 'Z':
        return r - 'A' + 'a'
    default:
        return r
    }
}

La plupart d'entre eux proviennent de http://play.golang.org/p/H6wjLZj6lW

func SwapCase(str string) string {
    return strings.Map(SwapRune, str)
}

Je comprends que cela mappe rune à string pour qu'il puisse retourner la chaîne échangée. Mais je ne comprends pas exactement comment rune ou byte fonctionnent ici.

Answer 1

Tout le monde a déjà abordé la partie liée aux runes, donc je ne vais pas en parler.

Cependant, il y a aussi une question liée au switch n'ayant aucun argument. Cela est simplement dû au fait qu'en Golang, switch sans expression est une façon alternative d'exprimer la logique if/else. Par exemple, écrire ceci :

t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("C'est avant midi")
default:
    fmt.Println("C'est après midi")
}

est équivalent à écrire ceci :

t := time.Now()
if t.Hour() < 12 {
    fmt.Println("C'est avant midi")
} else {
    fmt.Println("C'est après midi")
}

Vous pouvez en savoir plus ici.

Answer 2

Une rune est une valeur int32, et donc c'est un type Go utilisé pour représenter un point de code Unicode. Un point de code Unicode est une valeur numérique généralement utilisée pour représenter des caractères Unicode individuels;

Answer 3

Programme

package main

import (
    "fmt"
)

func main() {
    words := "€25 or less"
    fmt.Println("comme tranche de chaîne")
    fmt.Println(words, len(words))

    runes := []rune(words)
    fmt.Println("\ncomme tranche de []rune")
    fmt.Printf("%v, len:%d\n", runes, len(runes))

    bytes := []byte(words)
    fmt.Println("\ncomme tranche de []byte")
    fmt.Printf("%v, len:%d\n", bytes, len(bytes))
}

Sortie

comme tranche de chaîne
€25 or less 13

comme tranche de []rune
[8364 50 53 32 111 114 32 108 101 115 115], len:11

comme tranche de []byte
[226 130 172 50 53 32 111 114 32 108 101 115 115], len:13

Comme vous pouvez le voir, le symbole euro '€' est représenté par 3 octets - 226, 130 et 172. Le rune représente un caractère - n'importe quel caractère, que ce soit des hiéroglyphes. Les 32 bits d'un rune sont suffisants pour représenter tous les caractères du monde tels qu'ils existent aujourd'hui. Ainsi, la représentation rune d'un symbole euro '€' est 8364.

Pour les caractères ASCII, qui sont au nombre de 128, un octet (8 bits) est suffisant. Par conséquent, la représentation rune et la représentation byte des chiffres ou des lettres sont les mêmes. Par exemple : 2 est représenté par 50.

Une représentation byte d'une chaîne est toujours supérieure ou égale à sa représentation rune en longueur, car certains caractères sont représentés par plus d'un octet mais à l'intérieur de 32 bits, qui est un rune.

https://play.golang.org/p/y93woDLs4Qe

Answer 4

Une rune est un alias pour int32 et est équivalent à int32 de toutes les manières. Elle est utilisée pour distinguer les valeurs de caractère des valeurs entières.

l = 108, o = 111

Answer 5

Rune est un alias pour le type int32. Il représente un seul point de code Unicode. Le Consortium Unicode attribue des valeurs numériques, appelées points de code, à plus d'un million de caractères uniques. Par exemple, 65 est le point de code pour la lettre A, 66 -> B (source : Get Programming with Go)