Skip to content

Convertitore da Esadecimale a Testo (e da Testo a Hex)

Converti online da esadecimale a testo e viceversa. Incolla hex in ogni forma — spazi, 0x, \x, output di xxd o hexdump, array di byte Java o C — e ASCII, UTF-8, GBK o UTF-16 vengono rilevati da soli. Tutto nel browser.

Niente tracciamento Funziona nel browser Gratuito
La conversione avviene interamente nel tuo browser — niente di ciò che incolli lascia questo dispositivo.
Prova un esempio

Letto come hex semplice · 13 byte

    Testo 
    Hello, 世界

    Rilevato automaticamente UTF-8: ogni sequenza multibyte è ben formata.

    Gli stessi byte in ogni codifica

    Codifica Lettura
    UTF-8 Si decodifica senza errori Hello, 世界
    GBK / GB18030 Si decodifica senza errori Hello, 涓栫晫
    UTF-16LE Contiene byte non decodificabili 效汬Ɐ隸闧�
    UTF-16BE Contiene byte non decodificabili 䡥汬漬⃤뢖�
    ISO-8859-1 Si decodifica senza errori Hello, ä¸<96>ç<95><8C>
    I dump esadecimali, gli array di byte e i messaggi di errore citati qui provengono da esecuzioni reali di xxd, Python 3.14, Node.js 26, Go 1.27 e clang, e i formati di output del motore sono testati perché si possano rileggere ottenendo i byte originali. Il comportamento di Java e PHP è citato dalla documentazione ufficiale. — Team di Ingegneria Go Tools · Sep 16, 2026

    Scritto e revisionato dagli sviluppatori che realizzano gli strumenti di codifica di Go Tools. Ogni valore hex e ogni output citati in questa pagina sono prodotti dal motore della pagina stessa e verificati da test automatici.

    Hex in ASCII: risposte rapide

    Che testo è 48 65 6C 6C 6F?

    Hello In ASCII e UTF-8, 48 è H, 65 è e, 6C è l e 6F è o.

    Quanti byte occupa un carattere cinese?

    Di solito 3 byte in UTF-8, 2 in GBK 你 è E4 BD A0 in UTF-8 e C4 E3 in GBK.

    Che cos'è 0D 0A?

    CR LF (\r\n) Ritorno a capo seguito da avanzamento riga — il fine riga usato da Windows, da HTTP e dalla maggior parte dei set di comandi seriali.

    Qual è il valore hex della lettera A?

    41 La a minuscola è 61; maiuscola e minuscola differiscono sempre di 20.

    Che cos'è la conversione da hex a stringa?

    L'esadecimale è un modo di scrivere i byte: ogni byte, da 0 a 255, si scrive con due cifre da 00 a FF. La conversione da hex a stringa riporta quei byte a testo leggibile e comporta sempre la scelta di una codifica dei caratteri, cioè la tabella che dice quale byte, o sequenza di byte, corrisponde a quale carattere.

    Con il testo inglese la scelta si nota di rado, perché ASCII, UTF-8, GBK e la maggior parte delle altre codifiche concordano sui byte da 00 a 7F. Con qualsiasi altra cosa si nota subito. I byte C4 E3 BA C3 sono 你好 in GBK e non sono validi in UTF-8, mentre 你好 in UTF-8 è E4 BD A0 E5 A5 BD. L'hex è solo metà dell'informazione; l'altra metà è la codifica.

    Da stringa a hex è il percorso inverso: codifichi il testo in byte, poi scrivi ogni byte come due cifre hex. Gli sviluppatori la usano per vedere esattamente che cosa passa su una linea seriale o finisce in una colonna del database, per inserire dati binari nel codice sorgente e per confrontare ciò che due sistemi hanno davvero inviato.

    $ echo 48656c6c6f | xxd -r -p
Hello

>>> bytes.fromhex('c4e3bac3').decode('gbk')
'你好'
>>> bytes.fromhex('c4e3bac3').decode('utf-8')
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc4 in position 0: invalid continuation byte

    Che cosa fa questo convertitore esadecimale

    Incolla hex in qualsiasi forma

    Con spazi, compatto, separato da due punti o trattini, valori 0x, escape \x, codifica %, array C, Go e Java, l'output con segno di Arrays.toString di Java, letterali bytes di Python, Buffer di Node.js e schermate complete di xxd, hexdump -C e od. La pagina ti dice che cosa ha riconosciuto e che cosa ha rimosso.

    Codifica rilevata, con il motivo

    Il rilevamento automatico cerca un BOM, UTF-8 ben formato, UTF-16, ASCII puro e infine GBK, e dice quale regola ha deciso. GBK viene scelto solo quando i byte si leggono come caratteri cinesi comuni, quindi i frame binari brevi vengono segnalati come probabilmente non testuali invece di diventare cinese senza senso.

    Tutte le codifiche a confronto

    Gli stessi byte vengono mostrati come UTF-8, GBK, UTF-16LE, UTF-16BE e ISO-8859-1, ognuno contrassegnato a seconda che si decodifichi senza errori o no. Quando il testo esce illeggibile, di solito la lettura corretta è una riga più in basso.

    Byte invisibili resi visibili

    NUL, CR, LF, ESC e gli altri byte di controllo sono mostrati come ␀ ␍ ␊ ␛, così uno 00 finale o uno 0D mancante nei dati di protocollo salta all'occhio. La copia restituisce comunque i caratteri reali.

    Output pronto da incollare nel codice

    Testo → Hex produce hex con spazi o compatto, liste 0x, escape \x, un array C in stile xxd -i, un byte[] Java con valori con segno, un letterale bytes di Python identico a quello di repr(), un []byte Go o un dump xxd — e la pagina sa rileggere ognuno di questi formati.

    Niente esce dal tuo browser

    Analisi e decodifica girano in locale in JavaScript. Niente viene caricato, memorizzato o inserito nell'URL, quindi puoi incollare tranquillamente catture di pacchetti e log di produzione.

    Da hex a stringa nel codice

    Python 3

    bytes.fromhex(h).decode()

    bytes.fromhex('48 65 6c 6c 6f').decode('utf-8') restituisce 'Hello'; gli spazi tra i byte sono ammessi, un prefisso 0x no. L'inverso è s.encode('utf-8').hex(), oppure .hex(' ') per un output con spazi. Passa 'gbk' per decodificare o codificare testo cinese in GBK.

    JavaScript (Node.js)

    Buffer.from(h, 'hex')

    Buffer.from(h, 'hex').toString('utf8') decodifica, Buffer.from(s, 'utf8').toString('hex') codifica. Un input non valido non genera errori: la decodifica si ferma alla prima coppia errata e un'ultima cifra dispari viene scartata, quindi valida prima l'input.

    JavaScript (browser)

    TextDecoder / TextEncoder

    Converti le coppie con parseInt(pair, 16) in un Uint8Array, poi chiama new TextDecoder('utf-8').decode(bytes). TextDecoder legge anche 'gbk', 'big5' e 'shift_jis', ma TextEncoder produce solo UTF-8.

    Java 17+

    HexFormat.of()

    new String(HexFormat.of().parseHex(h), StandardCharsets.UTF_8) decodifica e HexFormat.of().formatHex(s.getBytes(StandardCharsets.UTF_8)) codifica. Nelle versioni precedenti formatta ogni byte con String.format("%02x", b); evita Integer.toHexString(b), che stampa ffffffe4 per i byte negativi.

    Go

    encoding/hex

    hex.DecodeString(h) restituisce i byte e string(b) li trasforma in stringa; hex.EncodeToString([]byte(s)) fa il percorso inverso. È rigoroso: con gli spazi restituisce invalid byte: U+0020 ' ' e con una lunghezza dispari odd length hex string.

    C

    sscanf with %2hhx

    Scorri la stringa due cifre alla volta scrivendo in un buffer di unsigned char e aggiungi un '\0' finale. Per stampare in hex fai il cast a unsigned char e usa %02X, altrimenti, dove char ha segno, i byte sopra 0x7F possono essere stampati come FFFFFFE4.

    PHP

    hex2bin() / bin2hex()

    hex2bin('48656c6c6f') restituisce Hello e bin2hex('Hello') restituisce 48656c6c6f. Il manuale documenta che hex2bin() restituisce false con un E_WARNING per input di lunghezza dispari o non valido.

    Shell (xxd)

    xxd -r -p / xxd -p

    echo 48656c6c6f | xxd -r -p stampa Hello, e printf 'Hello' | xxd -p stampa 48656c6c6f. Per codificare usa printf anziché echo, perché echo aggiunge un a capo finale, 0a.

    C# (.NET 5+)

    Convert.FromHexString()

    Encoding.UTF8.GetString(Convert.FromHexString(h)) decodifica e Convert.ToHexString(Encoding.UTF8.GetBytes(s)) codifica (in maiuscolo, senza separatori). FromHexString rifiuta gli spazi e il prefisso 0x. .NET Core e .NET 5+ non includono GBK: chiama prima Encoding.RegisterProvider(CodePagesEncodingProvider.Instance) e poi Encoding.GetEncoding(936).

    Esempi di conversione da hex a testo

    Hex UTF-8 con caratteri cinesi

    48 65 6C 6C 6F 2C 20 E4 B8 96 E7 95 8C
    Hello, 世界

    I primi sette byte sono semplice ASCII: 48 65 6C 6C 6F è Hello, 2C è una virgola e 20 uno spazio. E4 B8 96 e E7 95 8C sono sequenze UTF-8 di tre byte per 世 e 界 — la maggior parte dei caratteri cinesi occupa tre byte in UTF-8. Poiché ogni sequenza è ben formata, il rilevamento automatico lo legge come UTF-8.

    Lettura di un sensore in GBK che non è UTF-8 valido

    CE C2 B6 C8 3A 32 35 2E 33 A1 E6
    温度:25.3℃

    Molti dispositivi seriali inviano il testo cinese in GBK. Qui CE C2 è 温 e B6 C8 è 度, 3A 32 35 2E 33 è l'ASCII :25.3 e A1 E6 è il simbolo ℃ a larghezza piena — due byte per ogni carattere o simbolo cinese. Letti come UTF-8 i byte non sono validi (CE apre una sequenza di due byte, ma C2 non è un byte di continuazione), mentre letti come GBK sono caratteri comuni, quindi il rilevamento automatico sceglie GBK. Un convertitore che conosce solo UTF-8 qui mostra caratteri di sostituzione.

    Output di xxd incollato così com'è

    00000000: 4869 20e4 bda0 e5a5 bd0d 0a              Hi ........
    Hi 你好␍␊

    È esattamente ciò che stampa printf 'Hi 你好\r\n' | xxd. L'offset 00000000: e la colonna di caratteri a destra vengono rimossi prima della decodifica; se fossero letti come dati, già gli otto zeri diventerebbero quattro byte NUL all'inizio. Gli ultimi due byte, 0d 0a, sono un a capo di Windows, mostrato come ␍␊.

    Un array di byte Java preso da un log

    [-28, -72, -83, -26, -106, -121]
    中文

    Arrays.toString(bytes) stampa in decimale i byte con segno di Java. I valori negativi sono byte da 0x80 in su: -28 è 256 − 28 = 228 = 0xE4. I sei byte E4 B8 AD E6 96 87 sono la codifica UTF-8 di 中文.

    Da testo a hex per un comando AT seriale

    AT+CSQ\r\n
    41 54 2B 43 53 51 0D 0A

    I modem e la maggior parte dei set di comandi UART si aspettano che ogni comando termini con ritorno a capo più avanzamento riga. Una casella di testo produce solo 0A quando premi Invio, quindi spunta A capo come CR LF e il fine riga diventa 0D 0A.

    Hex codificato in hex due volte

    653462646130653561356264
    e4bda0e5a5bd → 你好

    Ogni byte qui è una cifra hex in ASCII (65 è e, 34 è 4, 62 è b), quindi la prima decodifica produce un'altra stringa hex. Succede quando una stringa hex viene trattata come testo e convertita di nuovo. La pagina propone il secondo passaggio, che dà 你好. Per evitare falsi allarmi lo propone solo quando il primo risultato ha almeno 12 cifre hex e il secondo si decodifica in testo vero — date, timestamp, valori CRC32 e hash MD5 non lo attivano.

    Come convertire da esadecimale a testo

    1. 1

      Incolla l'esadecimale

      Incollalo nel riquadro della scheda Hex → Testo nella forma che hai: con spazi, compatto, valori 0x, escape \x, un array di byte o un'intera schermata di xxd. La riga sotto il riquadro dice come è stato letto.

    2. 2

      Controlla il testo e la codifica

      Il testo compare a destra, con la codifica rilevata automaticamente e il motivo. Se l'ipotesi è sbagliata, la tabella sotto mostra tutte le letture; scegli quella giusta dal menu Codifica.

    3. 3

      Cerca i caratteri invisibili

      I byte di controllo come NUL, CR e LF sono mostrati come ␀ ␍ ␊. Togli la spunta a Mostra caratteri invisibili per il testo semplice, poi copia il risultato.

    4. 4

      Oppure converti il testo in hex

      Nella scheda Testo → Hex scegli la codifica e un formato di output — hex con spazi, valori 0x, un array C, Java, Python o Go, oppure un dump xxd. Spunta CR LF per i protocolli seriali e di rete.

    Perché la conversione da hex a testo va storta

    Decodificare byte GBK come UTF-8

    Il testo cinese proveniente da vecchi software Windows, da molti dispositivi seriali e da database legacy è in GBK. Decodificarlo come UTF-8 o fallisce o riempie l'output di caratteri di sostituzione. Guarda la tabella delle codifiche e usa la lettura che ha senso.

    ✗ Errato 
    >>> bytes.fromhex('c4e3bac3').decode('utf-8')
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc4 in position 0: invalid continuation byte
    ✓ Corretto 
    >>> bytes.fromhex('c4e3bac3').decode('gbk')
'你好'

    Usare charCodeAt() per ottenere i byte in JavaScript

    charCodeAt() restituisce un'unità di codice UTF-16. Per l'ASCII coincide per caso con il byte, quindi il bug compare solo con altri caratteri, dove il risultato non è ciò che invierebbe un qualsiasi sistema UTF-8.

    ✗ Errato 
    '你'.charCodeAt(0).toString(16)   // '4f60' — a UTF-16 code unit
    ✓ Corretto 
    Buffer.from('你', 'utf8').toString('hex')   // 'e4bda0' — the UTF-8 bytes

    Formattare byte con segno con Integer.toHexString in Java

    Il byte di Java ha segno, quindi i byte da 0x80 in su sono negativi. Integer.toHexString() lavora su un int, stampa i valori negativi come hex senza segno a 32 bit ed elimina gli zeri iniziali.

    ✗ Errato 
    Integer.toHexString(b)        // "ffffffe4" for 0xE4, "a" for 0x0A
    ✓ Corretto 
    String.format("%02x", b)      // "e4", "0a"

    Fidarsi di Buffer.from() di Node.js con hex non verificato

    Buffer.from(hex, 'hex') non lancia mai eccezioni. Si ferma alla prima coppia che non è hex valido e ignora un'ultima cifra dispari, quindi un errore di battitura ti dà un buffer più corto invece di un errore.

    ✗ Errato 
    Buffer.from('486', 'hex')      // <Buffer 48> — the 6 is silently dropped
Buffer.from('48zz65', 'hex')   // <Buffer 48> — stops at zz
    ✓ Corretto 
    if (!/^([0-9a-f]{2})*$/i.test(hex)) throw new Error('invalid hex');
Buffer.from(hex, 'hex');

    Incollare un dump esadecimale con la colonna degli offset

    Un convertitore che rimuove solo gli spazi legge l'offset 00000000: come dati e, dove può, la colonna dei caratteri come altro hex. Il risultato inizia con byte NUL e da lì va alla deriva. Usa xxd -p per ottenere hex semplice, oppure incolla il dump qui, dove le colonne vengono riconosciute.

    ✗ Errato 
    00000000: 4869 20e4 bda0 e5a5 bd0d 0a              Hi ........
→ read naively: 00 00 00 00 48 69 20 e4 …
    ✓ Corretto 
    $ printf 'Hi 你好\r\n' | xxd -p
486920e4bda0e5a5bd0d0a

    Inviare LF quando il dispositivo si aspetta CR LF

    I modem AT e molti protocolli basati su righe terminano ogni comando con ritorno a capo più avanzamento riga. Un comando che termina solo con 0A spesso viene ignorato senza alcun errore.

    ✗ Errato 
    41 54 2B 43 53 51 0A      AT+CSQ followed by LF only
    ✓ Corretto 
    41 54 2B 43 53 51 0D 0A   AT+CSQ followed by CR LF

    Quando serve un convertitore da hex a testo

    Debug seriale e UART
    I terminali seriali mostrano i dati ricevuti in hex. Incolla un frame per leggere il testo che contiene e individuare lo 0D 0A o lo 00 finale — e fai il percorso inverso per costruire un comando, con fine riga CR LF, che il dispositivo accetti.
    Leggere catture di pacchetti
    I payload di protocollo copiati da Wireshark o tcpdump sono in hex. Decodificare qui una riga di richiesta, un corpo JSON o il nome di un dispositivo dentro un frame è più veloce che scrivere uno script, e niente lascia la tua macchina.
    Array di byte nei log applicativi
    Java scrive nei log gli array di byte come decimali con segno, Python come letterali b'...' e Node.js come <Buffer ...>. Incolla il frammento di log così com'è per vedere il testo, compreso se era UTF-8 o GBK.
    Colonne hex e BLOB nei database
    Gli strumenti per database mostrano le colonne binarie in hex. Decodifica un valore per controllare che cosa è stato davvero memorizzato, oppure converti il testo in hex per confrontarlo byte per byte con ciò che contiene il database.
    Stringhe nel firmware e nel codice C
    Il codice embedded conserva il testo in array di byte. Trasforma una stringa in un array C pronto da incollare, oppure rileggi come testo un array preso da un file header per verificare che cosa stamperà il dispositivo.

    Come l'hex diventa testo: ASCII, UTF-8, GBK e UTF-16

    Due cifre hex per byte
    Un byte contiene 8 bit e una cifra hex ne rappresenta 4, quindi ogni byte è esattamente due cifre hex, da 00 a FF, e il numero di byte è sempre la metà del numero di cifre. Maiuscole e minuscole hanno lo stesso significato. Separatori, prefissi e sintassi degli array sono solo notazione: 4865, 48 65, 0x48, 0x65 e \x48\x65 sono gli stessi due byte.
    ASCII: i byte su cui tutte le codifiche concordano
    ASCII assegna i valori da 00 a 7F. I caratteri stampabili vanno da 20 (spazio) a 7E (~); il resto sono caratteri di controllo, tra cui 00 (NUL), 09 (tabulazione), 0A (avanzamento riga), 0D (ritorno a capo) e 1B (escape) sono i più frequenti nei dati reali. UTF-8, GBK e ISO-8859-1 mantengono tutti questi valori, ed è per questo che un semplice testo inglese sopravvive a quasi qualsiasi codifica sbagliata.
    UTF-8: da uno a quattro byte per carattere
    UTF-8 scrive l'ASCII come byte singoli e ogni altro carattere come sequenza. Il primo byte annuncia la lunghezza — C2–DF per due byte, E0–EF per tre, F0–F4 per quattro — e ogni byte successivo deve stare in 80–BF. Questa struttura rigida spiega perché una frase GBK non è quasi mai UTF-8 valido — nel nostro test su 33.910 frasi cinesi lo erano 55 — e perché il rilevamento automatico si fida di una decodifica UTF-8 pulita. Un singolo carattere cinese è un'altra storia: circa il 18% dei caratteri GBK forma per caso una sequenza UTF-8 valida di due byte.
    GBK: due byte per carattere cinese
    GBK mantiene l'ASCII come byte singoli e codifica i caratteri cinesi e la punteggiatura a larghezza piena con due byte: un byte iniziale da 81 a FE seguito da un byte finale da 40 a FE, escluso 7F. Poiché l'intervallo del byte finale è così ampio, un breve testo UTF-8 letto come GBK spesso si decodifica senza alcun errore in caratteri senza legame — E4 BD A0 E5 A5 BD (你好) diventa 浣犲ソ — ed è per questo che questa pagina prova prima UTF-8. GB18030 estende GBK con sequenze di quattro byte per i caratteri più rari; la decodifica di questa pagina le accetta.
    UTF-16 e ordine dei byte
    UTF-16 usa due byte per carattere (quattro per i caratteri fuori dal Piano Multilingue di Base), e i due byte possono arrivare in entrambi gli ordini. UTF-16LE mette prima il byte meno significativo — A è 41 00 — e UTF-16BE prima quello più significativo — 00 41. Le API di Windows e molti file usano il little-endian e possono iniziare con un BOM, FF FE; i file UTF-8 a volte iniziano con EF BB BF. Il rilevamento automatico rimuove il BOM e lo segnala.

    Convertire tra hex e stringhe senza errori

    Dichiara la codifica da entrambe le parti
    L'hex da solo non dice quale codifica l'ha prodotto. Ovunque il testo diventi byte — getBytes(), encode(), l'impostazione di un terminale seriale, il charset di una connessione al database — imposta la codifica in modo esplicito e annotala accanto all'hex, così l'altra parte non deve indovinarla.
    Lavora con i byte, non con i codici dei caratteri
    Le funzioni che restituiscono codici di carattere, come charCodeAt() di JavaScript o i valori char di Java, danno unità di codice UTF-16 anziché byte codificati. Codifica prima la stringa con TextEncoder, Buffer.from() o getBytes(StandardCharsets.UTF_8), poi formatta i byte.
    Scrivi sempre ogni byte con due cifre
    Usa %02x o un equivalente, mai una semplice conversione da numero a hex. In un log a e 0a si somigliano, ma concatenare valori senza zero iniziale produce una stringa di lunghezza dispari o, peggio, una che si decodifica in byte diversi.
    Usa separatori coerenti nello stesso log
    Scegli un formato per log e trace, per esempio coppie separate da spazi, e non cambiarlo. I formati misti sono facili da leggere per le persone e facili da fraintendere per gli script, soprattutto quando alcuni valori hanno lo zero iniziale e altri no.
    Controlla il numero di byte
    Prima di fidarti di una conversione, confronta il numero di byte con quello che ti aspetti: il campo lunghezza nell'header di un protocollo, la dimensione della colonna o quella del file. La pagina mostra il conteggio in entrambe le direzioni.

    Domande frequenti sulla conversione da hex a testo

    Come si converte da esadecimale a testo?
    Incolla l'esadecimale nel riquadro della scheda Hex → Testo; il testo compare subito. A mano servono due passaggi. Primo, dividi l'esadecimale in coppie: ogni coppia di cifre hex è un byte, da 00 a FF, quindi 48656c6c6f sono i cinque byte 48, 65, 6C, 6C, 6F. Secondo, decodifica quei byte con una codifica dei caratteri. In ASCII e UTF-8 48 è H, 65 è e, 6C è l e 6F è o, e si ottiene Hello. È nel secondo passaggio che i risultati divergono: i byte sopra 7F indicano caratteri diversi in UTF-8, GBK e altre codifiche, ed è per questo che questa pagina rileva la codifica e mostra tutte le letture una accanto all'altra.
    Perché il mio hex diventa caratteri illeggibili?
    Quasi sempre perché i byte vengono decodificati con la codifica sbagliata. Il testo cinese è il caso classico: C4 E3 BA C3 è 你好 in GBK ma UTF-8 non valido, e E4 BD A0 E5 A5 BD è 你好 in UTF-8 ma diventa 浣犲ソ se letto come GBK. Guarda la tabella delle codifiche sotto il risultato: la riga che si legge come testo sensato è la codifica con cui i dati sono stati scritti. Con uno o due caratteri soltanto il rilevamento automatico non sempre riesce a distinguere: D2 BB è UTF-8 valido (һ) e anche GBK (一), quindi controlla la riga GBK che la pagina mostra sotto il risultato. Vale la pena escludere altre due cause: una cifra hex in più o in meno, che sposta di mezzo byte tutti i byte successivi, e un dump esadecimale incollato con la colonna degli offset ancora attaccata. Se quello che hai è già testo illeggibile (come 浣犲ソ) e non hex, incolla invece il testo nel convertitore di codifica.
    Perché i dati seriali sembrano illeggibili come testo ma corretti in hex?
    Se l'hex è giusto, baud rate, bit di dati e parità sono corretti: se fossero sbagliati, cambierebbero i byte stessi. Il problema sta nel passaggio che trasforma i byte in caratteri, e di solito è una di tre cose. I dati potrebbero non essere affatto testo: un protocollo binario come Modbus RTU ha senso solo in hex. La codifica potrebbe non corrispondere: un dispositivo invia il cinese in UTF-8 mentre il terminale seriale mostra GBK, o viceversa, così i byte UTF-8 E4 BD A0 E5 A5 BD di 你好 compaiono come 浣犲ソ. Oppure il testo contiene byte di controllo come 00 o 0D 0A, che appaiono come quadratini o interruzioni di riga. Incolla qui l'hex: la tabella delle codifiche mostra le letture UTF-8 e GBK una accanto all'altra, e i byte di controllo compaiono come ␀ ␍ ␊.
    Che differenza c'è tra hex in ASCII e hex in UTF-8?
    ASCII definisce solo i byte da 00 a 7F: lettere, cifre, punteggiatura e caratteri di controllo. UTF-8 è costruito in modo che quegli stessi byte indichino esattamente gli stessi caratteri, e usa sequenze di byte da 80 in su per tutto il resto — 2 byte per le lettere latine accentate, 3 per la maggior parte dei caratteri cinesi, giapponesi e coreani, 4 per le emoji. Per un semplice testo in inglese, quindi, hex in ASCII e hex in UTF-8 danno risultati identici. Divergono non appena un byte vale 80 o più: un convertitore solo ASCII non può mostrare quei byte come caratteri, mentre UTF-8 li decodifica in tutta la gamma di Unicode. Per il significato di ogni byte da 00 a 7F, consulta la tabella ASCII.
    Quanti byte occupa un carattere cinese in hex?
    Dipende dalla codifica. In UTF-8 la maggior parte dei caratteri cinesi occupa 3 byte: 你 è E4 BD A0. In GBK e GB2312 ne occupa 2: 你 è C4 E3. In UTF-16 i caratteri del Piano Multilingue di Base occupano 2 byte, e l'ordine dei byte conta: 你 è 60 4F in UTF-16LE e 4F 60 in UTF-16BE. I caratteri rari fuori da quel piano occupano 4 byte in UTF-8, 4 in UTF-16 (una coppia surrogata) e 4 in GB18030. Cambia la codifica nella scheda Testo → Hex per vedere quanti byte occupa il tuo testo.
    Come si converte hex in stringa in Python?
    Usa bytes.fromhex() e poi decodifica: bytes.fromhex('48656c6c6f').decode('utf-8') restituisce 'Hello'. fromhex accetta spazi tra i byte, quindi funziona anche bytes.fromhex('48 65 6c 6c 6f'), ma rifiuta un prefisso 0x con un ValueError. Per i dati GBK decodifica con 'gbk': bytes.fromhex('c4e3bac3').decode('gbk') restituisce '你好', mentre decodificare gli stessi byte come UTF-8 solleva UnicodeDecodeError. L'operazione inversa è '你好'.encode('utf-8').hex(), che restituisce 'e4bda0e5a5bd'; passa un separatore, come in .hex(' '), per un output separato da spazi.
    Come si converte hex in stringa in JavaScript?
    In Node.js Buffer.from('48656c6c6f', 'hex').toString('utf8') restituisce 'Hello'. Attenzione all'input errato: Node non lancia eccezioni — si ferma alla prima coppia non valida e scarta in silenzio un'ultima cifra dispari, quindi Buffer.from('486', 'hex') è un buffer di un solo byte. Nel browser costruisci tu i byte e usa TextDecoder, che legge anche GBK: new TextDecoder('gbk').decode(Uint8Array.from('c4e3bac3'.match(/../g), h => parseInt(h, 16))) restituisce '你好'. Non usare charCodeAt() per ottenere i byte: '你'.charCodeAt(0).toString(16) è '4f60', un'unità di codice UTF-16, non i byte UTF-8 e4bda0.
    Come si converte una stringa esadecimale in testo in C o C++?
    Leggi due cifre hex alla volta in un buffer di unsigned char, poi aggiungi il terminatore: for (size_t i = 0; i < n; i++) sscanf(hex + 2 * i, "%2hhx", &buf[i]); buf[n] = '\0'; dove n è strlen(hex) / 2. Con hex impostato a 48656c6c6f2c20e4b896e7958c, stampare buf dà Hello, 世界 su un terminale UTF-8. Per la direzione opposta stampa ogni byte con printf("%02X ", (unsigned char)s[i]). Il cast è importante: sulle piattaforme dove char ha segno, un byte come 0xE4 verrebbe altrimenti esteso con segno e stampato come FFFFFFE4. In C++ aggiungi ogni coppia alla stringa con s.push_back(static_cast<char>(std::stoi(hex.substr(i, 2), nullptr, 16))); lo stesso hex dà Hello, 世界.
    Come si converte l'hex in testo in Java, e perché stampa ffffffe4?
    Da Java 17 in poi basta una riga: new String(HexFormat.of().parseHex(hex), StandardCharsets.UTF_8); per dati GBK usa invece Charset.forName("GBK"). Nella direzione opposta, la sorpresa classica è ffffffe4, perché il byte di Java ha segno e Integer.toHexString() accetta un int. Il byte 0xE4 è memorizzato come -28; convertito in int mantiene il valore -28, e toHexString stampa i numeri negativi come valore senza segno a 32 bit, ffffffe4. Lo stesso metodo elimina anche gli zeri iniziali, quindi 0x0A diventa a. Usa String.format("%02x", b), che formatta un byte negativo come valore senza segno a 8 bit, oppure Integer.toHexString(b & 0xff) aggiungendo gli zeri iniziali. Da Java 17 in poi HexFormat.of().formatHex(bytes) converte un intero array e HexFormat.of().parseHex(hex) fa il percorso inverso.
    Quale funzione PHP converte hex in stringa?
    hex2bin() decodifica una stringa hex in una stringa binaria e bin2hex() fa il contrario: bin2hex('Hello') restituisce 48656c6c6f. Secondo il manuale PHP, hex2bin() restituisce false ed emette un E_WARNING quando l'input ha lunghezza dispari o non è esadecimale valido, quindi togli spazi e prefissi 0x prima di chiamarla. Le stringhe PHP sono byte, quindi il risultato ha la codifica usata dal testo originale — converti l'output GBK con mb_convert_encoding() se la tua pagina è in UTF-8.
    Posso incollare direttamente l'output di xxd o hexdump?
    Sì. La colonna degli offset e quella dei caratteri vengono riconosciute e rimosse, e la riga sotto il riquadro di input ti dice che è successo. È importante perché un convertitore che rimuove solo gli spazi legge gli offset come dati. La pagina gestisce xxd (inclusi -u, -c e -g), hexdump -C, hex.Dump di Go, od -A x -t x1 e od -t x1z di GNU, ed espande la riga * che hexdump e od stampano al posto delle righe ripetute. Gestisce anche hexdump semplice e od -x, che stampano parole a 16 bit invece di byte: su una macchina little-endian i byte 48 69 vengono stampati come 6948, quindi la pagina rimette in ordine ogni coppia e usa l'ultimo offset per scartare il byte di riempimento aggiunto ai dati di lunghezza dispari. Ogni variante di xxd, hexdump e od è stata testata su 600 dump reali di dati casuali.
    Che cosa significa un numero dispari di cifre hex?
    Che qualcosa è andato perso o è stato aggiunto, perché ogni byte è esattamente due cifre hex. Le cause tipiche sono uno zero iniziale eliminato da una funzione di conversione da numero a hex (a invece di 0a), un carattere tagliato durante la copia o una lettera finita lì per sbaglio, come O al posto di 0. Una stringa hex ottenuta convertendo tutti i byte come un unico grande numero, come hex(int.from_bytes(data, 'big')) di Python, perde lo zero iniziale: \r\n diventa 0xd0a. La pagina non prova a indovinare quale cifra manca, perché un'ipotesi sbagliata sposta di mezzo byte tutti i byte successivi e produce un risultato assurdo ma credibile. Offre invece due correzioni con un clic — aggiungere uno 0 all'inizio o rimuovere l'ultima cifra — così puoi confrontare i risultati. I valori scritti singolarmente con un prefisso, come 0x0 0xa, vanno bene: ognuno viene letto come un byte intero.
    I dati che incollo vengono caricati da qualche parte?
    No. La conversione gira in JavaScript nel tuo browser: niente viene inviato a un server, memorizzato o aggiunto all'URL della pagina. Puoi verificarlo nel pannello Rete degli strumenti per sviluppatori del browser. Qui conta, perché l'esadecimale incollato in un convertitore è spesso una cattura di pacchetti, un dump di firmware o una riga di un log di produzione.

    Strumenti correlati

    Vedi tutti gli strumenti →

    Tabella ASCII e convertitore di caratteri

    Codifica e formattazione

    La tabella ASCII completa: 128 caratteri in decimale, esadecimale, ottale e binario, più un convertitore online testo ↔ ASCII. Ogni carattere di controllo ha il suo escape, la notazione caret e dove lo incontri.

    Decodificatore e codificatore Base64

    Codifica e formattazione

    Decodifica e codifica Base64 online gratis. Conversione in tempo reale con pieno supporto UTF-8 ed emoji. 100% privato — gira nel tuo browser. Nessuna registrazione.

    Convertitore da Base64 a immagine

    Codifica e formattazione

    Decodifica una stringa Base64 o un data URI in un'immagine nel tuo browser. Anteprima, dimensioni e MIME, poi scarica come PNG, JPG, GIF, SVG. Nessun upload.

    Convertitore CSV in JSON

    Codifica e formattazione

    Converti CSV in JSON nel browser. RFC 4180, inferenza tipi, riga header, sicuro per big-int. 100% privato, nessun upload.

    Convertitore di Codifica e Riparazione Mojibake

    Codifica e formattazione

    Incolla il testo illeggibile e riottieni l'originale. Ogni catena di codifica plausibile — UTF-8, GBK, Big5, Shift_JIS, EUC-KR, Windows-1252 — viene provata e ordinata, con la catena esatta in chiaro. Gratis e tutto in locale.

    Convertitore da .env a JSON

    Codifica e formattazione

    Incolla un file .env online e ottieni subito il JSON. Password, chiavi API e token non lasciano mai il browser: parser dotenv web, 100% privato, senza upload.