Runes in

Über Runes

Der Typ rune in Go ist ein Alias für int32. Aufgrund dieses zugrunde liegenden Typs int32 speichert der Typ rune einen vorzeichenbehafteten 32-Bit-Ganzzahlwert. Anders als beim Typ int32 repräsentiert der im Typ rune gespeicherte Ganzzahlwert jedoch ein einzelnes Unicode-Zeichen.

Unicode und Unicode-Codepunkte

Unicode ist eine Obermenge von ASCII, die Zeichen repräsentiert, indem sie jedem Zeichen eine eindeutige Zahl zuweist. Diese eindeutige Zahl heißt Unicode-Codepunkt. Unicode hat das Ziel, alle Zeichen der Welt als Unicode-Codepunkte darzustellen, einschließlich verschiedener Alphabete, Zahlen, Symbole und sogar Emojis.

In Go repräsentiert der Typ rune einen einzelnen Unicode-Codepunkt.

Die folgende Tabelle enthält Beispiele für Unicode-Zeichen zusammen mit ihrem Unicode-Codepunkt und ihrem Dezimalwert:

UTF-8

UTF-8 ist eine Zeichenkodierung mit variabler Breite, mit der jeder Unicode-Codepunkt als 1, 2, 3 oder 4 Bytes kodiert wird. Da ein Unicode-Codepunkt mit maximal 4 Bytes kodiert werden kann, muss der Typ rune in der Lage sein, bis zu 4 Bytes an Daten zu speichern. Deshalb ist der Typ rune ein Alias für int32, denn der Typ int32 kann bis zu 4 Bytes an Daten speichern.

Go-Quellcodedateien werden mit UTF-8 kodiert.

Runes verwenden

Variablen vom Typ rune deklarierst du, indem du ein Zeichen in einfache Anführungszeichen setzt:

myRune := '¿'

Da rune nur ein Alias für int32 ist, ergibt das Ausgeben des Typs einer Rune int32:

myRune := '¿'
fmt.Printf("myRune type: %T\n", myRune)
// Output: myRune type: int32

Genauso ergibt das Ausgeben des Werts einer Rune ihren ganzzahligen (dezimalen) Wert:

myRune := '¿'
fmt.Printf("myRune value: %v\n", myRune)
// Output: myRune value: 191

Um das von der Rune repräsentierte Unicode-Zeichen auszugeben, verwendest du das Formatierungsverb %c:

myRune := '¿'
fmt.Printf("myRune Unicode character: %c\n", myRune)
// Output: myRune Unicode character: ¿

Um den von der Rune repräsentierten Unicode-Codepunkt auszugeben, verwendest du das Formatierungsverb %U:

myRune := '¿'
fmt.Printf("myRune Unicode code point: %U\n", myRune)
// Output: myRune Unicode code point: U+00BF

Neben der Definition einer Rune durch Einschließen des Zeichens in einfache Anführungszeichen kannst du auch die hexadezimale oder dezimale Zahl angeben:

myRune := rune(0xbf)
myRune = 191
fmt.Printf("myRune Unicode character: %c\n", myRune)
// Output: myRune Unicode character: ¿

Runes und Strings

Strings in Go werden mit UTF-8 kodiert, das heißt, sie enthalten Unicode-Zeichen. Zeichen in Strings werden als 1, 2, 3 oder 4 Bytes gespeichert und kodiert, je nachdem, welches Unicode-Zeichen sie repräsentieren.

In Go werden Slices verwendet, um Sequenzen darzustellen, und diese Slices können mit range durchlaufen werden. Wenn wir über einen String iterieren, wandelt Go den String in eine Reihe von Runes um, von denen jede 4 Bytes groß ist (denk daran, der Typ rune ist ein Alias für ein int32!)

Auch wenn ein String nur ein Slice von Bytes ist, iteriert das Schlüsselwort range über die Runes eines Strings, nicht über seine Bytes.

In diesem Beispiel repräsentiert die Variable index den Startindex der Bytesequenz der aktuellen Rune und die Variable char repräsentiert die aktuelle Rune:

myString := "❗hello"
for index, char := range myString {
  fmt.Printf("Index: %d\tCharacter: %c\t\tCode Point: %U\n", index, char, char)
}
// Output:
// Index: 0	Character: ❗		Code Point: U+2757
// Index: 3	Character: h		Code Point: U+0068
// Index: 4	Character: e		Code Point: U+0065
// Index: 5	Character: l		Code Point: U+006C
// Index: 6	Character: l		Code Point: U+006C
// Index: 7	Character: o		Code Point: U+006F

Da Runes als 1, 2, 3 oder 4 Bytes gespeichert werden können, entspricht die Länge eines Strings nicht immer der Anzahl der Zeichen im String. Verwende die eingebaute Funktion len, um die Länge eines Strings in Bytes zu erhalten, und die Funktion utf8.RuneCountInString, um die Anzahl der Runes in einem String zu erhalten:

import "unicode/utf8"

myString := "❗hello"
stringLength := len(myString)
numberOfRunes := utf8.RuneCountInString(myString)

fmt.Printf("myString - Length: %d - Runes: %d\n", stringLength, numberOfRunes)
// Output: myString - Length: 8 - Runes: 6

Runes per Typumwandlung konvertieren

Du kannst einen Slice von Runes per Typumwandlung in einen String umwandeln:

myRuneSlice := []rune{'e', 'x', 'e', 'r', 'c', 'i', 's', 'm'}
myString := string(myRuneSlice)
fmt.Println(myString)
// Output: exercism

Genauso kannst du einen String per Typumwandlung in einen Slice von Runes umwandeln. Denk daran: Ohne Formatierungsverben ergibt das Ausgeben einer Rune ihren ganzzahligen (dezimalen) Wert:

myString := "exercism"
myRuneSlice := []rune(myString)
fmt.Println(myRuneSlice)
// Output: [101 120 101 114 99 105 115 109]