Ispettore Caratteri Unicode

Ispeziona stringhe Unicode carattere per carattere nel browser.

Nessun caricamentoNessuna registrazioneRisultati istantanei
Unicode e UTF-8/16Larghezza zero e omoglifi100% Locale • Zero Upload
Ispeziona caratteri
Motore offline prontoSpazio di lavoro 100% privato nel browser • Zero upload in cloud
100% Privato • Nessun Caricamento File su Server

Perché usare il Ispettore Caratteri Unicode gratuito di Utiliome?

Creato da zero per garantire massima privacy, esecuzione istantanea e zero intoppi. Senza abbonamento né registrazione.

Rilevamento Caratteri Invisibili e Override Bidi

Individua caratteri di controllo e formattazione non stampabili inclusi U+200B ZWSP, U+FEFF BOM, U+00A0 NBSP, U+00AD Soft Hyphen e override bidirezionali Trojan Source (da U+202A a U+202E, da U+2066 a U+2069).

Scomposizione Byte UTF-8 e UTF-16LE/BE

Mostra le sequenze esatte di byte UTF-8 esadecimali (da 1 a 4 byte secondo RFC 3629) insieme alle code unit UTF-16LE e UTF-16BE, esponendo le coppie di surrogati per i piani supplementari oltre U+FFFF.

Metriche Grafemi UAX #29 vs Code Unit

Confronta i cluster di grafemi estesi con il conteggio dei valori scalari Unicode, le code unit UTF-16 di JavaScript e la lunghezza in byte UTF-8 per diagnosticare bug di slicing delle stringhe e overflow nelle colonne dei database.

Diagnostica Omoglifi e Privacy Zero-Upload

Segnala i caratteri confondibili UTS #39 come glifi cirillici rispetto a quelli latini e la punteggiatura tipografica smart interamente lato client nella memoria del browser, così token, log e codice non lasciano mai il tuo dispositivo.

Utiliome vs le alternative cloud tradizionali

Confronta il nostro motore locale WebAssembly con i vecchi strumenti in cloud.

Funzionalità Utiliome (Browser Locale) Convertitori Cloud Datati
Rilevamento Caratteri Invisibili e Override Bidi Individua caratteri di controllo e formattazione non stampabili inclusi U+200B ZWSP, U+FEFF BOM, U+00A0 NBSP, U+00AD Soft Hyphen e override bidirezionali Trojan Source (da U+202A a U+202E, da U+2066 a U+2069). Opzioni limitate senza personalizzazione avanzata
Scomposizione Byte UTF-8 e UTF-16LE/BE Mostra le sequenze esatte di byte UTF-8 esadecimali (da 1 a 4 byte secondo RFC 3629) insieme alle code unit UTF-16LE e UTF-16BE, esponendo le coppie di surrogati per i piani supplementari oltre U+FFFF. Richiede strumenti esterni o modifiche manuali
Privacy e Elaborazione Dati Elaborazione 100% locale nel browser (zero upload) Carica i dati su server cloud di terze parti
Prezzo e Registrazione 100% gratuito per sempre senza registrazione Richiede registrazione o abbonamento a pagamento
Come funziona

Come usare Ispettore Caratteri Unicode in 3 semplici passaggi

Nessuna installazione richiesta. Tutto viene eseguito direttamente nel tuo browser web.

1

Incolla il Testo o Trascina un File

Incolla una stringa, un identificatore, una voce di log o carica un file UTF-8 contenente sospetti caratteri a larghezza zero, sequenze emoji corrotte o lunghezze in byte impreviste.

2

Ispeziona i Metadati per Singolo Carattere

Esamina per ogni carattere il code point scalare U+XXXX, il nome ufficiale Unicode, la General Category, il blocco di appartenenza, i byte esadecimali UTF-8 e UTF-16LE/BE e i badge di avviso di sicurezza.

3

Isola le Anomalie o Copia l'Output Pulito

Filtra direttamente i caratteri di formattazione invisibili o gli omoglifi confondibili, rimuovi i code point non stampabili indesiderati oppure copia la tabella di ispezione a livello di byte per le segnalazioni di bug.

Ispezionare Caratteri Nascosti, Coppie di Surrogati e Omoglifi

Risposta Rapida: Incolla qualsiasi stringa per scomporla nei singoli valori scalari Unicode, esponendo caratteri invisibili come U+200B Zero Width Space o U+FEFF BOM, sequenze emoji ZWJ multi-codepoint e caratteri non-ASCII confondibili insieme alle relative sequenze esatte di byte UTF-8 e UTF-16.

Gli errori dei parser, le mancate corrispondenze delle firme webhook e le query SQL fallite derivano spesso da caratteri che vengono renderizzati in modo identico—o completamente invisibile—negli emulatori di terminale e negli editor di codice. Consideriamo una variabile d'ambiente copiata da un portale di documentazione o da un messaggio in chat che appare visivamente identica ad api_key=prod:

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

Analizzando quella stringa di 14 unità con l'Ispettore Caratteri Unicode emergono tre distinte anomalie nascoste all'interno di quello che sembra semplice testo ASCII: un Byte Order Mark iniziale (<BOM>), un omoglifo cirillico che sostituisce la a latina e uno spazio a larghezza zero incorporato (<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"
  }
]

L'ispettore chiarisce anche perché le emoji multi-codepoint riportano lunghezze profondamente diverse a seconda del runtime. Ispezionando la singola emoji visibile del tecnologo 👨💻 si scoprono tre code point scalari uniti da <ZWJ> (U+200D), che occupano 5 code unit UTF-16 in JavaScript e 11 byte in 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

Meccaniche di Codifica Unicode, Confini dei Grafemi e Rischi di Sicurezza

Risposta Rapida: Unicode mappa 1.112.064 valori scalari validi distribuiti su 17 piani in sequenze a larghezza variabile UTF-8 (da 1 a 4 byte secondo RFC 3629) o UTF-16 (2 o 4 byte tramite coppie di surrogati secondo RFC 2781). Le discrepanze tra cluster di grafemi, forme di normalizzazione canonica e controlli bidi invisibili causano bug nei parser e vulnerabilità di sicurezza.

Valori Scalari, Bit di Prefisso UTF-8 (RFC 3629) e Surrogati UTF-16 (RFC 2781)

Lo spazio dei codici Unicode si estende da U+0000 a U+10FFFF attraverso 17 piani da 65.536 code point ciascuno. Escludendo le 2.048 posizioni riservate ai surrogati (U+D800 a U+DFFF), esistono esattamente 1.112.064 valori scalari Unicode:

  • UTF-8 codifica il Plane 0 Basic Latin (U+0000 a U+007F) in 1 byte (0xxxxxxx), da U+0080 a U+07FF in 2 byte (110xxxxx 10xxxxxx), i restanti caratteri del Basic Multilingual Plane (BMP, da U+0800 a U+FFFF) in 3 byte (1110xxxx 10xxxxxx 10xxxxxx) e i piani astrali supplementari (U+10000 a U+10FFFF) in 4 byte (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx). Poiché i byte di continuazione iniziano sempre con 10, UTF-8 è auto-sincronizzante e non contiene mai byte null (0x00) all'interno di caratteri non null.
  • UTF-16 rappresenta i valori scalari del BMP direttamente come una singola code unit a 16 bit. I caratteri da U+10000 a U+10FFFF sottraggono 0x10000 per ottenere un offset a 20 bit (0x00000 a 0xFFFFF), dividendo i 10 bit superiori in un surrogato alto/lead (0xD800 a 0xDBFF) e i 10 bit inferiori in un surrogato basso/trail (0xDC00 a 0xDFFF). UTF-16BE serializza prima il byte più significativo (D8 3D DC 80), mentre UTF-16LE inverte l'ordine dei byte all'interno di ciascuna unità a 16 bit (3D D8 80 DC).

Equivalenza Canonica (UAX #15) e Segmentazione dei Grafemi (UAX #29)

Un testo visivamente identico possiede spesso rappresentazioni in byte sottostanti differenti. Secondo lo Unicode Standard Annex #15, é può essere memorizzata in Normalization Form C (NFC) come carattere precomposto U+00E9 (UTF-8 C3 A9) oppure in Normalization Form D (NFD) come carattere base U+0065 (e) seguito da U+0301 (COMBINING ACUTE ACCENT, General Category Mn, UTF-8 65 CC 81). I file system macOS normalizzano i nomi dei file verso forme NFD, mentre Linux, Windows e gli invii dei form nei browser usano NFC per impostazione predefinita—facendo fallire i confronti ingenui byte per byte tra stringhe, le ricerche di chiavi di oggetti S3 e le verifiche HMAC se non vengono prima normalizzati.

Allo stesso modo, suddividere le stringhe tramite indice UTF-16 (str.slice(0, 10)) può separare un surrogato alto dal suo surrogato basso (producendo surrogati spaiati che vengono serializzati come caratteri di sostituzione U+FFFD in UTF-8) o dividere un carattere base dai suoi segni diacritici combinanti, dai selettori di variante (U+FE0E, U+FE0F) o dagli indicatori regionali delle bandiere (U+1F1E6 a U+1F1FF). I caratteri percepiti dall'utente devono essere segmentati lungo i confini degli extended grapheme cluster UAX #29.

Trojan Source (`CVE-2021-42574`) e Caratteri Confondibili UTS #39

Due classi di caratteri in Unicode comportano gravi rischi per la sicurezza delle applicazioni:

  1. Override Bidirezionali (Cf): I code point da U+202A a U+202E (<LRE>, <RLE>, <PDF>, <LRO>, <RLO>) e gli isolati da U+2066 a U+2069 (<LRI>, <RLI>, <FSI>, <PDI>) istruiscono i motori di rendering del testo a invertire l'ordine di visualizzazione senza alterare l'ordine logico in memoria. Gli attaccanti sfruttano controlli bidi non terminati per camuffare controlli condizionali attivi all'interno di commenti o stringhe letterali (CVE-2021-42574).
  2. Spoofing con Omoglifi (UTS #39): I caratteri simili appartenenti a sistemi di scrittura diversi (U+0430 а cirillica, U+03BF ο greca, U+FF21 A a larghezza intera) consentono agli attaccanti di falsificare nomi di dominio ingannevoli (attacchi omografici IDN), oscurare variabili nel codice sorgente (CVE-2021-42694) o aggirare le blocklist di parole chiave.

Ispettore Caratteri Unicode vs Strumenti Affini per Testo e Codifica

Risposta Rapida: Usa l'Ispettore Caratteri Unicode per analizzare una stringa carattere per carattere alla ricerca di codici di controllo nascosti, omoglifi e sequenze di byte. Usa la Tabella ASCII per consultazioni statiche dei codici da 0 a 255, il Convertitore Unicode per conversioni massive da testo a code point, o lo Strumento di Escape Unicode per sequenze di escape specifiche dei linguaggi.

Scegli l'utility giusta nel gruppo dedicato a caratteri e codifica in base alla tua esigenza: diagnosticare una stringa sconosciuta, consultare una tabella di byte standard o trasformare stringhe letterali per il codice sorgente:

Funzionalità Ispettore Caratteri Unicode Tabella ASCII Convertitore Unicode Strumento di Escape Unicode
Flusso Principale Analisi diagnostica per singolo carattere di stringhe incollate o file Tabella di riferimento interattiva per i codici byte 0–255 Conversione massiva tra testo, code point e array di byte Escape e unescape di stringhe letterali per codice sorgente
Avvisi Nascosti e Bidi Evidenzia <ZWSP>, <BOM>, <NBSP> e codici bidi Trojan Source Elenca i codici di controllo C0 (0–31, 127) e C1 (128–159) Codifica i caratteri di controllo numericamente senza badge di sicurezza Converte i caratteri non-ASCII in sequenze visibili \uXXXX
Rilevamento Omoglifi Segnala i caratteri confondibili multi-alfabeto UTS #39 e la punteggiatura smart Copre solo US-ASCII a 7 bit e ISO-8859-1 Latin-1 Nessuna analisi di alfabeti confondibili Nessuna analisi di alfabeti confondibili
Confronto Grafemi vs UTF-16 Mostra grafemi UAX #29, punti scalari, unità UTF-16 e byte UTF-8 Righe di tabella fisse a 1 byte (8-bit) Genera flussi completi UTF-8, UTF-16 e UTF-32 Preserva o accoppia i surrogati UTF-16 (\uD83D\uDE80 vs \u{1F680})
Sintassi di Escape per Linguaggi Mostra code point esadecimali grezzi (U+XXXX) e valori in byte Mostra escape C/JS, notazione caret (^M) ed entità HTML Formatta elenchi di code point esadecimali/decimali Modalità di escape dedicate per JS, JSON, Python, CSS, Rust e HTML
  • Passa alla Tabella ASCII quando hai bisogno di una tabella di consultazione rapida per maschere di bit binarie, codici ottali e notazione caret da terminale per US-ASCII a 7 bit (0–127) e Latin-1 esteso (128–255).
  • Usa il Convertitore Unicode quando vuoi convertire in blocco un intero testo in elenchi continui U+XXXX o flussi esadecimali UTF-8/UTF-16/UTF-32.
  • Usa lo Strumento di Escape Unicode per preparare o decodificare sequenze \uXXXX, \u{XXXXX}, \xXX o CSS \XXXXXX destinate a payload JSON e file sorgente, oppure apri il Contatore di caratteri per verificare i testi rispetto ai limiti dei meta tag SEO e dei segmenti SMS GSM-7/UCS-2.
Domande frequenti

FAQ e Guida Tecnica su Ispettore Caratteri Unicode

Tutto ciò che devi sapere sull'uso di ispettore caratteri unicode online e gratuito di Utiliome.

Perché String.length in JavaScript restituisce 2 o più per un singolo carattere visibile?

JavaScript, Java e C# misurano la lunghezza delle stringhe in code unit UTF-16 a 16 bit anziché in valori scalari Unicode o cluster di grafemi estesi UAX #29. Qualsiasi carattere esterno al Basic Multilingual Plane (oltre U+FFFF, come il razzo U+1F680) richiede una coppia di surrogati alto e basso, restituendo una proprietà .length pari a 2. Le sequenze di emoji composte unite tramite U+200D Zero Width Joiner (<ZWJ>) e U+FE0F Variation Selector-16 combinano più valori scalari in un unico glifo visivo, producendo spesso valori di .length compresi tra 5 e 11.

Quali caratteri Unicode invisibili corrompono più frequentemente JSON, YAML e codice sorgente?

I quattro responsabili più comuni sono U+00A0 No-Break Space (<NBSP>, spesso digitato accidentalmente con Opzione+Spazio su macOS, che invalida l'indentazione YAML e i parser SQL), U+FEFF Byte Order Mark (<BOM>, incorporato a metà flusso quando si concatenano file salvati da editor Windows), U+200B Zero Width Space (<ZWSP>, copiato da documenti rich-text, PDF o app di chat dentro i token API) e le virgolette tipografiche smart (U+201C e U+201D) che sostituiscono le virgolette dritte ASCII (U+0022).

Come posso rilevare gli attacchi di override bidirezionale Trojan Source nei frammenti di codice?

Trojan Source (CVE-2021-42574) sfrutta nove caratteri di controllo bidirezionali Unicode della General Category Cf—U+202A (<LRE>), U+202B (<RLE>), U+202C (<PDF>), U+202D (<LRO>), U+202E (<RLO>), U+2066 (<LRI>), U+2067 (<RLI>), U+2068 (<FSI>) e U+2069 (<PDI>)—per riordinare visivamente i token del codice sorgente in modo che istruzioni eseguibili appaiano commentate durante la revisione umana. Incollando il codice sospetto nell'ispettore viene rivelato ogni singolo code point bidi nascosto al suo esatto indice di carattere.

Perché due stringhe accentate visivamente identiche non superano i controlli di uguaglianza stretta?

Unicode consente più rappresentazioni canonicamente equivalenti secondo lo standard UAX #15. Ad esempio, 'é' in Normalization Form C (NFC) è un singolo valore scalare precomposto U+00E9 (byte UTF-8 C3 A9), mentre in Normalization Form D (NFD) è composta da due valori scalari: U+0065 ('e') seguito dal Combining Acute Accent U+0301 (byte UTF-8 65 CC 81). Ispezionando entrambe le stringhe vengono esposte le diverse sequenze di code point, permettendoti di applicare .normalize('NFC') prima dell'hashing o del confronto.

Il testo incollato o il file caricato viene trasmesso a qualche server?

No. La segmentazione dei caratteri, l'estrazione dei code point, il calcolo dei byte UTF-8 e UTF-16LE/BE e i controlli sugli omoglifi confondibili vengono eseguiti interamente nel tuo browser utilizzando le API JavaScript native lato client. Chiavi API, log di produzione e frammenti di codice sorgente privato rimangono strettamente nella memoria locale.