Rune y byte en Golang: los strings UTF-8 explicados

Un string de Go es una secuencia de bytes, y el código fuente y los literales de string de Go están en UTF-8. Un byte es uno de esos bytes. Un rune es un carácter Unicode (un code point), que UTF-8 guarda en 1 a 4 bytes. Casi toda la confusión con los strings en Go viene de mezclar los dos:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "語Go"

	fmt.Println("bytes:", len(s))
	fmt.Println("runes:", utf8.RuneCountInString(s))

	fmt.Println("byte loop:")
	for i := 0; i < len(s); i++ {
		fmt.Printf("  %d: %d\n", i, s[i])
	}

	fmt.Println("range loop:")
	for i, r := range s {
		fmt.Printf("  %d: %c (%d)\n", i, r, r)
	}
}

語 ocupa tres bytes en UTF-8, así que "語Go" son 5 bytes pero 3 runes. El bucle con índice ve cinco bytes, y los bytes 0, 1 y 2 no significan nada por separado. El bucle range decodifica UTF-8 y produce tres runes en los índices 0, 3 y 4: i es siempre un desplazamiento en bytes, no un recuento de caracteres.

byte y rune son alias

Como son alias, un byte es un uint8 y un rune es un int32; no hace falta conversión entre el alias y su tipo subyacente. Las comillas simples crean un rune y las dobles un string. 'ab' es un error de compilación, porque un literal rune contiene exactamente un carácter.

Los runes son números, así que puedes hacer aritmética con ellos:

package main

import (
	"fmt"
	"unicode"
)

func main() {
	r := 'a'
	fmt.Println(r, string(r))
	fmt.Println(string(r + 1))
	fmt.Println('7'-'0', unicode.IsDigit('7'))
	fmt.Println(unicode.ToUpper('é') == 'É', string(unicode.ToUpper('é')))
	fmt.Printf("%c %U %q\n", '世', '世', '世')
}

'7' - '0' es la forma clásica de convertir un carácter de dígito en su valor. El paquete unicode clasifica runes (IsLetter, IsDigit, IsSpace, IsUpper) y cambia mayúsculas y minúsculas correctamente en letras que no son ASCII. %c imprime un rune como carácter, %U en la forma U+4E16 y %q como literal rune entre comillas.

Cómo guarda UTF-8 los caracteres

El texto ASCII es idéntico en UTF-8, y por eso el código basado en bytes suele funcionar en las pruebas y romperse con el primer nombre con tilde. El paquete unicode/utf8 trabaja directamente con la codificación:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	for _, s := range []string{"a", "é", "€", "🙂"} {
		r, size := utf8.DecodeRuneInString(s)
		fmt.Printf("%s  U+%04X  %d bytes  % x\n", s, r, size, []byte(s))
	}

	fmt.Println(utf8.ValidString("ok"), utf8.ValidString("\xff"))
	fmt.Println(utf8.RuneLen('語'))
}

% x (con un espacio) imprime los bytes en hexadecimal separados por espacios. utf8.ValidString informa de si un string es UTF-8 válido. Los strings de Go pueden contener cualquier byte, no solo UTF-8 válido; cuando range encuentra un byte no válido, produce utf8.RuneError (U+FFFD, el carácter de sustitución) y avanza un byte.

Convertir entre string, []byte y []rune

package main

import "fmt"

func reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}

func main() {
	s := "héllo, 世界"

	b := []byte(s)
	r := []rune(s)
	fmt.Println(len(s), len(b), len(r))

	fmt.Println(reverse(s))

	// first 7 characters, not bytes
	fmt.Println(string(r[:7]))

	// edit bytes, then convert back
	b[0] = 'H'
	fmt.Println(string(b))
}

Invertir por bytes convertiría 世界 en UTF-8 no válido, y por eso reverse trabaja con runes. Ni siquiera los runes lo cuentan todo: un carácter como é también se puede escribir como e más un acento combinable, que son dos runes. Para los caracteres que ve el usuario (grapheme clusters), usa una librería como github.com/rivo/uniseg.

Cada conversión copia, porque los strings son inmutables y los slices no. En código caliente, evita convertir de ida y vuelta; el compilador optimiza algunos casos (como string(b) usado como clave de map o en una comparación) para saltarse la copia.

Indexar da un byte

s[i] devuelve un byte, y s[i:j] recorta por desplazamientos en bytes:

s := "café"
fmt.Println(s[3])            // 195: the first byte of é
fmt.Println(string(s[3]))    // "Ã": that byte read as a code point
fmt.Println(s[:3])           // "caf"
fmt.Println(s[:4])           // "caf\xc3": half of é, invalid UTF-8

string(s[3]) es una trampa: convertir un solo byte a string lo trata como el code point 195, que es Ã, no como el propio byte. Para encontrar los límites de los caracteres, usa range, la familia strings.Index (que devuelve desplazamientos en bytes que siempre caen en un límite) o utf8.DecodeRuneInString.

El paquete bytes

bytes replica strings para []byte: bytes.Contains, bytes.Split, bytes.Fields, bytes.TrimSpace, bytes.Equal, bytes.ToUpper, etc. Úsalo cuando los datos llegan como bytes (contenido de archivos, bodies HTTP, buffers de red), para no convertirlos a string y de vuelta:

package main

import (
	"bytes"
	"fmt"
)

func main() {
	data := []byte("name=ana\nrole=admin\n")

	for _, line := range bytes.Split(bytes.TrimSpace(data), []byte("\n")) {
		key, value, _ := bytes.Cut(line, []byte("="))
		fmt.Printf("%s -> %s\n", key, value)
	}

	var buf bytes.Buffer
	buf.WriteString("hello, ")
	buf.Write([]byte("bytes"))
	buf.WriteByte('!')
	fmt.Println(buf.String(), buf.Len())

	fmt.Println(bytes.Equal([]byte("a"), []byte("a")))
}

bytes.Buffer es un buffer de bytes que crece y que implementa io.Reader e io.Writer. Es la herramienta adecuada cuando escribes y lees bytes; para construir un string, strings.Builder es algo más barato. Compara slices de bytes con bytes.Equal, porque == no funciona con slices.

Cuál elegir

• Texto que muestras, comparas o buscas: mantenlo como string, y usa range cuando lo recorras carácter a carácter.
• Posiciones de caracteres, invertir, truncar a n caracteres: convierte a []rune.
• I/O, hashing, codificación, protocolos binarios: usa []byte y el paquete bytes.
• Un solo carácter: un rune. Un solo byte en bruto: un byte.