Что означает 48 65 6C 6C 6F в виде текста?
Hello В ASCII и UTF-8 48 — это H, 65 — e, 6C — l, а 6F — o.
Перевод hex в текст и текста в hex. Вставьте hex в любом виде: с пробелами, 0x, \x, вывод xxd или hexdump, массивы байтов Java и C. ASCII, UTF-8, GBK и UTF-16 определяются сами. Всё в браузере.
Формат: чистый hex · байт: 13
Hello, 世界
Автоопределение: UTF-8 — все многобайтовые последовательности корректны.
Результат сам является hex — вероятно, его перевели дважды. Ещё один проход даёт:
| Кодировка | Прочтение |
|---|---|
| UTF-8 Декодируется без ошибок | Hello, 世界 |
| GBK / GB18030 Декодируется без ошибок | Hello, 涓栫晫 |
| UTF-16LE Есть недекодируемые байты | 效汬Ɐ隸闧� |
| UTF-16BE Есть недекодируемые байты | 䡥汬漬⃤뢖� |
| ISO-8859-1 Декодируется без ошибок | Hello, ä¸<96>ç<95><8C> |
48 65 6C 6C 6F 2C 20 E4 B8 96 E7 95 8C
Написано и проверено разработчиками, которые создают инструменты кодирования Go Tools. Каждое hex-значение и каждый результат на этой странице получены собственным движком страницы и проверены автоматическими тестами.
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.
CR LF (\r\n) Возврат каретки и следом перевод строки — окончание строки, принятое в Windows, HTTP и большинстве наборов команд для последовательного порта.
41 Строчная a — это 61; заглавная и строчная буквы всегда отличаются на 20.
Шестнадцатеричная запись (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 С пробелами, слитно, через двоеточия или дефисы, значения 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, поэтому дампы трафика и продакшен-логи можно вставлять спокойно.
bytes.fromhex(h).decode() bytes.fromhex('48 65 6c 6c 6f').decode('utf-8') возвращает 'Hello'; пробелы между байтами допустимы, префикс 0x — нет. Обратное преобразование — s.encode('utf-8').hex() или .hex(' ') для вывода через пробел. Передайте 'gbk', чтобы декодировать или закодировать китайский текст в GBK.
Buffer.from(h, 'hex') Buffer.from(h, 'hex').toString('utf8') декодирует, Buffer.from(s, 'utf8').toString('hex') кодирует. Некорректный ввод не считается ошибкой: декодирование останавливается на первой плохой паре, а последняя непарная цифра отбрасывается, поэтому сначала проверяйте ввод.
TextDecoder / TextEncoder Разберите пары через parseInt(pair, 16) в Uint8Array, затем вызовите new TextDecoder('utf-8').decode(bytes). TextDecoder читает также 'gbk', 'big5' и 'shift_jis', но TextEncoder выдаёт только UTF-8.
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 для отрицательных байтов.
encoding/hex hex.DecodeString(h) возвращает байты, а string(b) превращает их в строку; hex.EncodeToString([]byte(s)) выполняет обратное преобразование. Пакет строгий: на пробелы он возвращает invalid byte: U+0020 ' ', а на нечётную длину — odd length hex string.
sscanf with %2hhx Проходите по строке по две цифры, записывая байты в буфер unsigned char, и добавьте завершающий '\0'. Чтобы напечатать hex, приводите к unsigned char и используйте %02X, иначе там, где char знаковый, байты выше 0x7F могут напечататься как FFFFFFE4.
hex2bin() / bin2hex() hex2bin('48656c6c6f') возвращает Hello, а bin2hex('Hello') возвращает 48656c6c6f. В руководстве указано, что при нечётной длине или некорректном вводе hex2bin() возвращает false с E_WARNING.
xxd -r -p / xxd -p echo 48656c6c6f | xxd -r -p печатает Hello, а printf 'Hello' | xxd -p печатает 48656c6c6f. При кодировании используйте printf, а не echo, потому что echo добавляет в конце перевод строки, 0a.
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).
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.
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, покажет здесь символы замены.
00000000: 4869 20e4 bda0 e5a5 bd0d 0a Hi ........
Hi 你好␍␊
Именно это печатает printf 'Hi 你好\r\n' | xxd. Смещение 00000000: и символьный столбец справа удаляются перед декодированием; если прочитать их как данные, одни только восемь нулей дадут четыре байта NUL в начале. Последние два байта, 0d 0a, — это перевод строки в стиле Windows, он показан как ␍␊.
[-28, -72, -83, -26, -106, -121]
中文
Arrays.toString(bytes) печатает знаковые байты Java в десятичном виде. Отрицательные значения — это байты от 0x80 и выше: -28 — это 256 − 28 = 228 = 0xE4. Шесть байтов E4 B8 AD E6 96 87 — это кодировка UTF-8 для 中文.
AT+CSQ\r\n
41 54 2B 43 53 51 0D 0A
Модемы и большинство наборов команд UART ожидают, что каждая команда заканчивается возвратом каретки и переводом строки. Текстовое поле по Enter даёт только 0A, поэтому отметьте Переводы строк как CR LF — и окончание строки станет 0D 0A.
653462646130653561356264
e4bda0e5a5bd → 你好
Каждый байт здесь — ASCII-код шестнадцатеричной цифры (65 — это e, 34 — 4, 62 — b), поэтому первое декодирование даёт ещё одну hex-строку. Так бывает, когда hex-строку принимают за текст и конвертируют повторно. Страница предлагает второй проход, который даёт 你好. Чтобы не было ложных срабатываний, он предлагается, только если первый результат содержит не меньше 12 шестнадцатеричных цифр, а второй декодируется в осмысленный текст: даты, метки времени, значения CRC32 и хеши MD5 его не вызывают.
Вставьте его в поле на вкладке Hex → Текст в том виде, какой есть: с пробелами, слитно, значения 0x, экранирование \x, массив байтов или целый экран xxd. Строка под полем сообщает, как он был прочитан.
Текст появляется справа вместе с автоматически определённой кодировкой и причиной выбора. Если догадка неверна, в таблице ниже есть все варианты прочтения — выберите нужный в меню «Кодировка».
Управляющие байты, например NUL, CR и LF, показываются как ␀ ␍ ␊. Снимите флажок «Показывать невидимые символы», чтобы увидеть чистый текст, и скопируйте результат.
На вкладке Текст → Hex выберите кодировку и формат вывода — hex через пробел, значения 0x, массив для C, Java, Python или Go либо дамп xxd. Для последовательных и сетевых протоколов отметьте CR LF.
Китайский текст из старых программ для 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() возвращает кодовую единицу 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 byte в Java знаковый, поэтому байты от 0x80 и выше отрицательны. Integer.toHexString() работает с int, печатает отрицательные значения как беззнаковый 32-битный hex и отбрасывает ведущие нули.
Integer.toHexString(b) // "ffffffe4" for 0xE4, "a" for 0x0A
String.format("%02x", b) // "e4", "0a" 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'); Конвертер, который только удаляет пробелы, читает смещение 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
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
0D 0A или 00 в конце, — или идите в обратную сторону и соберите команду с окончаниями строк CR LF, которую устройство примет.b'...', а Node.js — в виде <Buffer ...>. Вставьте фрагмент лога как есть, чтобы увидеть текст и заодно узнать, был он в UTF-8 или в GBK.00 до FF, и число байтов всегда вдвое меньше числа цифр. Верхний и нижний регистр означают одно и то же. Разделители, префиксы и синтаксис массивов — лишь форма записи: 4865, 48 65, 0x48, 0x65 и \x48\x65 — это одни и те же два байта.00 до 7F. Печатные символы идут от 20 (пробел) до 7E (~); остальные — управляющие символы, из которых в реальных данных чаще всего встречаются 00 (NUL), 09 (табуляция), 0A (перевод строки), 0D (возврат каретки) и 1B (escape). UTF-8, GBK и ISO-8859-1 сохраняют эти значения, поэтому обычный английский текст переживает почти любую неверную кодировку.C2–DF для двух байтов, E0–EF для трёх, F0–F4 для четырёх, — а каждый следующий байт обязан лежать в диапазоне 80–BF. Из-за этой строгой структуры предложение в GBK почти никогда не оказывается корректным UTF-8 — в нашем тесте на 33 910 китайских предложениях таких нашлось 55, — и поэтому автоопределение доверяет чистому декодированию UTF-8. С одиночным иероглифом всё иначе: около 18% символов GBK случайно образуют корректную двухбайтовую последовательность UTF-8.81 до FE и следующий за ним байт от 40 до FE, кроме 7F. Поскольку диапазон второго байта так широк, короткий текст в UTF-8, прочитанный как GBK, часто без единой ошибки декодируется в посторонние символы — E4 BD A0 E5 A5 BD (你好) превращается в 浣犲ソ, — поэтому эта страница сначала пробует UTF-8. GB18030 расширяет GBK четырёхбайтовыми последовательностями для более редких иероглифов; декодер здесь их принимает.41 00), а UTF-16BE — старший (00 41). В Windows API и во многих файлах принят little-endian, а в начале может стоять метка порядка байтов FF FE; файлы в UTF-8 иногда начинаются с EF BB BF. Автоопределение удаляет метку порядка байтов и сообщает об этом.getBytes(), encode(), настройка терминала последовательного порта, кодировка соединения с базой данных — задавайте кодировку явно и записывайте её рядом с hex, чтобы другой стороне не пришлось гадать.charCodeAt() в JavaScript или значения char в Java, дают кодовые единицы UTF-16, а не закодированные байты. Сначала закодируйте строку через TextEncoder, Buffer.from() или getBytes(StandardCharsets.UTF_8), а затем форматируйте байты.%02x или аналог, а не голый вызов перевода числа в hex. В логе a и 0a выглядят похоже, но склейка значений без дополнения даёт строку нечётной длины или, хуже того, строку, которая декодируется в другие байты.00 до FF, так что 48656c6c6f — это пять байтов 48, 65, 6C, 6C, 6F. Затем декодируйте эти байты в какой-либо кодировке символов. В ASCII и UTF-8 48 — это H, 65 — e, 6C — l, а 6F — o, получается Hello. Именно на втором шаге результаты расходятся: байты выше 7F означают разные символы в UTF-8, GBK и других кодировках, поэтому страница определяет кодировку и показывает все варианты прочтения рядом. C4 E3 BA C3 — это 你好 в GBK, но некорректный UTF-8, а E4 BD A0 E5 A5 BD — это 你好 в UTF-8, но при чтении как GBK превращается в 浣犲ソ. Посмотрите на таблицу кодировок под результатом: строка, в которой получился осмысленный текст, и есть кодировка, в которой данные были записаны. Когда символов всего один-два, автоопределение не всегда может решить: D2 BB — корректный UTF-8 (һ) и одновременно GBK (一), поэтому проверьте строку GBK, которую страница показывает под результатом. Стоит исключить ещё две причины: лишнюю или пропущенную шестнадцатеричную цифру, из-за которой все последующие байты сдвигаются на полбайта, и hex-дамп, вставленный вместе со столбцом смещений. Если у вас не hex, а уже готовые кракозябры (например, 浣犲ソ), вставьте этот текст в конвертер кодировок. E4 BD A0 E5 A5 BD для 你好 превращаются в 浣犲ソ. Или в тексте есть управляющие байты, например 00 или 0D 0A, которые выглядят как квадратики или переносы строк. Вставьте hex сюда: таблица кодировок показывает варианты прочтения в UTF-8 и GBK рядом, а управляющие байты отображаются как ␀ ␍ ␊. 00 до 7F: буквы, цифры, знаки препинания и управляющие символы. UTF-8 устроен так, что те же байты означают ровно те же символы, а для всего остального использует последовательности байтов от 80 и выше: 2 байта для латинских букв с диакритикой, 3 — для большинства китайских, японских и корейских иероглифов, 4 — для эмодзи. Поэтому для обычного английского текста перевод hex в ASCII и hex в UTF-8 даёт одинаковый результат. Разница появляется, как только встречается байт 80 или выше: конвертер, знающий только ASCII, не может показать такие байты как символы, а UTF-8 декодирует их во весь диапазон Unicode. Что обозначает каждый байт от 00 до 7F, смотрите в таблице ASCII. 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, чтобы увидеть число байтов для своего текста. 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(' '), чтобы получить вывод через пробел. 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. 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, 世界. 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) — в обратную сторону. hex2bin() декодирует hex-строку в двоичную строку, а bin2hex() работает в обратную сторону: bin2hex('Hello') возвращает 48656c6c6f. Согласно руководству PHP, hex2bin() возвращает false и выдаёт E_WARNING, если длина ввода нечётная или он не является корректным шестнадцатеричным значением, поэтому перед вызовом удалите пробелы и префиксы 0x. Строки в PHP — это байты, так что результат будет в той же кодировке, что и исходный текст: если страница в UTF-8, а вывод в GBK, преобразуйте его через mb_convert_encoding(). 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 реальных дампах случайных данных. a вместо 0a), символ, обрезанный при копировании, или случайная буква, например O вместо 0. Hex-строка, полученная переводом всех байтов как одного большого числа, например через hex(int.from_bytes(data, 'big')) в Python, теряет ноль в начале: \r\n превращается в 0xd0a. Страница не угадывает, какой цифры не хватает, потому что ошибочная догадка сдвигает все последующие байты на полбайта и даёт правдоподобную бессмыслицу. Вместо этого она предлагает два исправления в один клик — добавить 0 в начало или удалить последнюю цифру, — чтобы можно было сравнить результаты. Значения, записанные по отдельности с префиксом, например 0x0 0xa, в порядке: каждое читается как целый байт. Кодирование и форматирование
Полная таблица ASCII: 128 символов в десятичном, шестнадцатеричном, восьмеричном и двоичном виде плюс конвертер текста и кодов. Управляющие символы — с escape-последовательностями, caret-записью и тем, где их встретить.
Кодирование и форматирование
Декодирование и кодирование Base64 онлайн бесплатно. Преобразование в реальном времени с полной поддержкой UTF-8 и эмодзи. Полная приватность — работает в браузере. Без регистрации.
Кодирование и форматирование
Декодируйте строку Base64 или data URI обратно в изображение прямо в браузере. Предпросмотр, размеры и MIME, затем скачивание как PNG, JPG, GIF, SVG. Без загрузки.
Кодирование и форматирование
Конвертируйте CSV в JSON в браузере. RFC 4180, определение типов, заголовок, безопасность больших целых. 100% приватно, без загрузки.
Кодирование и форматирование
Вставьте кракозябры — и получите исходный текст. Перебираются все правдоподобные цепочки кодировок: UTF-8, Windows-1251, GBK, Big5, Shift_JIS, EUC-KR. Бесплатно, локально в браузере.
Кодирование и форматирование
Вставьте файл .env — получите JSON мгновенно. Пароли БД, API-ключи и токены не покидают браузер: 100% приватно, без загрузки, парсер dotenv.