El tipo rune en Go es un alias de int32.
Dado este tipo int32 subyacente, el tipo rune almacena un valor entero con signo de 32 bits.
Sin embargo, a diferencia de un tipo int32, el valor entero que se almacena en un tipo rune representa un solo carácter Unicode.
Unicode y puntos de código Unicode
Unicode es un superconjunto de ASCII que representa los caracteres asignándole un número único a cada carácter.
A este número único se le llama punto de código Unicode.
Unicode busca representar todos los caracteres del mundo, incluidos los distintos alfabetos, números, símbolos e incluso emojis, como puntos de código Unicode.
En Go, el tipo rune representa un solo punto de código Unicode.
La siguiente tabla contiene caracteres Unicode de ejemplo junto con su punto de código Unicode y sus valores decimales:
| Carácter Unicode |
Punto de código Unicode |
Valor decimal |
| 0 |
U+0030 |
48 |
| A |
U+0041 |
65 |
| a |
U+0061 |
97 |
| ¿ |
U+00BF |
191 |
| π |
U+03C0 |
960 |
| 🧠 |
U+1F9E0 |
129504 |
UTF-8
UTF-8 es una codificación de caracteres de ancho variable que se usa para codificar cada punto de código Unicode como 1, 2, 3 o 4 bytes.
Como un punto de código Unicode se puede codificar en un máximo de 4 bytes, el tipo rune necesita poder almacenar hasta 4 bytes de datos.
Por eso el tipo rune es un alias de int32: un tipo int32 es capaz de almacenar hasta 4 bytes de datos.
Los archivos de código fuente de Go se codifican con UTF-8.
Uso de las runes
Las variables de tipo rune se declaran colocando un carácter entre comillas simples:
myRune := '¿'
Como rune es solo un alias de int32, imprimir el tipo de una rune da como resultado int32:
myRune := '¿'
fmt.Printf("myRune type: %T\n", myRune)
// Output: myRune type: int32
De manera similar, imprimir el valor de una rune da como resultado su valor entero (decimal):
myRune := '¿'
fmt.Printf("myRune value: %v\n", myRune)
// Output: myRune value: 191
Para imprimir el carácter Unicode que representa la rune, usa el verbo de formato %c:
myRune := '¿'
fmt.Printf("myRune Unicode character: %c\n", myRune)
// Output: myRune Unicode character: ¿
Para imprimir el punto de código Unicode que representa la rune, usa el verbo de formato %U:
myRune := '¿'
fmt.Printf("myRune Unicode code point: %U\n", myRune)
// Output: myRune Unicode code point: U+00BF
Runes y strings
Los strings en Go se codifican con UTF-8, lo que significa que contienen caracteres Unicode.
Los caracteres de un string se almacenan y codifican como 1, 2, 3 o 4 bytes, según el carácter Unicode que representen.
En Go, se usan slices para representar secuencias y se puede iterar sobre estos slices usando range.
Cuando iteramos sobre un string, Go convierte el string en una serie de runes, y cada una ocupa 4 bytes (recuerda, ¡el tipo rune es un alias de un int32!).
Aunque un string es solo un slice de bytes, la palabra clave range itera sobre las runes de un string, no sobre sus bytes.
En este ejemplo, la variable index representa el índice inicial de la secuencia de bytes de la rune actual, y la variable char representa la rune actual:
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
Como las runes se pueden almacenar en 1, 2, 3 o 4 bytes, la longitud de un string no siempre es igual al número de caracteres del string.
Usa la función integrada len para obtener la longitud de un string en bytes y la función utf8.RuneCountInString para obtener el número de runes de un string:
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
Ejercicio de aprendizaje
