Hex naar tekst omzetten (en tekst naar hex)

Hex naar ASCII: snelle antwoorden

Wat is hex naar tekst omzetten?

$ 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

Wat deze hexconverter doet

Hex naar string omzetten in code

Voorbeelden van hex naar tekst

48 65 6C 6C 6F 2C 20 E4 B8 96 E7 95 8C

Hello, 世界

CE C2 B6 C8 3A 32 35 2E 33 A1 E6

温度:25.3℃

00000000: 4869 20e4 bda0 e5a5 bd0d 0a              Hi ........

Hi 你好␍␊

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

中文

AT+CSQ\r\n

41 54 2B 43 53 51 0D 0A

653462646130653561356264

e4bda0e5a5bd → 你好

Zo zet je hex om naar tekst

1. 1

   Plak de hex

   Plak hem in het vak op het tabblad Hex → tekst, in welke vorm je hem ook hebt: met spaties, compact, 0x-waarden, \x-escapes, een byte-array of een compleet xxd-scherm. De regel onder het vak vertelt hoe hij is gelezen.

2. 2

   Controleer de tekst en de codering

   De tekst verschijnt rechts, met de automatisch gedetecteerde codering en de reden daarvoor. Zit de gok ernaast, dan toont de tabel eronder elke lezing; kies de juiste in het menu Codering.

3. 3

   Let op onzichtbare tekens

   Stuurbytes zoals NUL, CR en LF worden getoond als ␀ ␍ ␊. Vink Onzichtbare tekens tonen uit voor de platte tekst en kopieer daarna het resultaat.

4. 4

   Of zet tekst om naar hex

   Kies op het tabblad Tekst → hex de codering en een uitvoerformaat — hex met spaties, 0x-waarden, een C-, Java-, Python- of Go-array, of een xxd-dump. Vink CR LF aan voor seriële protocollen en netwerkprotocollen.

Waarom hex naar tekst omzetten misgaat

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

>>> bytes.fromhex('c4e3bac3').decode('gbk')
'你好'

'你'.charCodeAt(0).toString(16)   // '4f60' — a UTF-16 code unit

Buffer.from('你', 'utf8').toString('hex')   // 'e4bda0' — the UTF-8 bytes

Integer.toHexString(b)        // "ffffffe4" for 0xE4, "a" for 0x0A

String.format("%02x", b)      // "e4", "0a"

Buffer.from('486', 'hex')      // <Buffer 48> — the 6 is silently dropped
Buffer.from('48zz65', 'hex')   // <Buffer 48> — stops at zz

if (!/^([0-9a-f]{2})*$/i.test(hex)) throw new Error('invalid hex');
Buffer.from(hex, 'hex');

00000000: 4869 20e4 bda0 e5a5 bd0d 0a              Hi ........
→ read naively: 00 00 00 00 48 69 20 e4 …

$ printf 'Hi 你好\r\n' | xxd -p
486920e4bda0e5a5bd0d0a

41 54 2B 43 53 51 0A      AT+CSQ followed by LF only

41 54 2B 43 53 51 0D 0A   AT+CSQ followed by CR LF

Wanneer je hex naar tekst moet omzetten

Seriële verbindingen en UART debuggen

Seriële terminals tonen ontvangen data als hex. Plak een frame om de tekst erin te lezen en de 0D 0A of 00 aan het eind te zien — of werk andersom en bouw een commando met CR LF-regeleinden dat een apparaat accepteert.

Pakketcaptures lezen

Protocolpayloads die je uit Wireshark of tcpdump kopieert, zijn hex. Een requestregel, een JSON-body of een apparaatnaam in een frame decoderen gaat hier sneller dan een script schrijven, en niets verlaat je computer.

Byte-arrays in applicatielogs

Java logt byte-arrays als signed decimale getallen, Python als b'...'-literals en Node.js als <Buffer ...>. Plak het logfragment zoals het is om de tekst te zien, inclusief of het UTF-8 of GBK was.

Hexkolommen en BLOB's in databases

Databasetools tonen binaire kolommen als hex. Decodeer een waarde om te controleren wat er werkelijk is opgeslagen, of zet tekst om naar hex om byte voor byte te vergelijken met wat de database bevat.

Strings in firmware en C-broncode

Embedded code bewaart tekst in byte-arrays. Maak van een string een C-array die je direct kunt plakken, of lees een array uit een headerbestand terug als tekst om te bevestigen wat het apparaat zal afdrukken.

Van hex naar tekst: ASCII, UTF-8, GBK en UTF-16

Twee hexcijfers per byte

Een byte bevat 8 bits en een hexcijfer 4, dus elke byte is precies twee hexcijfers, 00 tot FF, en het aantal bytes is altijd de helft van het aantal cijfers. Hoofdletters en kleine letters betekenen hetzelfde. Scheidingstekens, prefixen en array-syntaxis zijn alleen notatie: 4865, 48 65, 0x48, 0x65 en \x48\x65 zijn dezelfde twee bytes.

ASCII: de bytes waarover elke codering het eens is

ASCII wijst 00 tot 7F toe. Afdrukbare tekens lopen van 20 (spatie) tot 7E (~); de rest zijn stuurtekens, waarvan 00 (NUL), 09 (tab), 0A (line feed), 0D (carriage return) en 1B (escape) het vaakst in echte data voorkomen. UTF-8, GBK en ISO-8859-1 behouden deze waarden allemaal, en daarom overleeft gewoon Engels bijna elke verkeerde codering.

UTF-8: één tot vier bytes per teken

UTF-8 schrijft ASCII als losse bytes en elk ander teken als een reeks. De eerste byte geeft de lengte aan — C2–DF voor twee bytes, E0–EF voor drie, F0–F4 voor vier — en elke volgende byte moet in 80–BF liggen. Door die strikte structuur is een GBK-zin bijna nooit geldige UTF-8 — in onze test met 33.910 Chinese zinnen gold dat voor 55 — en daarom vertrouwt automatische detectie op een foutloze UTF-8-decodering. Een los Chinees teken is een ander verhaal: ongeveer 18% van de GBK-tekens vormt toevallig een geldige UTF-8-reeks van twee bytes.

GBK: twee bytes per Chinees teken

GBK houdt ASCII als losse bytes en encodeert Chinese tekens en leestekens in volle breedte als twee bytes: een eerste byte van 81 tot FE, gevolgd door een tweede byte van 40 tot FE, met uitzondering van 7F. Omdat het bereik van die tweede byte zo breed is, laat korte UTF-8-tekst zich als GBK vaak zonder enige fout decoderen tot tekens die er niets mee te maken hebben — E4 BD A0 E5 A5 BD (你好) wordt 浣犲ソ — en daarom probeert deze pagina eerst UTF-8. GB18030 breidt GBK uit met reeksen van vier bytes voor zeldzamere tekens; de decodering hier accepteert die.

UTF-16 en bytevolgorde

UTF-16 gebruikt twee bytes per teken (vier voor tekens buiten het Basic Multilingual Plane), en die twee bytes kunnen in beide volgordes staan. UTF-16LE zet de lage byte eerst — A is 41 00 — en UTF-16BE de hoge byte — 00 41. Windows-API's en veel bestanden gebruiken little-endian en kunnen beginnen met een byte-order mark, FF FE; UTF-8-bestanden beginnen soms met EF BB BF. Automatische detectie verwijdert een byte-order mark en meldt dat.

Hex en strings betrouwbaar omzetten

Benoem de codering aan beide kanten

Hex alleen zegt niet met welke codering het is gemaakt. Overal waar tekst in bytes verandert — getBytes(), encode(), een instelling van een seriële terminal, de charset van een databaseverbinding — stel je de codering expliciet in en noteer je die naast de hex, zodat de andere kant niet hoeft te raden.

Werk met bytes, niet met tekencodes

Functies die tekencodes teruggeven, zoals charCodeAt() in JavaScript of char-waarden in Java, leveren UTF-16-code-units op in plaats van geëncodeerde bytes. Encodeer de string eerst met TextEncoder, Buffer.from() of getBytes(StandardCharsets.UTF_8) en formatteer daarna de bytes.

Vul elke byte altijd aan tot twee cijfers

Gebruik %02x of iets gelijkwaardigs, nooit een kale getal-naar-hexaanroep. a en 0a lijken in een log op elkaar, maar waarden zonder opvulling aan elkaar plakken levert een string met een oneven lengte op, of erger, een die naar andere bytes decodeert.

Houd scheidingstekens consistent binnen één log

Kies één formaat voor logs en traces, zoals paren gescheiden door spaties, en houd je daaraan. Gemengde formaten zijn voor mensen makkelijk te lezen en voor scripts makkelijk verkeerd te lezen, vooral als sommige waarden zijn opgevuld en andere niet.

Controleer het aantal bytes

Voordat je een omzetting vertrouwt, vergelijk je het aantal bytes met wat je verwacht: het lengteveld in een protocolheader, de kolomgrootte of de bestandsgrootte. De pagina toont het aantal voor beide richtingen.

Veelgestelde vragen over hex naar tekst