{"canonical_url":"https://engineer.company/es/glossary/utf-8/","content_markdown":"# UTF-8\n\n## Qué es\n\nUTF-8 es la codificación que convierte el texto Unicode en bytes. El estándar\nUnicode la define como la forma de codificación que guarda cada valor escalar\nUnicode, es decir, cualquier punto de código salvo los sustitutos reservados\npara UTF-16, en una secuencia de uno a cuatro bytes. Un carácter percibido por\nel usuario puede contener varios valores escalares y necesitar, por tanto, más\nbytes. Es una de las tres formas de codificación del estándar, junto con UTF-16\ny UTF-32, y la que exigen los estándares de la propia web. Como etiqueta, en una\npágina HTML o una cabecera HTTP, suele escribirse en minúsculas, utf-8, y a veces\nsin guion, utf8; el estándar Encoding acepta ambas y no distingue mayúsculas de\nminúsculas en las etiquetas.\n\nKen Thompson diseñó UTF-8 en septiembre de 1992 para el sistema operativo Plan\n9, siguiendo los criterios que había establecido Rob Pike. Durante su\nestandarización, la codificación se llamó FSS-UTF y después UTF-2, antes de\nrecibir su nombre actual. RFC 3629, la definición del IETF de 2003, la limita a\nlos puntos de código U+0000 a U+10FFFF, el mismo espacio de códigos de Unicode.\nCuando se escribió el RFC, la descripción de UTF-8 en ISO/IEC 10646 aún permitía\nsecuencias de hasta seis bytes; según el RFC y el estándar Unicode, ningún\nvalor escalar Unicode ocupa más de cuatro.\n\nLos bits iniciales de cada byte indican qué tipo de byte es. Un byte cuyo bit\nmás significativo es 0 representa un carácter por sí solo: uno de los 128\ncaracteres de ASCII. Un byte que empieza por 110, 1110 o 11110 inicia una\nsecuencia de dos, tres o cuatro bytes; cada byte posterior empieza por 10 y\nlleva otros seis bits del punto de código. El formato completo cabe en cuatro\nfilas, donde x representa los bits del punto de código:\n\n```text\nU+0000..U+007F     0xxxxxxx\nU+0080..U+07FF     110xxxxx 10xxxxxx\nU+0800..U+FFFF     1110xxxx 10xxxxxx 10xxxxxx\nU+10000..U+10FFFF  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx\n```\n\nLa fila de tres bytes excluye los sustitutos, U+D800 a U+DFFF: no son\ncaracteres y cualquier secuencia de bytes que codifique uno está mal formada.\n\nDe esa estructura se derivan cuatro propiedades, todas descritas por el\nestándar Unicode. UTF-8 es transparente para ASCII: los bytes 00 a 7F conservan\nsu significado de ASCII y nunca aparecen dentro de otro carácter. Es\nautosincronizable: resulta fácil distinguir un byte inicial de uno de\ncontinuación. Ordenar cadenas UTF-8 byte a byte produce el mismo orden que\nordenarlas por punto de código. Y no tiene orden de bytes, por lo que nunca\nsurge la cuestión del orden big-endian o little-endian que deben resolver\nUTF-16 y UTF-32.\n\n## Por qué importa\n\nLa web lo ha adoptado. El estándar WHATWG Encoding, la especificación que\nimplementan los navegadores para leer y escribir texto, identifica UTF-8 como\nla forma preferida de intercambiar texto Unicode y lo exige para protocolos y\nformatos nuevos, así como para formatos existentes usados en contextos nuevos.\nIndica a los autores que utilicen UTF-8 y lo identifiquen con la etiqueta utf-8.\nHTML sigue el mismo criterio: la codificación de un documento debe ser UTF-8,\nlo declare o no, y las herramientas de creación deben usar UTF-8 como opción\npredeterminada para documentos nuevos. Ya se espera que un producto que\npublique páginas, envíe JSON o acepte formularios enviados por POST lo utilice.\n\nSu diseño explica por qué se consolidó esa elección. Como los bytes ASCII\nnunca aparecen dentro de otro carácter, un programa escrito para ASCII sigue\nfuncionando con texto UTF-8: un analizador que separe por comas, barras o saltos\nde línea los encuentra exactamente donde están en una frase danesa o ucraniana,\ny nunca en medio de una å o una Ґ. Como un programa situado en cualquier\nposición encuentra el inicio de un valor escalar codificado buscando como\nmáximo cuatro bytes hacia atrás, y normalmente menos, la decodificación puede\nreanudarse en una secuencia posterior bien formada, en lugar de perder el resto\ndel archivo. Eso no garantiza exactamente un carácter de sustitución por cada\nbyte dañado. Buscar un valor escalar codificado completo nunca coincide con\nparte de otro. Como el orden binario es el de los puntos de código, una base\nde datos o un programa puede ordenar bytes UTF-8 sin decodificarlos. Ese orden\nes técnico: coloca å antes de æ y ø, mientras que un diccionario danés termina\nel alfabeto con æ, ø y å.\n\nEl coste está en el tamaño. El estándar Unicode considera UTF-8 razonablemente\ncompacto: la sintaxis ASCII y los idiomas occidentales ocupan mucho menos que\ncon UTF-16, mientras que el texto en sistemas de escritura asiáticos como los\ndel hindi, tailandés, chino, japonés y coreano ocupa bastante más. En el\nalfabeto danés básico, las letras ocupan un byte salvo æ, ø y å, que ocupan dos;\notras letras acentuadas pueden necesitar más. El ucraniano necesita dos bytes\npor cada letra cirílica y uno por los espacios, dígitos y signos de puntuación\nASCII, pero otra puntuación puede ocupar más. Por tanto, un campo medido en\nbytes admite aproximadamente la mitad de letras ucranianas que inglesas.\n\n## Cómo se aplica en la práctica\n\nLos bytes se ven con facilidad. Node.js tiene, igual que un navegador, el\n`TextEncoder` del estándar Encoding, que escribe una cadena como UTF-8:\n\n```js\nconst hex = (bytes) =\u003e\n  [...bytes].map((b) =\u003e b.toString(16).padStart(2, \"0\")).join(\" \");\nconst encoder = new TextEncoder();\nfor (const text of [\"A\", \"å\", \"Ґ\", \"€\", \"𐌂\"]) {\n  console.log(text, hex(encoder.encode(text)).toUpperCase());\n}\n```\n\nEjecutado en Node.js 25, imprime cada carácter y sus bytes en hexadecimal:\n\n```text\nA 41\nå C3 A5\nҐ D2 90\n€ E2 82 AC\n𐌂 F0 90 8C 82\n```\n\nLa letra A es ASCII y conserva su único byte. La å danesa es U+00E5, que\nnecesita ocho bits, uno más que los siete que ofrece un solo byte, de modo que\nusa el patrón de dos bytes. Su valor de once bits, 00011100101, se divide en\n00011 y 100101; el byte inicial es 110 seguido de 00011, que da C3, y el de\ncontinuación, 10 seguido de 100101, que da A5. La Ґ ucraniana, U+0490, ocupa\ndos bytes del mismo modo; el símbolo del euro ocupa tres y la letra del antiguo alfabeto\nitálico 𐌂, situada más allá de U+FFFF, cuatro. El primer byte de cada secuencia\nanuncia su longitud: C3 y D2 empiezan por 110, E2 por 1110 y F0 por 11110.\n\nEste sitio escribe todas las páginas en UTF-8 y lo declara donde exige HTML.\nEl primer elemento de la cabecera de cada página es `\u003cmeta charset=\"utf-8\"\u003e`,\ncon la etiqueta utf-8 que prescribe el estándar Encoding y claramente dentro de\nlos primeros 1.024 bytes, donde HTML exige que figure. La\n[página de créditos](/es/credits/) tiene una sección de comprobaciones externas,\nninguna propia: cada una ejecuta una prueba en directo, en lugar de aceptar sin\nmás lo que afirmamos. Una de ellas es W3C Internationalization Checker, que lee\nlas declaraciones de idioma y codificación que permiten que cada versión\nlingüística de este sitio resulte legible para su público.\n\n## Dónde surgen los problemas\n\n**Un límite de bytes corta un carácter por la mitad.** Una columna, un campo de\nmensaje o un búfer medido en bytes puede terminar en medio de una secuencia.\nEl nombre Ærø tiene tres caracteres y cinco bytes; un límite de cuatro conserva\nÆ, r y el primer byte de ø:\n\n```js\nconst bytes = new TextEncoder().encode(\"Ærø\");\nconst cut = new TextDecoder().decode(bytes.slice(0, 4));\nconsole.log(bytes.length, [...cut].map((c) =\u003e c.codePointAt(0).toString(16)));\nconsole.log(new TextEncoder().encodeInto(\"Ærø\", new Uint8Array(4)));\n```\n\n```text\n5 [ 'c6', '72', 'fffd' ]\n{ read: 2, written: 3 }\n```\n\nEl byte inicial huérfano se decodifica como U+FFFD, el carácter de sustitución,\npor lo que el nombre guardado termina con un marcador donde estaba la ø.\nCorte en un límite de valor escalar Unicode. `encodeInto`, en la última línea,\nlo hace por sí mismo: con espacio para cuatro bytes, solo escribe los tres de\nÆ y r, e indica en `read` cuánto tomó de la cadena, contado en unidades UTF-16.\nEl código que recorta bytes que ya tiene puede retroceder sobre los bytes de\ncontinuación, que empiezan por 10, hasta el byte inicial, y cortar allí.\nEso conserva UTF-8 bien formado; para preservar además un carácter completo tal\ncomo lo percibe el usuario, también hay que respetar los límites de los grupos\nde grafemas.\n\n**El archivo comienza con una marca de orden de bytes.** UTF-8 no tiene orden\nde bytes y no necesita marca, pero un conversor que transforma UTF-16 con marca\nde orden de bytes en UTF-8 convierte la marca en los tres bytes EF BB BF.\nEl estándar Unicode no los exige, dice que su presencia no afecta a la\nconformidad y no los recomienda como firma de UTF-8. Los lectores discrepan en\ncómo tratarlos. Aquí, el archivo bom.json contiene esos tres bytes seguidos de\n`{\"name\":\"Ærø\"}`:\n\n```js\nimport { readFileSync } from \"node:fs\";\n\nconst text = readFileSync(\"bom.json\", \"utf8\");\nconsole.log(text.codePointAt(0).toString(16));\ntry {\n  JSON.parse(text);\n} catch (error) {\n  console.log(error.name);\n}\nconsole.log(JSON.parse(new TextDecoder().decode(readFileSync(\"bom.json\"))));\n```\n\n```text\nfeff\nSyntaxError\n{ name: 'Ærø' }\n```\n\nEl `readFileSync` de Node conserva la marca como el carácter U+FEFF y\n`JSON.parse` rechaza el texto por ese motivo. `TextDecoder` sigue el estándar\nEncoding, retira la marca y permite analizar correctamente los mismos bytes.\nEn un navegador, la marca tiene aún más alcance: el estándar Encoding le da\nprioridad sobre cualquier otra indicación, incluida la cabecera HTTP\n`Content-Type`. Escriba UTF-8 sin marca y, cuando lleguen archivos de otros\nsistemas, decodifíquelos con un decodificador que la retire, o elimine un U+FEFF\ninicial antes del análisis.\n\n**Una comprobación lee los bytes antes de decodificarlos.** RFC 3629 describe\nun analizador que comprueba la entrada codificada y rechaza los bytes\n2F 2E 2E 2F, el paso de ruta \"/../\", pero deja pasar 2F C0 AE 2E 2F, donde\nC0 AE es una representación ilegal de dos bytes de un punto, que el analizador\nacaba interpretando como un único punto. El RFC registra que un virus que se propagó ampliamente por servidores web\nen 2001 usó precisamente este truco. Desde Unicode 3.1, estas formas que no\nusan la representación más corta están mal formadas, y los bytes C0, C1 y\nF5 a FF nunca aparecen en UTF-8 válido. Un decodificador conforme, incluido\n`TextDecoder`, transforma esos cinco bytes en una barra, dos U+FFFD y \"./\",\npor lo que ya no queda ningún \"/../\" que pueda burlar la comprobación. El\nestándar Unicode es igual de estricto con lo que sigue a un error: un\ndecodificador que se traga los bytes válidos posteriores a un byte inicial\nincorrecto no es conforme y permite ataques. `TextDecoder` convierte los bytes\nC2 41 42 en U+FFFD seguido de AB. Decodifique primero con el decodificador de la\npropia plataforma; después compruebe el texto decodificado. Nunca escriba a mano\nun decodificador UTF-8 ni un patrón de bytes que lo sustituya.\n\n**La sustitución oculta el daño.** Un decodificador sustituye de forma\npredeterminada cada secuencia incorrecta por U+FFFD y continúa. Eso es adecuado\npara mostrar una página, pero no para importar datos: el texto parece casi\nnormal, la copia guardada ha perdido los bytes originales y quien lo envió\nnunca descubre dónde se dañó el archivo. El estándar Encoding define dos modos\nde error para decodificar, «replacement» y «fatal»; para identificadores y\nsecuencias de bytes dentro de un formato o protocolo, deja que otros estándares\nelijan un decodificador que falle en lugar de sustituir. En JavaScript,\n`new TextDecoder(\"utf-8\", { fatal: true })` lanza un `TypeError` para el nombre\ncortado del ejemplo, en lugar de devolverlo. Use el modo fatal siempre que el\ntexto se almacene, se firme o se compare; rechace la entrada con un mensaje que\npermita corregir el problema y reserve la sustitución para la visualización.\n\n**La declaración llega tarde, falta o es incorrecta.** HTML exige que el\nelemento que declara la codificación esté completo dentro de los primeros\n1.024 bytes del documento. Exige una declaración incluso si todos los\ncaracteres son ASCII, porque el navegador necesita una codificación para lo que\nse escribe en los formularios y para las URL que construyen los scripts.\nUna etiqueta que parece inocua también puede ser incorrecta: en el estándar\nEncoding, \"ascii\", \"latin1\" e \"iso-8859-1\" son etiquetas de windows-1252, por lo\nque una página declarada como ASCII se lee como windows-1252. Ponga\n`\u003cmeta charset=\"utf-8\"\u003e` al principio de la cabecera, envíe\n`Content-Type: text/html; charset=utf-8` con cada página y considere un defecto\ncualquier otra etiqueta en cualquiera de esos lugares.\n\n## Lecturas adicionales\n\n- [The Unicode Standard, capítulo 3: Conformance](https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-3/#G27817)\n  — la definición de UTF-8, la tabla de secuencias de bytes bien formadas, la\n  marca de orden de bytes y cómo debe tratar un conversor la entrada mal formada.\n- [The Unicode Standard, capítulo 2: General Structure](https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-2/)\n  — por qué UTF-8 es transparente para ASCII, autosincronizable y carece de orden\n  de bytes, y cómo se compara su tamaño con UTF-16.\n- [RFC 3629: UTF-8, a transformation format of ISO 10646](https://www.rfc-editor.org/rfc/rfc3629)\n  — la definición del IETF, su historia desde Plan 9 y las consideraciones de\n  seguridad del ataque con una codificación no mínima de la ruta.\n- [Encoding Standard](https://encoding.spec.whatwg.org/) — la especificación\n  WHATWG que siguen los navegadores: por qué se exige UTF-8, cómo trata la\n  decodificación la marca de orden de bytes y los errores, y las interfaces\n  `TextEncoder` y `TextDecoder`.\n- [HTML: Specifying the document's character encoding](https://html.spec.whatwg.org/multipage/semantics.html#charset)\n  — qué debe decir una declaración, dónde debe aparecer y por qué la necesita\n  incluso una página escrita solo en ASCII.\n\n\u003chttps://engineer.company/es/glossary/utf-8/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"UTF-8: valores escalares en uno a cuatro bytes, por qué la web lo exige y cinco fallos que dañan el texto por cortes, marcas sueltas o bytes incorrectos.","formats":{"gemtext":"https://engineer.company/es/glossary/utf-8/index.gmi","gopher":"https://engineer.company/es/glossary/utf-8/gophermap","html":"https://engineer.company/es/glossary/utf-8/","json":"https://engineer.company/es/glossary/utf-8/index.json","markdown":"https://engineer.company/es/glossary/utf-8/index.md","pdf":"https://engineer.company/es/glossary/utf-8/index.pdf"},"kind":"page","language":"es","title":"¿Qué es UTF-8?","url":"https://engineer.company/es/glossary/utf-8/","version":1}