Skip to content

Перевод hex в текст и обратно: конвертер hex в строку

Перевод hex в текст и текста в hex. Вставьте hex в любом виде: с пробелами, 0x, \x, вывод xxd или hexdump, массивы байтов Java и C. ASCII, UTF-8, GBK и UTF-16 определяются сами. Всё в браузере.

Без отслеживания Работает в браузере Бесплатно
Преобразование выполняется целиком в браузере — вставленные данные не покидают это устройство.
Попробуйте пример

Формат: чистый hex · байт: 13

    Текст
    Hello, 世界

    Автоопределение: UTF-8 — все многобайтовые последовательности корректны.

    Те же байты во всех кодировках

    Кодировка Прочтение
    UTF-8 Декодируется без ошибок Hello, 世界
    GBK / GB18030 Декодируется без ошибок Hello, 涓栫晫
    UTF-16LE Есть недекодируемые байты 效汬Ɐ隸闧�
    UTF-16BE Есть недекодируемые байты 䡥汬漬⃤뢖�
    ISO-8859-1 Декодируется без ошибок Hello, ä¸<96>ç<95><8C>
    Hex-дампы, массивы байтов и сообщения об ошибках, приведённые здесь, взяты из реальных запусков xxd, Python 3.14, Node.js 26, Go 1.27 и clang, а тесты подтверждают, что каждый формат вывода движка читается обратно в исходные байты. Поведение Java и PHP описано по официальной документации. — Инженерная команда Go Tools · Sep 16, 2026

    Написано и проверено разработчиками, которые создают инструменты кодирования Go Tools. Каждое hex-значение и каждый результат на этой странице получены собственным движком страницы и проверены автоматическими тестами.

    Быстрые ответы: hex в ASCII

    Что означает 48 65 6C 6C 6F в виде текста?

    Hello В ASCII и UTF-8 48 — это H, 65 — e, 6C — l, а 6F — o.

    Сколько байтов занимает один китайский иероглиф?

    Обычно 3 байта в UTF-8, 2 в GBK 你 — это E4 BD A0 в UTF-8 и C4 E3 в GBK.

    Что такое 0D 0A?

    CR LF (\r\n) Возврат каретки и следом перевод строки — окончание строки, принятое в Windows, HTTP и большинстве наборов команд для последовательного порта.

    Как буква A записывается в hex?

    41 Строчная a — это 61; заглавная и строчная буквы всегда отличаются на 20.

    Что такое перевод hex в строку?

    Шестнадцатеричная запись (hex) — это способ записывать байты: каждый байт, от 0 до 255, записывается двумя цифрами от 00 до FF. Перевод hex в строку превращает эти байты обратно в читаемый текст, и он всегда требует выбрать кодировку символов — таблицу, которая говорит, какой байт или какая последовательность байтов обозначает какой символ.

    Для английского текста этот выбор почти незаметен, потому что ASCII, UTF-8, GBK и большинство других кодировок совпадают на байтах от 00 до 7F. Со всем остальным он проявляется сразу. Байты C4 E3 BA C3 — это 你好 в GBK и некорректная последовательность в UTF-8, тогда как 你好 в UTF-8 — это E4 BD A0 E5 A5 BD. Hex — лишь половина информации; вторая половина — кодировка.

    Преобразование текста в hex — обратная операция: текст кодируется в байты, и каждый байт записывается двумя шестнадцатеричными цифрами. Разработчики пользуются им, чтобы увидеть, что именно уходит в последовательный порт или в столбец базы данных, чтобы вставить двоичные данные в исходный код и чтобы сравнить, что на самом деле отправили две системы.

    $ 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

    Что умеет этот hex-конвертер

    Hex в любом виде

    С пробелами, слитно, через двоеточия или дефисы, значения 0x, экранирование \x, кодирование через %, массивы C, Go и Java, знаковый вывод Arrays.toString из Java, литералы bytes из Python, Buffer из Node.js и полные экраны xxd, hexdump -C и od. Страница сообщает, что распознала и что удалила.

    Кодировка определяется — с объяснением

    Автоопределение проверяет метку порядка байтов, корректный UTF-8, UTF-16, чистый ASCII и затем GBK и сообщает, какое правило сработало. GBK выбирается, только если байты читаются как распространённые китайские иероглифы, поэтому короткие двоичные кадры помечаются как «вероятно, не текст», а не выдаются бессмысленными иероглифами.

    Все кодировки рядом

    Одни и те же байты показаны как UTF-8, GBK, UTF-16LE, UTF-16BE и ISO-8859-1, и для каждого варианта отмечено, декодируется ли он без ошибок. Если текст вышел кракозябрами, правильное прочтение обычно строкой ниже.

    Невидимые байты становятся видимыми

    NUL, CR, LF, ESC и другие управляющие байты показываются как ␀ ␍ ␊ ␛, так что лишний 00 в конце или пропущенный 0D в данных протокола сразу бросаются в глаза. При копировании по-прежнему получаются настоящие символы.

    Вывод, готовый для вставки в код

    Текст → Hex выдаёт hex через пробел или слитно, списки 0x, экранирование \x, массив C в стиле xxd -i, Java byte[] со знаковыми значениями, литерал bytes для Python в точности как у repr(), Go []byte или дамп xxd — и страница умеет прочитать каждый из этих форматов обратно.

    Ничего не покидает браузер

    Разбор и декодирование выполняются локально на JavaScript. Ничего не загружается, не сохраняется и не попадает в URL, поэтому дампы трафика и продакшен-логи можно вставлять спокойно.

    Перевод hex в строку в коде

    Python 3

    bytes.fromhex(h).decode()

    bytes.fromhex('48 65 6c 6c 6f').decode('utf-8') возвращает 'Hello'; пробелы между байтами допустимы, префикс 0x — нет. Обратное преобразование — s.encode('utf-8').hex() или .hex(' ') для вывода через пробел. Передайте 'gbk', чтобы декодировать или закодировать китайский текст в GBK.

    JavaScript (Node.js)

    Buffer.from(h, 'hex')

    Buffer.from(h, 'hex').toString('utf8') декодирует, Buffer.from(s, 'utf8').toString('hex') кодирует. Некорректный ввод не считается ошибкой: декодирование останавливается на первой плохой паре, а последняя непарная цифра отбрасывается, поэтому сначала проверяйте ввод.

    JavaScript (браузер)

    TextDecoder / TextEncoder

    Разберите пары через parseInt(pair, 16) в Uint8Array, затем вызовите new TextDecoder('utf-8').decode(bytes). TextDecoder читает также 'gbk', 'big5' и 'shift_jis', но TextEncoder выдаёт только UTF-8.

    Java 17+

    HexFormat.of()

    new String(HexFormat.of().parseHex(h), StandardCharsets.UTF_8) декодирует, а HexFormat.of().formatHex(s.getBytes(StandardCharsets.UTF_8)) кодирует. В более старых версиях форматируйте каждый байт через String.format("%02x", b); избегайте Integer.toHexString(b), который печатает ffffffe4 для отрицательных байтов.

    Go

    encoding/hex

    hex.DecodeString(h) возвращает байты, а string(b) превращает их в строку; hex.EncodeToString([]byte(s)) выполняет обратное преобразование. Пакет строгий: на пробелы он возвращает invalid byte: U+0020 ' ', а на нечётную длину — odd length hex string.

    C

    sscanf with %2hhx

    Проходите по строке по две цифры, записывая байты в буфер unsigned char, и добавьте завершающий '\0'. Чтобы напечатать hex, приводите к unsigned char и используйте %02X, иначе там, где char знаковый, байты выше 0x7F могут напечататься как FFFFFFE4.

    PHP

    hex2bin() / bin2hex()

    hex2bin('48656c6c6f') возвращает Hello, а bin2hex('Hello') возвращает 48656c6c6f. В руководстве указано, что при нечётной длине или некорректном вводе hex2bin() возвращает false с E_WARNING.

    Shell (xxd)

    xxd -r -p / xxd -p

    echo 48656c6c6f | xxd -r -p печатает Hello, а printf 'Hello' | xxd -p печатает 48656c6c6f. При кодировании используйте printf, а не echo, потому что echo добавляет в конце перевод строки, 0a.

    C# (.NET 5+)

    Convert.FromHexString()

    Encoding.UTF8.GetString(Convert.FromHexString(h)) декодирует, а Convert.ToHexString(Encoding.UTF8.GetBytes(s)) кодирует (заглавными буквами, без разделителей). FromHexString не принимает пробелы и префикс 0x. В .NET Core и .NET 5+ нет встроенной поддержки GBK: сначала вызовите Encoding.RegisterProvider(CodePagesEncodingProvider.Instance), затем Encoding.GetEncoding(936).

    Примеры перевода hex в текст

    Hex в UTF-8 с китайскими иероглифами

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

    Первые семь байтов — обычный ASCII: 48 65 6C 6C 6F — это Hello, 2C — запятая, 20 — пробел. E4 B8 96 и E7 95 8C — трёхбайтовые последовательности UTF-8 для 世 и 界: большинство китайских иероглифов занимает в UTF-8 три байта. Все последовательности корректны, поэтому автоопределение читает ввод как UTF-8.

    Показания датчика в GBK, некорректные как UTF-8

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

    Многие устройства с последовательным портом передают китайский текст в GBK. Здесь CE C2 — это 温, B6 C8 — 度, 3A 32 35 2E 33 — ASCII-строка :25.3, а A1 E6 — полноширинный знак ℃: по два байта на каждый китайский иероглиф или символ. Как UTF-8 эти байты некорректны (CE открывает двухбайтовую последовательность, но C2 не является байтом продолжения), а как GBK читаются распространёнными символами, поэтому автоопределение выбирает GBK. Конвертер, знающий только UTF-8, покажет здесь символы замены.

    Вывод xxd, вставленный как есть

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

    Именно это печатает printf 'Hi 你好\r\n' | xxd. Смещение 00000000: и символьный столбец справа удаляются перед декодированием; если прочитать их как данные, одни только восемь нулей дадут четыре байта NUL в начале. Последние два байта, 0d 0a, — это перевод строки в стиле Windows, он показан как ␍␊.

    Массив байтов Java из лога

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

    Arrays.toString(bytes) печатает знаковые байты Java в десятичном виде. Отрицательные значения — это байты от 0x80 и выше: -28 — это 256 − 28 = 228 = 0xE4. Шесть байтов E4 B8 AD E6 96 87 — это кодировка UTF-8 для 中文.

    Текст в hex для AT-команды по последовательному порту

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

    Модемы и большинство наборов команд UART ожидают, что каждая команда заканчивается возвратом каретки и переводом строки. Текстовое поле по Enter даёт только 0A, поэтому отметьте Переводы строк как CR LF — и окончание строки станет 0D 0A.

    Hex, дважды закодированный в hex

    653462646130653561356264
    e4bda0e5a5bd → 你好

    Каждый байт здесь — ASCII-код шестнадцатеричной цифры (65 — это e, 34 — 4, 62 — b), поэтому первое декодирование даёт ещё одну hex-строку. Так бывает, когда hex-строку принимают за текст и конвертируют повторно. Страница предлагает второй проход, который даёт 你好. Чтобы не было ложных срабатываний, он предлагается, только если первый результат содержит не меньше 12 шестнадцатеричных цифр, а второй декодируется в осмысленный текст: даты, метки времени, значения CRC32 и хеши MD5 его не вызывают.

    Как перевести hex в текст

    1. 1

      Вставьте hex

      Вставьте его в поле на вкладке Hex → Текст в том виде, какой есть: с пробелами, слитно, значения 0x, экранирование \x, массив байтов или целый экран xxd. Строка под полем сообщает, как он был прочитан.

    2. 2

      Проверьте текст и кодировку

      Текст появляется справа вместе с автоматически определённой кодировкой и причиной выбора. Если догадка неверна, в таблице ниже есть все варианты прочтения — выберите нужный в меню «Кодировка».

    3. 3

      Найдите невидимые символы

      Управляющие байты, например NUL, CR и LF, показываются как ␀ ␍ ␊. Снимите флажок «Показывать невидимые символы», чтобы увидеть чистый текст, и скопируйте результат.

    4. 4

      Или переведите текст в hex

      На вкладке Текст → Hex выберите кодировку и формат вывода — hex через пробел, значения 0x, массив для C, Java, Python или Go либо дамп xxd. Для последовательных и сетевых протоколов отметьте CR LF.

    Типичные ошибки при переводе hex в текст

    Декодирование байтов GBK как UTF-8

    Китайский текст из старых программ для Windows, многих устройств с последовательным портом и унаследованных баз данных — это GBK. При декодировании как UTF-8 либо возникает ошибка, либо вывод заполняется символами замены. Посмотрите на таблицу кодировок и возьмите осмысленный вариант прочтения.

    ✗ Неверно
    >>> 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() для получения байтов в JavaScript

    charCodeAt() возвращает кодовую единицу UTF-16. Для ASCII она случайно совпадает с байтом, поэтому ошибка проявляется только на других символах, где результат не совпадает с тем, что отправляет любая система на UTF-8.

    ✗ Неверно
    '你'.charCodeAt(0).toString(16)   // '4f60' — a UTF-16 code unit
    ✓ Верно
    Buffer.from('你', 'utf8').toString('hex')   // 'e4bda0' — the UTF-8 bytes

    Форматирование знаковых байтов через Integer.toHexString в Java

    byte в Java знаковый, поэтому байты от 0x80 и выше отрицательны. Integer.toHexString() работает с int, печатает отрицательные значения как беззнаковый 32-битный hex и отбрасывает ведущие нули.

    ✗ Неверно
    Integer.toHexString(b)        // "ffffffe4" for 0xE4, "a" for 0x0A
    ✓ Верно
    String.format("%02x", b)      // "e4", "0a"

    Непроверенный hex в Buffer.from() из Node.js

    Buffer.from(hex, 'hex') никогда не выбрасывает исключение. Он останавливается на первой паре, которая не является корректным hex, и игнорирует последнюю непарную цифру, так что опечатка даёт более короткий буфер вместо ошибки.

    ✗ Неверно
    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');

    Hex-дамп, вставленный со столбцом смещений

    Конвертер, который только удаляет пробелы, читает смещение 00000000: как данные, а символьный столбец — как дополнительный hex там, где это получается. Результат начинается с байтов NUL и дальше расползается. Используйте xxd -p для чистого 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

    LF там, где устройство ждёт CR LF

    AT-модемы и многие строчно-ориентированные протоколы завершают каждую команду возвратом каретки и переводом строки. Команда, которая заканчивается одним 0A, часто просто игнорируется без всякой ошибки.

    ✗ Неверно
    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

    Когда нужен конвертер hex в строку

    Отладка последовательного порта и UART
    Терминалы последовательного порта показывают принятые данные в hex. Вставьте кадр, чтобы прочитать текст внутри и заметить 0D 0A или 00 в конце, — или идите в обратную сторону и соберите команду с окончаниями строк CR LF, которую устройство примет.
    Разбор перехваченных пакетов
    Содержимое пакетов (payload), скопированное из Wireshark или tcpdump, — это hex. Декодировать строку запроса, тело JSON или имя устройства внутри кадра здесь быстрее, чем писать скрипт, и ничего не покидает ваш компьютер.
    Массивы байтов в логах приложений
    Java пишет массивы байтов в лог знаковыми десятичными числами, Python — литералами b'...', а Node.js — в виде <Buffer ...>. Вставьте фрагмент лога как есть, чтобы увидеть текст и заодно узнать, был он в UTF-8 или в GBK.
    Hex-столбцы и BLOB в базах данных
    Клиенты баз данных показывают двоичные столбцы в hex. Декодируйте значение, чтобы проверить, что на самом деле сохранено, или переведите текст в hex, чтобы побайтно сравнить его с тем, что хранится в базе.
    Строки в прошивках и исходниках на C
    Встраиваемый код хранит текст в массивах байтов. Превратите строку в массив C, готовый к вставке, или прочитайте массив из заголовочного файла обратно как текст, чтобы убедиться, что именно выведет устройство.

    Как hex превращается в текст: ASCII, UTF-8, GBK и UTF-16

    Две шестнадцатеричные цифры на байт
    Байт содержит 8 бит, а одна шестнадцатеричная цифра — 4, поэтому каждый байт — это ровно две цифры, от 00 до FF, и число байтов всегда вдвое меньше числа цифр. Верхний и нижний регистр означают одно и то же. Разделители, префиксы и синтаксис массивов — лишь форма записи: 4865, 48 65, 0x48, 0x65 и \x48\x65 — это одни и те же два байта.
    ASCII: байты, в которых сходятся все кодировки
    ASCII занимает диапазон от 00 до 7F. Печатные символы идут от 20 (пробел) до 7E (~); остальные — управляющие символы, из которых в реальных данных чаще всего встречаются 00 (NUL), 09 (табуляция), 0A (перевод строки), 0D (возврат каретки) и 1B (escape). UTF-8, GBK и ISO-8859-1 сохраняют эти значения, поэтому обычный английский текст переживает почти любую неверную кодировку.
    UTF-8: от одного до четырёх байтов на символ
    UTF-8 записывает ASCII одиночными байтами, а все остальные символы — последовательностями. Первый байт задаёт длину — C2DF для двух байтов, E0EF для трёх, F0F4 для четырёх, — а каждый следующий байт обязан лежать в диапазоне 80BF. Из-за этой строгой структуры предложение в GBK почти никогда не оказывается корректным UTF-8 — в нашем тесте на 33 910 китайских предложениях таких нашлось 55, — и поэтому автоопределение доверяет чистому декодированию UTF-8. С одиночным иероглифом всё иначе: около 18% символов GBK случайно образуют корректную двухбайтовую последовательность UTF-8.
    GBK: два байта на китайский иероглиф
    GBK сохраняет ASCII в виде одиночных байтов, а китайские иероглифы и полноширинную пунктуацию кодирует двумя: ведущий байт от 81 до FE и следующий за ним байт от 40 до FE, кроме 7F. Поскольку диапазон второго байта так широк, короткий текст в UTF-8, прочитанный как GBK, часто без единой ошибки декодируется в посторонние символы — E4 BD A0 E5 A5 BD (你好) превращается в 浣犲ソ, — поэтому эта страница сначала пробует UTF-8. GB18030 расширяет GBK четырёхбайтовыми последовательностями для более редких иероглифов; декодер здесь их принимает.
    UTF-16 и порядок байтов
    UTF-16 использует два байта на символ (четыре — для символов за пределами базовой многоязычной плоскости), и эти два байта могут идти в любом порядке. UTF-16LE ставит первым младший байт (A записывается как 41 00), а UTF-16BE — старший (00 41). В Windows API и во многих файлах принят little-endian, а в начале может стоять метка порядка байтов FF FE; файлы в UTF-8 иногда начинаются с EF BB BF. Автоопределение удаляет метку порядка байтов и сообщает об этом.

    Как надёжно переводить hex в строки и обратно

    Указывайте кодировку на обеих сторонах
    Сам по себе hex не говорит, какая кодировка его породила. Везде, где текст превращается в байты, — getBytes(), encode(), настройка терминала последовательного порта, кодировка соединения с базой данных — задавайте кодировку явно и записывайте её рядом с hex, чтобы другой стороне не пришлось гадать.
    Работайте с байтами, а не с кодами символов
    Функции, возвращающие коды символов, например charCodeAt() в JavaScript или значения char в Java, дают кодовые единицы UTF-16, а не закодированные байты. Сначала закодируйте строку через TextEncoder, Buffer.from() или getBytes(StandardCharsets.UTF_8), а затем форматируйте байты.
    Всегда дополняйте каждый байт до двух цифр
    Используйте %02x или аналог, а не голый вызов перевода числа в hex. В логе a и 0a выглядят похоже, но склейка значений без дополнения даёт строку нечётной длины или, хуже того, строку, которая декодируется в другие байты.
    Держите разделители единообразными в пределах одного лога
    Выберите один формат для логов и трассировок, например пары через пробел, и придерживайтесь его. Смешанные форматы людям читать легко, а скриптам — легко прочитать неправильно, особенно когда одни значения дополнены нулями, а другие нет.
    Проверяйте число байтов
    Прежде чем доверять результату, сравните число байтов с ожидаемым: с полем длины в заголовке протокола, размером столбца или размером файла. Страница показывает число байтов в обоих направлениях.

    Частые вопросы о переводе hex в текст

    Как перевести hex в текст?
    Вставьте hex в поле на вкладке Hex → Текст — текст появится сразу. Вручную это делается в два шага. Сначала разбейте hex на пары: каждая пара шестнадцатеричных цифр — это один байт от 00 до FF, так что 48656c6c6f — это пять байтов 48, 65, 6C, 6C, 6F. Затем декодируйте эти байты в какой-либо кодировке символов. В ASCII и UTF-8 48 — это H, 65 — e, 6C — l, а 6F — o, получается Hello. Именно на втором шаге результаты расходятся: байты выше 7F означают разные символы в UTF-8, GBK и других кодировках, поэтому страница определяет кодировку и показывает все варианты прочтения рядом.
    Почему после перевода hex получаются кракозябры?
    Почти всегда потому, что байты декодированы не в той кодировке. Классический случай — китайский текст: C4 E3 BA C3 — это 你好 в GBK, но некорректный UTF-8, а E4 BD A0 E5 A5 BD — это 你好 в UTF-8, но при чтении как GBK превращается в 浣犲ソ. Посмотрите на таблицу кодировок под результатом: строка, в которой получился осмысленный текст, и есть кодировка, в которой данные были записаны. Когда символов всего один-два, автоопределение не всегда может решить: D2 BB — корректный UTF-8 (һ) и одновременно GBK (一), поэтому проверьте строку GBK, которую страница показывает под результатом. Стоит исключить ещё две причины: лишнюю или пропущенную шестнадцатеричную цифру, из-за которой все последующие байты сдвигаются на полбайта, и hex-дамп, вставленный вместе со столбцом смещений. Если у вас не hex, а уже готовые кракозябры (например, 浣犲ソ), вставьте этот текст в конвертер кодировок.
    Почему данные с последовательного порта в виде текста — кракозябры, а в hex всё верно?
    Если hex правильный, то скорость передачи, биты данных и чётность настроены верно — при ошибке в них менялись бы сами байты. Проблема в шаге, который превращает байты в символы, и обычно причина одна из трёх. Данные могут вообще не быть текстом: двоичный протокол вроде Modbus RTU имеет смысл только в виде hex. Может не совпадать кодировка: устройство отправляет китайский текст в UTF-8, а терминал последовательного порта отображает GBK, или наоборот, — и тогда байты UTF-8 E4 BD A0 E5 A5 BD для 你好 превращаются в 浣犲ソ. Или в тексте есть управляющие байты, например 00 или 0D 0A, которые выглядят как квадратики или переносы строк. Вставьте hex сюда: таблица кодировок показывает варианты прочтения в UTF-8 и GBK рядом, а управляющие байты отображаются как ␀ ␍ ␊.
    Чем перевод hex в ASCII отличается от перевода hex в UTF-8?
    ASCII определяет только байты от 00 до 7F: буквы, цифры, знаки препинания и управляющие символы. UTF-8 устроен так, что те же байты означают ровно те же символы, а для всего остального использует последовательности байтов от 80 и выше: 2 байта для латинских букв с диакритикой, 3 — для большинства китайских, японских и корейских иероглифов, 4 — для эмодзи. Поэтому для обычного английского текста перевод hex в ASCII и hex в UTF-8 даёт одинаковый результат. Разница появляется, как только встречается байт 80 или выше: конвертер, знающий только ASCII, не может показать такие байты как символы, а UTF-8 декодирует их во весь диапазон Unicode. Что обозначает каждый байт от 00 до 7F, смотрите в таблице ASCII.
    Сколько байтов занимает китайский иероглиф в hex?
    Зависит от кодировки. В UTF-8 большинство китайских иероглифов занимает 3 байта: 你 — это E4 BD A0. В GBK и GB2312 — 2 байта: 你 — это C4 E3. В UTF-16 символы базовой многоязычной плоскости занимают 2 байта, и важен порядок байтов: 你 — это 60 4F в UTF-16LE и 4F 60 в UTF-16BE. Редкие иероглифы за пределами этой плоскости занимают 4 байта в UTF-8, 4 в UTF-16 (суррогатная пара) и 4 в GB18030. Переключите кодировку на вкладке Текст → Hex, чтобы увидеть число байтов для своего текста.
    Как перевести hex в строку в Python?
    Используйте bytes.fromhex(), а затем декодируйте: bytes.fromhex('48656c6c6f').decode('utf-8') возвращает 'Hello'. fromhex допускает пробелы между байтами, так что bytes.fromhex('48 65 6c 6c 6f') тоже работает, но префикс 0x отвергает с ошибкой ValueError. Данные в GBK декодируйте через 'gbk': bytes.fromhex('c4e3bac3').decode('gbk') возвращает '你好', а декодирование тех же байтов как UTF-8 выбрасывает UnicodeDecodeError. Обратное преобразование — '你好'.encode('utf-8').hex(), оно возвращает 'e4bda0e5a5bd'; передайте разделитель, например .hex(' '), чтобы получить вывод через пробел.
    Как перевести hex в строку в JavaScript?
    В Node.js Buffer.from('48656c6c6f', 'hex').toString('utf8') возвращает 'Hello'. Осторожнее с некорректным вводом: Node не выбрасывает исключение — он останавливается на первой недопустимой паре и молча отбрасывает последнюю непарную цифру, так что Buffer.from('486', 'hex') — это буфер из одного байта. В браузере соберите байты сами и используйте TextDecoder, который умеет читать и GBK: new TextDecoder('gbk').decode(Uint8Array.from('c4e3bac3'.match(/../g), h => parseInt(h, 16))) возвращает '你好'. Не используйте charCodeAt() для получения байтов: '你'.charCodeAt(0).toString(16) — это '4f60', кодовая единица UTF-16, а не байты UTF-8 e4bda0.
    Как перевести hex-строку в строку на C или C++?
    Считывайте по две шестнадцатеричные цифры в буфер unsigned char, а затем завершите его нулём: for (size_t i = 0; i < n; i++) sscanf(hex + 2 * i, "%2hhx", &buf[i]); buf[n] = '\0';, где n — это strlen(hex) / 2. Если hex равен 48656c6c6f2c20e4b896e7958c, вывод buf в терминале с UTF-8 даст Hello, 世界. Для обратного направления печатайте каждый байт через printf("%02X ", (unsigned char)s[i]). Приведение типа здесь важно: на платформах, где char знаковый, байт вроде 0xE4 иначе будет расширен знаком и напечатан как FFFFFFE4. В C++ добавляйте каждую пару через s.push_back(static_cast<char>(std::stoi(hex.substr(i, 2), nullptr, 16))); тот же hex даёт Hello, 世界.
    Как перевести hex в строку в Java и почему Java печатает ffffffe4?
    В Java 17 и новее это одна строка кода: new String(HexFormat.of().parseHex(hex), StandardCharsets.UTF_8); для данных в GBK используйте вместо этого Charset.forName("GBK"). В обратную сторону классический сюрприз — ffffffe4. Он возникает потому, что byte в Java знаковый, а Integer.toHexString() принимает int. Байт 0xE4 хранится как -28; при расширении до int значение остаётся -28, а toHexString печатает отрицательные числа как беззнаковое 32-битное значение — ffffffe4. Этот же метод отбрасывает ведущие нули, так что 0x0A превращается в a. Используйте String.format("%02x", b), который форматирует отрицательный байт как беззнаковое 8-битное значение, или Integer.toHexString(b & 0xff) с дополнением нулями. В Java 17 и новее HexFormat.of().formatHex(bytes) преобразует весь массив, а HexFormat.of().parseHex(hex) — в обратную сторону.
    Какая функция PHP переводит hex в строку?
    hex2bin() декодирует hex-строку в двоичную строку, а bin2hex() работает в обратную сторону: bin2hex('Hello') возвращает 48656c6c6f. Согласно руководству PHP, hex2bin() возвращает false и выдаёт E_WARNING, если длина ввода нечётная или он не является корректным шестнадцатеричным значением, поэтому перед вызовом удалите пробелы и префиксы 0x. Строки в PHP — это байты, так что результат будет в той же кодировке, что и исходный текст: если страница в UTF-8, а вывод в GBK, преобразуйте его через mb_convert_encoding().
    Можно ли вставить вывод xxd или hexdump напрямую?
    Да. Столбец смещений и символьный столбец распознаются и удаляются, а строка под полем ввода сообщает об этом. Это важно, потому что конвертер, который только убирает пробелы, читает смещения как данные. Страница понимает xxd (включая -u, -c и -g), hexdump -C, hex.Dump из Go, od -A x -t x1 и GNU od -t x1z, а также разворачивает строку *, которую hexdump и od печатают вместо повторяющихся строк. Поддерживаются и простой hexdump, и od -x, которые печатают 16-битные слова, а не байты: на little-endian-машине байты 48 69 печатаются как 6948, поэтому страница переставляет байты в каждой паре обратно и по последнему смещению отбрасывает байт-заполнитель, добавленный к данным нечётной длины. Каждый вариант xxd, hexdump и od проверен на 600 реальных дампах случайных данных.
    Что означает нечётное число шестнадцатеричных цифр?
    Что-то потерялось или добавилось: каждый байт — это ровно две шестнадцатеричные цифры. Частые причины — ведущий ноль, отброшенный функцией перевода числа в hex (a вместо 0a), символ, обрезанный при копировании, или случайная буква, например O вместо 0. Hex-строка, полученная переводом всех байтов как одного большого числа, например через hex(int.from_bytes(data, 'big')) в Python, теряет ноль в начале: \r\n превращается в 0xd0a. Страница не угадывает, какой цифры не хватает, потому что ошибочная догадка сдвигает все последующие байты на полбайта и даёт правдоподобную бессмыслицу. Вместо этого она предлагает два исправления в один клик — добавить 0 в начало или удалить последнюю цифру, — чтобы можно было сравнить результаты. Значения, записанные по отдельности с префиксом, например 0x0 0xa, в порядке: каждое читается как целый байт.
    Загружаются ли куда-нибудь вставленные данные?
    Нет. Преобразование выполняется на JavaScript в вашем браузере: ничего не отправляется на сервер, не сохраняется и не добавляется в URL страницы. Это можно проверить на вкладке Network в инструментах разработчика браузера. Здесь это особенно важно, потому что hex, вставляемый в конвертер, — это часто перехваченный сетевой трафик, дамп прошивки или строка из продакшен-лога.

    Похожие инструменты

    Все инструменты →

    Таблица ASCII и конвертер

    Кодирование и форматирование

    Полная таблица ASCII: 128 символов в десятичном, шестнадцатеричном, восьмеричном и двоичном виде плюс конвертер текста и кодов. Управляющие символы — с escape-последовательностями, caret-записью и тем, где их встретить.

    Base64 декодер и кодировщик

    Кодирование и форматирование

    Декодирование и кодирование Base64 онлайн бесплатно. Преобразование в реальном времени с полной поддержкой UTF-8 и эмодзи. Полная приватность — работает в браузере. Без регистрации.

    Конвертер Base64 в изображение

    Кодирование и форматирование

    Декодируйте строку Base64 или data URI обратно в изображение прямо в браузере. Предпросмотр, размеры и MIME, затем скачивание как PNG, JPG, GIF, SVG. Без загрузки.

    Конвертер CSV в JSON

    Кодирование и форматирование

    Конвертируйте CSV в JSON в браузере. RFC 4180, определение типов, заголовок, безопасность больших целых. 100% приватно, без загрузки.

    Конвертер кодировок и восстановление кракозябр

    Кодирование и форматирование

    Вставьте кракозябры — и получите исходный текст. Перебираются все правдоподобные цепочки кодировок: UTF-8, Windows-1251, GBK, Big5, Shift_JIS, EUC-KR. Бесплатно, локально в браузере.

    Конвертер .env в JSON

    Кодирование и форматирование

    Вставьте файл .env — получите JSON мгновенно. Пароли БД, API-ключи и токены не покидают браузер: 100% приватно, без загрузки, парсер dotenv.