Runas en

Acerca de Runas

El tipo rune en Go es un alias de int32. Dado este tipo int32 subyacente, el tipo rune contiene 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 asignando un número único a cada uno. Ese número único se llama punto de código Unicode. Unicode busca representar todos los caracteres del mundo, incluidos diversos alfabetos, números, símbolos e incluso emoji, como puntos de código Unicode.

En Go, el tipo rune representa un solo punto de código Unicode.

La siguiente tabla contiene ejemplos de caracteres Unicode junto con su punto de código Unicode y sus valores decimales:

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 contener hasta 4 bytes de datos. Por eso el tipo rune es un alias de int32: un tipo int32 es capaz de contener hasta 4 bytes de datos.

Los archivos de código fuente de Go se codifican con UTF-8.

Uso de 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 dará como resultado int32:

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

De manera similar, imprimir el valor de una rune dará 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

Además de definir una rune colocando el carácter entre comillas simples, también puedes especificar el número hexadecimal o decimal:

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

Runes y strings

Los strings en Go se codifican con UTF-8, lo que significa que contienen caracteres Unicode. Los caracteres de los strings se almacenan y se 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 esos slices se pueden recorrer con range. Cuando recorremos un string, Go lo convierte en una serie de runes, y cada una ocupa 4 bytes (recuerda, ¡el tipo rune es un alias de int32!).

Aunque un string es solo un slice de bytes, la palabra clave range recorre las runes del string, no 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 como 1, 2, 3 o 4 bytes, la longitud de un string no siempre es igual al número de caracteres que contiene. 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

Conversión de tipos de runes

Un slice de runes se puede convertir a un string:

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

De manera similar, un string se puede convertir a un slice de runes. Recuerda: sin verbos de formato, imprimir una rune da como resultado su valor entero (decimal):

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