UTF-8

Qué es

UTF-8 es la codificación que convierte el texto Unicode en bytes. El
estándar Unicode la define como la forma de codificación que guarda
cada valor escalar Unicode, es decir, cualquier punto de código
salvo los sustitutos reservados para UTF-16, en una secuencia de uno
a cuatro bytes. Un carácter percibido por el usuario puede contener
varios valores escalares y necesitar, por tanto, más bytes. Es una
de las tres formas de codificación del estándar, junto con UTF-16 y
UTF-32, y la que exigen los estándares de la propia web. Como
etiqueta, en una página HTML o una cabecera HTTP, suele escribirse
en minúsculas, utf-8, y a veces sin guion, utf8; el estándar
Encoding acepta ambas y no distingue mayúsculas de minúsculas en las
etiquetas.

Ken Thompson diseñó UTF-8 en septiembre de 1992 para el sistema
operativo Plan

9, siguiendo los criterios que había establecido Rob Pike. Durante
su estandarización, la codificación se llamó FSS-UTF y después
UTF-2, antes de recibir su nombre actual. RFC 3629, la definición
del IETF de 2003, la limita a los puntos de código U+0000 a
U+10FFFF, el mismo espacio de códigos de Unicode. Cuando se escribió
el RFC, la descripción de UTF-8 en ISO/IEC 10646 aún permitía
secuencias de hasta seis bytes; según el RFC y el estándar Unicode,
ningún valor escalar Unicode ocupa más de cuatro.

Los bits iniciales de cada byte indican qué tipo de byte es. Un byte
cuyo bit más significativo es 0 representa un carácter por sí solo:
uno de los 128 caracteres de ASCII. Un byte que empieza por 110,
1110 o 11110 inicia una secuencia de dos, tres o cuatro bytes; cada
byte posterior empieza por 10 y lleva otros seis bits del punto de
código. El formato completo cabe en cuatro filas, donde x representa
los bits del punto de código:

```text
U+0000..U+007F     0xxxxxxx
U+0080..U+07FF     110xxxxx 10xxxxxx
U+0800..U+FFFF     1110xxxx 10xxxxxx 10xxxxxx
U+10000..U+10FFFF  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
```

La fila de tres bytes excluye los sustitutos, U+D800 a U+DFFF: no
son caracteres y cualquier secuencia de bytes que codifique uno está
mal formada.

De esa estructura se derivan cuatro propiedades, todas descritas por
el estándar Unicode. UTF-8 es transparente para ASCII: los bytes 00
a 7F conservan su significado de ASCII y nunca aparecen dentro de
otro carácter. Es autosincronizable: resulta fácil distinguir un
byte inicial de uno de continuación. Ordenar cadenas UTF-8 byte a
byte produce el mismo orden que ordenarlas por punto de código. Y no
tiene orden de bytes, por lo que nunca surge la cuestión del orden
big-endian o little-endian que deben resolver UTF-16 y UTF-32.

Por qué importa

La web lo ha adoptado. El estándar WHATWG Encoding, la
especificación que implementan los navegadores para leer y escribir
texto, identifica UTF-8 como la forma preferida de intercambiar
texto Unicode y lo exige para protocolos y formatos nuevos, así como
para formatos existentes usados en contextos nuevos. Indica a los
autores que utilicen UTF-8 y lo identifiquen con la etiqueta utf-8.
HTML sigue el mismo criterio: la codificación de un documento debe
ser UTF-8, lo declare o no, y las herramientas de creación deben
usar UTF-8 como opción predeterminada para documentos nuevos. Ya se
espera que un producto que publique páginas, envíe JSON o acepte
formularios enviados por POST lo utilice.

Su diseño explica por qué se consolidó esa elección. Como los bytes
ASCII nunca aparecen dentro de otro carácter, un programa escrito
para ASCII sigue funcionando con texto UTF-8: un analizador que
separe por comas, barras o saltos de línea los encuentra exactamente
donde están en una frase danesa o ucraniana, y nunca en medio de una
å o una Ґ. Como un programa situado en cualquier posición encuentra
el inicio de un valor escalar codificado buscando como máximo cuatro
bytes hacia atrás, y normalmente menos, la decodificación puede
reanudarse en una secuencia posterior bien formada, en lugar de
perder el resto del archivo. Eso no garantiza exactamente un
carácter de sustitución por cada byte dañado. Buscar un valor
escalar codificado completo nunca coincide con parte de otro. Como
el orden binario es el de los puntos de código, una base de datos o
un programa puede ordenar bytes UTF-8 sin decodificarlos. Ese orden
es técnico: coloca å antes de æ y ø, mientras que un diccionario
danés termina el alfabeto con æ, ø y å.

El coste está en el tamaño. El estándar Unicode considera UTF-8
razonablemente compacto: la sintaxis ASCII y los idiomas
occidentales ocupan mucho menos que con UTF-16, mientras que el
texto en sistemas de escritura asiáticos como los del hindi,
tailandés, chino, japonés y coreano ocupa bastante más. En el
alfabeto danés básico, las letras ocupan un byte salvo æ, ø y å, que
ocupan dos; otras letras acentuadas pueden necesitar más. El
ucraniano necesita dos bytes por cada letra cirílica y uno por los
espacios, dígitos y signos de puntuación ASCII, pero otra puntuación
puede ocupar más. Por tanto, un campo medido en bytes admite
aproximadamente la mitad de letras ucranianas que inglesas.

Cómo se aplica en la práctica

Los bytes se ven con facilidad. Node.js tiene, igual que un
navegador, el `TextEncoder` del estándar Encoding, que escribe una
cadena como UTF-8:

```js
const hex = (bytes) =>
  [...bytes].map((b) => b.toString(16).padStart(2, "0")).join(" ");
const encoder = new TextEncoder();
for (const text of ["A", "å", "Ґ", "€", "𐌂"]) {
  console.log(text, hex(encoder.encode(text)).toUpperCase());
}
```

Ejecutado en Node.js 25, imprime cada carácter y sus bytes en
hexadecimal:

```text
A 41
å C3 A5
Ґ D2 90
€ E2 82 AC
𐌂 F0 90 8C 82
```

La letra A es ASCII y conserva su único byte. La å danesa es U+00E5,
que necesita ocho bits, uno más que los siete que ofrece un solo
byte, de modo que usa el patrón de dos bytes. Su valor de once bits,
00011100101, se divide en

00011 y 100101; el byte inicial es 110 seguido de 00011, que da C3,
y el de continuación, 10 seguido de 100101, que da A5. La Ґ
ucraniana, U+0490, ocupa dos bytes del mismo modo; el símbolo del
euro ocupa tres y la letra del antiguo alfabeto itálico 𐌂, situada
más allá de U+FFFF, cuatro. El primer byte de cada secuencia anuncia
su longitud: C3 y D2 empiezan por 110, E2 por 1110 y F0 por 11110.

Este sitio escribe todas las páginas en UTF-8 y lo declara donde
exige HTML. El primer elemento de la cabecera de cada página es
`<meta charset="utf-8">`, con la etiqueta utf-8 que prescribe el
estándar Encoding y claramente dentro de los primeros 1.024 bytes,
donde HTML exige que figure. La página de créditos tiene una sección
de comprobaciones externas, ninguna propia: cada una ejecuta una
prueba en directo, en lugar de aceptar sin más lo que afirmamos. Una
de ellas es W3C Internationalization Checker, que lee las
declaraciones de idioma y codificación que permiten que cada versión
lingüística de este sitio resulte legible para su público.

Dónde surgen los problemas

Un límite de bytes corta un carácter por la mitad. Una columna, un
campo de mensaje o un búfer medido en bytes puede terminar en medio
de una secuencia. El nombre Ærø tiene tres caracteres y cinco bytes;
un límite de cuatro conserva Æ, r y el primer byte de ø:

```js
const bytes = new TextEncoder().encode("Ærø");
const cut = new TextDecoder().decode(bytes.slice(0, 4));
console.log(bytes.length, [...cut].map((c) => c.codePointAt(0).toString(16)));
console.log(new TextEncoder().encodeInto("Ærø", new Uint8Array(4)));
```

```text
5 [ 'c6', '72', 'fffd' ]
{ read: 2, written: 3 }
```

El byte inicial huérfano se decodifica como U+FFFD, el carácter de
sustitución, por lo que el nombre guardado termina con un marcador
donde estaba la ø. Corte en un límite de valor escalar Unicode.
`encodeInto`, en la última línea, lo hace por sí mismo: con espacio
para cuatro bytes, solo escribe los tres de Æ y r, e indica en
`read` cuánto tomó de la cadena, contado en unidades UTF-16. El
código que recorta bytes que ya tiene puede retroceder sobre los
bytes de continuación, que empiezan por 10, hasta el byte inicial, y
cortar allí. Eso conserva UTF-8 bien formado; para preservar además
un carácter completo tal como lo percibe el usuario, también hay que
respetar los límites de los grupos de grafemas.

El archivo comienza con una marca de orden de bytes. UTF-8 no tiene
orden de bytes y no necesita marca, pero un conversor que transforma
UTF-16 con marca de orden de bytes en UTF-8 convierte la marca en
los tres bytes EF BB BF. El estándar Unicode no los exige, dice que
su presencia no afecta a la conformidad y no los recomienda como
firma de UTF-8. Los lectores discrepan en cómo tratarlos. Aquí, el
archivo bom.json contiene esos tres bytes seguidos de
`{"name":"Ærø"}`:

```js
import { readFileSync } from "node:fs";

const text = readFileSync("bom.json", "utf8");
console.log(text.codePointAt(0).toString(16));
try {
  JSON.parse(text);
} catch (error) {
  console.log(error.name);
}
console.log(JSON.parse(new TextDecoder().decode(readFileSync("bom.json"))));
```

```text
feff
SyntaxError
{ name: 'Ærø' }
```

El `readFileSync` de Node conserva la marca como el carácter U+FEFF
y `JSON.parse` rechaza el texto por ese motivo. `TextDecoder` sigue
el estándar Encoding, retira la marca y permite analizar
correctamente los mismos bytes. En un navegador, la marca tiene aún
más alcance: el estándar Encoding le da prioridad sobre cualquier
otra indicación, incluida la cabecera HTTP `Content-Type`. Escriba
UTF-8 sin marca y, cuando lleguen archivos de otros sistemas,
decodifíquelos con un decodificador que la retire, o elimine un
U+FEFF inicial antes del análisis.

Una comprobación lee los bytes antes de decodificarlos. RFC 3629
describe un analizador que comprueba la entrada codificada y rechaza
los bytes

2F 2E 2E 2F, el paso de ruta "/../", pero deja pasar 2F C0 AE 2E 2F,
donde C0 AE es una representación ilegal de dos bytes de un punto,
que el analizador acaba interpretando como un único punto. El RFC
registra que un virus que se propagó ampliamente por servidores web
en 2001 usó precisamente este truco. Desde Unicode 3.1, estas formas
que no usan la representación más corta están mal formadas, y los
bytes C0, C1 y F5 a FF nunca aparecen en UTF-8 válido. Un
decodificador conforme, incluido `TextDecoder`, transforma esos
cinco bytes en una barra, dos U+FFFD y "./", por lo que ya no queda
ningún "/../" que pueda burlar la comprobación. El estándar Unicode
es igual de estricto con lo que sigue a un error: un decodificador
que se traga los bytes válidos posteriores a un byte inicial
incorrecto no es conforme y permite ataques. `TextDecoder` convierte
los bytes C2 41 42 en U+FFFD seguido de AB. Decodifique primero con
el decodificador de la propia plataforma; después compruebe el texto
decodificado. Nunca escriba a mano un decodificador UTF-8 ni un
patrón de bytes que lo sustituya.

La sustitución oculta el daño. Un decodificador sustituye de forma
predeterminada cada secuencia incorrecta por U+FFFD y continúa. Eso
es adecuado para mostrar una página, pero no para importar datos: el
texto parece casi normal, la copia guardada ha perdido los bytes
originales y quien lo envió nunca descubre dónde se dañó el archivo.
El estándar Encoding define dos modos de error para decodificar,
«replacement» y «fatal»; para identificadores y secuencias de bytes
dentro de un formato o protocolo, deja que otros estándares elijan
un decodificador que falle en lugar de sustituir. En JavaScript,
`new TextDecoder("utf-8", { fatal: true })` lanza un `TypeError`
para el nombre cortado del ejemplo, en lugar de devolverlo. Use el
modo fatal siempre que el texto se almacene, se firme o se compare;
rechace la entrada con un mensaje que permita corregir el problema y
reserve la sustitución para la visualización.

La declaración llega tarde, falta o es incorrecta. HTML exige que el
elemento que declara la codificación esté completo dentro de los
primeros

1.024 bytes del documento. Exige una declaración incluso si todos
los caracteres son ASCII, porque el navegador necesita una
codificación para lo que se escribe en los formularios y para las
URL que construyen los scripts. Una etiqueta que parece inocua
también puede ser incorrecta: en el estándar Encoding, "ascii",
"latin1" e "iso-8859-1" son etiquetas de windows-1252, por lo que
una página declarada como ASCII se lee como windows-1252. Ponga
`<meta charset="utf-8">` al principio de la cabecera, envíe
`Content-Type: text/html; charset=utf-8` con cada página y considere
un defecto cualquier otra etiqueta en cualquiera de esos lugares.

Lecturas adicionales

  * The Unicode Standard, capítulo 3: Conformance — la definición de
UTF-8, la tabla de secuencias de bytes bien formadas, la marca de
orden de bytes y cómo debe tratar un conversor la entrada mal
formada.

  * The Unicode Standard, capítulo 2: General Structure — por qué
UTF-8 es transparente para ASCII, autosincronizable y carece de
orden de bytes, y cómo se compara su tamaño con UTF-16.

  * RFC 3629: UTF-8, a transformation format of ISO 10646 — la
definición del IETF, su historia desde Plan 9 y las consideraciones
de seguridad del ataque con una codificación no mínima de la ruta.

  * Encoding Standard — la especificación WHATWG que siguen los
navegadores: por qué se exige UTF-8, cómo trata la decodificación la
marca de orden de bytes y los errores, y las interfaces
`TextEncoder` y `TextDecoder`.

  * HTML: Specifying the document's character encoding — qué debe
decir una declaración, dónde debe aparecer y por qué la necesita
incluso una página escrita solo en ASCII.

hEsta página en la web	URL:https://engineer.company/es/glossary/utf-8/	engineer.company	70
