Inspector de Caracteres Unicode

Inspecciona cadenas Unicode carácter por carácter en tu navegador.

Sin subidasSin registroResultados instantáneos
Unicode y UTF-8/16Ancho cero y homógrafos100% Local • Cero Subidas
Inspeccionar caracteres
Motor local listoEspacio de trabajo 100% privado en el navegador • Sin subidas a la nube
100 % Privado • Sin cargas de archivos a servidores

¿Por qué usar Inspector de Caracteres Unicode gratis en Utiliome?

Diseñado para máxima privacidad, ejecución instantánea y sin fricción. Sin suscripciones ni registros.

Detección de Invisibles y Controles Bidi

Revela caracteres de control y formato no imprimibles como U+200B ZWSP, U+FEFF BOM, U+00A0 NBSP, U+00AD Soft Hyphen y controles bidireccionales Trojan Source (U+202A a U+202E, U+2066 a U+2069).

Desglose de Bytes UTF-8 y UTF-16LE/BE

Muestra secuencias exactas de bytes UTF-8 en hexadecimal (de 1 a 4 bytes según RFC 3629) junto con unidades de código UTF-16LE y UTF-16BE, exponiendo pares sustitutos en planos suplementarios por encima de U+FFFF.

Métricas de Grafemas UAX #29 vs Unidades de Código

Compara clústeres de grafemas extendidos con valores escalares Unicode, unidades de código UTF-16 de JavaScript y longitud en bytes UTF-8 para diagnosticar errores al cortar cadenas y desbordamientos en bases de datos.

Diagnóstico de Homóglifos y Privacidad Local

Detecta caracteres visualmente confusos según UTS #39, como glifos cirílicos frente a latinos y puntuación tipográfica, 100 % en la memoria del navegador para que tus tokens, logs y código nunca salgan de tu dispositivo.

Utiliome vs Alternativas en la nube tradicionales

Compara nuestro motor local en WebAssembly frente a herramientas en la nube.

Característica Utiliome (Navegador local) Convertidores en la nube tradicionales
Detección de Invisibles y Controles Bidi Revela caracteres de control y formato no imprimibles como U+200B ZWSP, U+FEFF BOM, U+00A0 NBSP, U+00AD Soft Hyphen y controles bidireccionales Trojan Source (U+202A a U+202E, U+2066 a U+2069). Opciones limitadas sin personalización avanzada
Desglose de Bytes UTF-8 y UTF-16LE/BE Muestra secuencias exactas de bytes UTF-8 en hexadecimal (de 1 a 4 bytes según RFC 3629) junto con unidades de código UTF-16LE y UTF-16BE, exponiendo pares sustitutos en planos suplementarios por encima de U+FFFF. Requiere herramientas externas o ajustes manuales
Privacidad y Procesamiento 100% local en tu navegador (cero subidas al servidor) Sube los datos a servidores externos en la nube
Precio y Registro 100% gratis para siempre y sin crear cuenta Requiere registro de cuenta o suscripción de pago
Cómo funciona

Cómo usar Inspector de Caracteres Unicode en 3 sencillos pasos

Sin instalación de software. Todo funciona directamente dentro de tu navegador web.

1

Pega Texto o Arrastra un Archivo

Pega una cadena, identificador, entrada de log o sube un archivo UTF-8 que sospeches que contiene caracteres de ancho cero, secuencias de emojis rotas o longitudes de bytes inesperadas.

2

Inspecciona los Metadatos por Carácter

Revisa el punto de código escalar U+XXXX de cada carácter, su nombre oficial Unicode, Categoría General, bloque asignado, bytes hexadecimales en UTF-8 y UTF-16LE/BE, e insignias de advertencia de seguridad.

3

Aísla Anomalías o Copia el Resultado Limpio

Filtra directamente los caracteres de formato invisibles o los homóglifos confusos, elimina puntos de código no imprimibles no deseados o copia la tabla de inspección a nivel de bytes para tus reportes de bugs.

Inspección de Caracteres Ocultos, Pares Sustitutos y Homóglifos

Respuesta rápida: Pega cualquier cadena para descomponerla en valores escalares Unicode individuales, exponiendo caracteres invisibles como el espacio de ancho cero U+200B o la marca de orden de bytes U+FEFF BOM, secuencias de emojis ZWJ multipunto y homóglifos no ASCII junto con sus secuencias exactas de bytes UTF-8 y UTF-16.

Los fallos de análisis sintáctico (parsers), las discrepancias en firmas de webhooks y las búsquedas SQL fallidas suelen originarse en caracteres que se renderizan de forma idéntica —o completamente invisible— en emuladores de terminal y editores de código. Considera una variable de entorno copiada de un portal de documentación o mensaje de chat que parece visualmente idéntica a api_key=prod:

Visual rendering:  api_key=prod
String.length:     14 (expected 12)
UTF-8 byte length: 19 bytes (expected 12 bytes)

Al pasar esa cadena de 14 unidades por el Inspector de Caracteres Unicode, se descubren tres anomalías distintas ocultas dentro de un texto aparentemente ASCII plano: una marca de orden de bytes inicial (<BOM>), un homóglifo cirílico que reemplaza a la a latina y un espacio de ancho cero incrustado (<ZWSP>):

[
  {
    "index": 0,
    "badge": "<BOM>",
    "codePoint": "U+FEFF",
    "name": "ZERO WIDTH NO-BREAK SPACE",
    "category": "Cf (Format)",
    "block": "Arabic Presentation Forms-B",
    "utf8Hex": "EF BB BF",
    "utf16BE": "FE FF",
    "utf16LE": "FF FE",
    "warning": "Invisible zero-width format character"
  },
  {
    "index": 1,
    "glyph": "а",
    "codePoint": "U+0430",
    "name": "CYRILLIC SMALL LETTER A",
    "category": "Ll (Lowercase Letter)",
    "block": "Cyrillic",
    "utf8Hex": "D0 B0",
    "utf16BE": "04 30",
    "utf16LE": "30 04",
    "warning": "Confusable homoglyph for Latin U+0061 ('a')"
  },
  {
    "index": 2,
    "glyph": "p",
    "codePoint": "U+0070",
    "name": "LATIN SMALL LETTER P",
    "category": "Ll (Lowercase Letter)",
    "block": "Basic Latin",
    "utf8Hex": "70",
    "utf16BE": "00 70",
    "utf16LE": "70 00",
    "warning": null
  },
  {
    "index": 8,
    "badge": "<ZWSP>",
    "codePoint": "U+200B",
    "name": "ZERO WIDTH SPACE",
    "category": "Cf (Format)",
    "block": "General Punctuation",
    "utf8Hex": "E2 80 8B",
    "utf16BE": "20 0B",
    "utf16LE": "0B 20",
    "warning": "Invisible zero-width format character"
  }
]

El inspector también aclara por qué los emojis compuestos por múltiples puntos de código reportan longitudes tan diferentes según el entorno de ejecución. Al inspeccionar el único emoji visible de tecnólogo 👨💻, se revelan tres puntos de código escalares unidos por <ZWJ> (U+200D), que ocupan 5 unidades de código UTF-16 en JavaScript y 11 bytes en UTF-8:

Grapheme clusters (UAX #29): 1   -> [ "👨💻" ]
Unicode scalar code points:  3   -> U+1F468 (Man) + U+200D (<ZWJ>) + U+1F4BB (Laptop)
UTF-16 code units (.length): 5   -> D83D DC68 + 200D + D83D DCBB
UTF-8 encoded bytes:         11  -> F0 9F 91 A8 + E2 80 8D + F0 9F 92 BB

Mecánica de Codificación Unicode, Límites de Grafemas y Riesgos de Seguridad

Respuesta rápida: Unicode asigna 1.112.064 valores escalares válidos en 17 planos a codificaciones de ancho variable como UTF-8 (de 1 a 4 bytes según RFC 3629) o UTF-16 (2 o 4 bytes mediante pares sustitutos según RFC 2781). Las discrepancias entre clústeres de grafemas, formas de normalización canónica y controles bidi invisibles provocan errores en parsers y vulnerabilidades de seguridad.

Valores Escalares, Bits de Prefijo UTF-8 (RFC 3629) y Sustitutos UTF-16 (RFC 2781)

El espacio de códigos Unicode abarca desde U+0000 hasta U+10FFFF a lo largo de 17 planos de 65.536 puntos de código cada uno. Excluyendo las 2.048 posiciones sustitutas reservadas (U+D800 a U+DFFF), existen exactamente 1.112.064 valores escalares Unicode:

  • UTF-8 codifica el Latín Básico del Plano 0 (U+0000 a U+007F) en 1 byte (0xxxxxxx), de U+0080 a U+07FF en 2 bytes (110xxxxx 10xxxxxx), el resto de caracteres del Plano Multilingüe Básico o BMP (U+0800 a U+FFFF) en 3 bytes (1110xxxx 10xxxxxx 10xxxxxx), y los planos astrales suplementarios (U+10000 a U+10FFFF) en 4 bytes (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx). Dado que los bytes de continuación siempre comienzan con 10, UTF-8 es autosincronizable y nunca contiene bytes nulos (0x00) dentro de caracteres no nulos.
  • UTF-16 representa los valores escalares del BMP directamente como una unidad de código de 16 bits. A los caracteres desde U+10000 hasta U+10FFFF se les resta 0x10000 para obtener un desplazamiento de 20 bits (0x00000 a 0xFFFFF), dividiendo los 10 bits superiores en un sustituto alto/inicial (0xD800 a 0xDBFF) y los 10 bits inferiores en un sustituto bajo/final (0xDC00 a 0xDFFF). UTF-16BE serializa primero el byte más significativo (D8 3D DC 80), mientras que UTF-16LE invierte el orden de los bytes dentro de cada unidad de 16 bits (3D D8 80 DC).

Equivalencia Canónica (UAX #15) y Segmentación de Grafemas (UAX #29)

Un texto visualmente idéntico suele tener representaciones de bytes subyacentes distintas. Según el Anexo Estándar Unicode #15 (UAX #15), la letra é puede almacenarse en la Forma de Normalización C (NFC) como el carácter precompuesto U+00E9 (UTF-8 C3 A9) o en la Forma de Normalización D (NFD) como la base U+0065 (e) seguida de U+0301 (COMBINING ACUTE ACCENT, Categoría General Mn, UTF-8 65 CC 81). Los sistemas de archivos de macOS normalizan los nombres de archivo hacia formas NFD, mientras que Linux, Windows y los envíos de formularios de navegadores usan NFC por defecto, lo que provoca que las comparaciones ingenuas de cadenas byte a byte, las búsquedas de claves de objetos en S3 y las verificaciones HMAC fallen si no se normalizan previamente.

Del mismo modo, cortar cadenas por índice UTF-16 (str.slice(0, 10)) puede separar un sustituto alto de su sustituto bajo (produciendo sustitutos huérfanos que se serializan como caracteres de reemplazo U+FFFD en UTF-8) o separar un carácter base de sus signos diacríticos combinados, selectores de variación (U+FE0E, U+FE0F) o indicadores de banderas regionales (U+1F1E6 a U+1F1FF). Los caracteres percibidos por el usuario deben segmentarse siguiendo los límites de clústeres de grafemas extendidos de UAX #29.

Trojan Source (`CVE-2021-42574`) y Caracteres Confusos de UTS #39

Dos clases de caracteres en Unicode representan riesgos agudos para la seguridad de las aplicaciones:

  1. Controles de Anulación Bidireccional (Cf): Los puntos de código U+202A a U+202E (<LRE>, <RLE>, <PDF>, <LRO>, <RLO>) y los aislantes U+2066 a U+2069 (<LRI>, <RLI>, <FSI>, <PDI>) instruyen a los motores de renderizado de texto para que inviertan el orden de visualización sin alterar el orden lógico en memoria. Los atacantes utilizan controles bidi sin cerrar para camuflar comprobaciones condicionales activas dentro de comentarios o literales de cadena (CVE-2021-42574).
  2. Suplantación mediante Homóglifos (UTS #39): Los caracteres visualmente idénticos entre distintos alfabetos (U+0430 а cirílica, U+03BF ο griega, U+FF21 A de ancho completo) permiten a los adversarios falsificar nombres de dominio engañosos (ataques homográficos IDN), ocultar variables en el código fuente (CVE-2021-42694) o eludir listas de bloqueo de palabras clave.

Inspector de Caracteres Unicode vs Otras Herramientas de Texto y Codificación

Respuesta rápida: Usa el Inspector de Caracteres Unicode para auditar una cadena carácter por carácter en busca de códigos de control ocultos, homóglifos y secuencias de bytes. Usa la Tabla ASCII para consultas estáticas de códigos 0 a 255, el Convertidor Unicode para conversiones masivas de texto a puntos de código o la Herramienta para Escapar Unicode para literales de código fuente.

Elige la utilidad adecuada dentro del conjunto de herramientas de caracteres y codificación según necesites diagnosticar una cadena desconocida, consultar una tabla de bytes estándar o transformar literales de cadena para código fuente:

Capacidad Inspector de Caracteres Unicode Tabla ASCII Convertidor Unicode Herramienta para Escapar Unicode
Flujo Principal Auditoría diagnóstica por carácter de cadenas pegadas o archivos Tabla de referencia interactiva para códigos de byte 0–255 Conversión masiva entre texto, puntos de código y arreglos de bytes Escape y desescape de literales de cadena para código fuente
Alertas de Ocultos y Bidi Resalta <ZWSP>, <BOM>, <NBSP> y códigos bidi Trojan Source Lista códigos de control C0 (0–31, 127) y C1 (128–159) Codifica controles numéricamente sin insignias de seguridad Convierte caracteres no ASCII en escapes visibles \uXXXX
Detección de Homóglifos Marca homóglifos entre alfabetos (UTS #39) y puntuación tipográfica Cubre solo US-ASCII de 7 bits e ISO-8859-1 Latin-1 Sin análisis de alfabetos confusos Sin análisis de alfabetos confusos
Diferencia Grafema vs UTF-16 Muestra grafemas UAX #29, puntos escalares, unidades UTF-16 y bytes UTF-8 Filas de tabla fijas de 1 byte (8-bit) Genera flujos completos en UTF-8, UTF-16 y UTF-32 Preserva o empareja sustitutos UTF-16 (\uD83D\uDE80 vs \u{1F680})
Sintaxis de Escape por Lenguaje Muestra puntos de código hexadecimales puros (U+XXXX) y valores de bytes Muestra escapes C/JS, notación caret (^M) y entidades HTML Formatea listas de puntos de código en hexadecimal/decimal Modos dedicados para JS, JSON, Python, CSS, Rust y HTML
  • Cambia a la Tabla ASCII cuando necesites una tabla de consulta rápida para máscaras de bits binarias US-ASCII de 7 bits (0–127) y Latin-1 Extendido (128–255), códigos octales y notación caret de terminal.
  • Usa el Convertidor Unicode cuando quieras convertir por lotes un bloque entero de texto en listas continuas U+XXXX o flujos hexadecimales UTF-8/UTF-16/UTF-32.
  • Usa la Herramienta para Escapar Unicode al preparar o decodificar secuencias \uXXXX, \u{XXXXX}, \xXX o CSS \XXXXXX para payloads JSON y archivos de código fuente, o abre el Contador de caracteres para verificar textos frente a límites de metaetiquetas SEO y segmentos SMS GSM-7/UCS-2.
Preguntas frecuentes

Preguntas frecuentes y guía técnica de Inspector de Caracteres Unicode

Todo lo que necesitas saber sobre el uso gratuito en línea de inspector de caracteres unicode en Utiliome.

¿Por qué String.length en JavaScript devuelve 2 o más para un solo carácter visible?

JavaScript, Java y C# miden la longitud de las cadenas en unidades de código UTF-16 de 16 bits en lugar de valores escalares Unicode o clústeres de grafemas extendidos UAX #29. Cualquier carácter fuera del Plano Multilingüe Básico (por encima de U+FFFF, como el cohete U+1F680) requiere un par sustituto alto y bajo, lo que le da un .length de 2. Las secuencias de emojis compuestos unidos con U+200D Zero Width Joiner (<ZWJ>) y el selector de variación U+FE0F combinan múltiples valores escalares en un solo glifo visual, produciendo a menudo valores de .length entre 5 y 11.

¿Qué caracteres Unicode invisibles rompen con más frecuencia archivos JSON, YAML y código fuente?

Los cuatro culpables más habituales son U+00A0 No-Break Space (<NBSP>, introducido a menudo por accidente mediante Option+Espacio en macOS, rompiendo la indentación YAML y analizadores SQL), U+FEFF Byte Order Mark (<BOM>, incrustado a mitad del flujo al concatenar archivos guardados por editores de Windows), U+200B Zero Width Space (<ZWSP>, copiado de documentos de texto enriquecido, PDFs o apps de chat en tokens de API) y las comillas tipográficas inteligentes (U+201C y U+201D) que reemplazan a las comillas rectas ASCII (U+0022).

¿Cómo detecto ataques de control bidireccional Trojan Source en fragmentos de código?

Trojan Source (CVE-2021-42574) explota nueve caracteres de control bidireccional de la Categoría General Cf de Unicode —U+202A (<LRE>), U+202B (<RLE>), U+202C (<PDF>), U+202D (<LRO>), U+202E (<RLO>), U+2066 (<LRI>), U+2067 (<RLI>), U+2068 (<FSI>) y U+2069 (<PDI>)— para reordenar visualmente los tokens del código fuente de modo que instrucciones ejecutables parezcan estar comentadas durante la revisión humana. Pegar el código sospechoso en el inspector revela cada punto de código bidi oculto en su índice de carácter exacto.

¿Por qué dos cadenas con acentos visualmente idénticas fallan en las comprobaciones de igualdad estricta?

Unicode permite múltiples representaciones canónicamente equivalentes según UAX #15. Por ejemplo, 'é' en la Forma de Normalización C (NFC) es un único valor escalar precompuesto U+00E9 (bytes UTF-8 C3 A9), mientras que en la Forma de Normalización D (NFD) consta de dos valores escalares: U+0065 ('e') seguido del acento agudo combinante U+0301 (bytes UTF-8 65 CC 81). Inspeccionar ambas cadenas expone las diferentes secuencias de puntos de código para que puedas aplicar .normalize('NFC') antes de calcular un hash o comparar.

¿El texto pegado o los archivos subidos se transmiten a algún servidor?

No. La segmentación de caracteres, la extracción de puntos de código, el cálculo de bytes UTF-8 y UTF-16LE/BE y la detección de homóglifos confusos se ejecutan íntegramente en tu navegador utilizando APIs de JavaScript nativas del lado del cliente. Las claves de API, los logs de producción y los fragmentos de código privado permanecen estrictamente en la memoria local.