Мойибаке: текст в чужой кодировке и как его прочитать

Мойибаке — это текст, который показывает не те символы, потому что байты одной кодировки были прочитаны в другой. Файл при этом обычно не повреждён: это корректный UTF-8, каждая последовательность байтов в нём — допустимый символ, и ни один валидатор не жалуется. Повреждение видит человек, больше никто.

Слово японское: 文字化け, "превращение символов"; по-русски такое чаще называют просто кракозябрами. Причина — обычное несовпадение, а не экзотика: страница отдана без charset, редактор сохранил файл в Windows-1252, соединение с базой выставлено в latin1, заголовок письма закодирован дважды. Дальше — как выглядит каждое такое несовпадение, как воспроизвести его намеренно, как прочитать текст обратно и как держать тесты, которые это ловят.

Инструменты: Python 3.14, PHP 8.3, pytest 9.2, bash 5.3 и команда iconv из этого контейнера. Каждый блок ниже выполнен, а вывод под ним скопирован из запуска.

Что такое мойибаке

Символ — это число, а кодировка — правило, которое записывает это число байтами. UTF-8 записывает é двумя байтами, C3 A9. Windows-1252, кодировка большинства западноевропейских программ Windows, записывает тот же символ одним байтом, E9. Отдайте два байта UTF-8 декодеру cp1252, и он прочитает два символа, Ã и ©, потому что именно это cp1252 означает байтами C3 и A9.

text = "é" print(text, text.encode(), text.encode("cp1252")) print(text.encode(), "->", text.encode().decode("cp1252"))

é b'\xc3\xa9' b'\xe9' b'\xc3\xa9' -> é

Python записывает UTF-8, когда encode() вызван без аргумента, поэтому в примерах здесь аргумент опущен; encode("utf-8") — тот же вызов, записанный полностью.

Чтобы повреждение закрепилось, нужны два условия. Читатель должен принять байты: cp1252, cp1251, latin-1 и koi8-r отображают почти все 256 значений байта в символы, поэтому строка обычного текста читается без ошибки и без предупреждения. И результат должен быть снова сохранён как текст, так что файл или база теперь хранят не те символы в корректной кодировке. Поэтому повреждение переживает любую последующую проверку: в байтах нет ничего недопустимого.

Виды мойибаке

Повреждения различаются тем, какая кодировка читала, и тем, что случилось с результатом потом. Восемь видов покрывают почти все случаи на практике:

Виды повреждения
Что произошлоЧто видно
UTF-8 прочитан как cp1252 или latin-1café превращается в café
UTF-8 прочитан как cp1251Привет превращается в Привет
двойное кодирование: повреждённый текст сохранён и снова прочитан неправильноcafé превращается в café
символы замены: декодирование с errors='replace'Привет превращается в 12 символов U+FFFD, и байты потеряны
конвертация с потерями: символа нет в целевой кодировкеПривет превращается в ??????
BOM, сохранённый вместе с файломневидимый U+FEFF перед первым символом
обрезанная многобайтовая последовательностьcafé, обрезанный после четырёх байтов, превращается в caf и U+FFFD
смешано в одном файле: часть переписана, часть нетстрока 1 в порядке, строка 2 сломана, строка 3 в порядке

Первые два вида, один латинский и один кириллический, встречаются чаще всего. Один и тот же текст UTF-8 выглядит по-разному в зависимости от того, какая однобайтовая кодировка его прочитала:

utf8 = "Привет".encode() print("Привет as cp1251:", utf8.decode("cp1251")) print("Привет as cp1252:", utf8.decode("cp1252")) print("café as cp1252 :", "café".encode().decode("cp1252")) print("café as latin-1 :", "café".encode().decode("latin-1")) print("a dash as cp1252:", "—".encode().decode("cp1252")) print("a dash as latin-1:", repr("—".encode().decode("latin-1")))

Привет as cp1251: Привет Привет as cp1252: Привет café as cp1252 : café café as latin-1 : café a dash as cp1252: — a dash as latin-1: 'â\x80\x94'

cp1252 и latin-1 совпадают на диапазоне A0-FF и различаются в 80-9F, где у cp1252 знак евро, тире и типографские кавычки, а у latin-1 управляющие символы. Повреждённое тире — это — в cp1252 и буква с двумя управляющими символами в latin-1; так эти две кодировки и различают в файле.

Третий вид — то же чтение, применённое дважды: повреждённый текст был сохранён как UTF-8 и ещё раз прочитан как cp1252. Каждый круг удваивает число байтов:

once = "café".encode().decode("cp1252") twice = once.encode().decode("cp1252") print("once :", once, once.encode()) print("twice:", twice, twice.encode())

once : café b'caf\xc3\x83\xc2\xa9' twice: café b'caf\xc3\x83\xc6\x92\xc3\x82\xc2\xa9'

Остальные виды необратимы, кроме BOM. Декодирование с errors="replace", сохранение в более узкую кодировку и обрыв посреди символа выбрасывают информацию, поэтому никакая догадка её не вернёт: символ замены и вопросительный знак говорят только, что там что-то было.

raw = "Привет".encode() broken = raw.decode("ascii", errors="replace") print("bytes in :", len(raw)) print("as ascii :", broken[:6].encode("unicode_escape").decode()) print("U+FFFD count :", broken.count("\ufffd")) print("bytes out :", len(broken.encode())) print("ascii replace:", "Привет".encode("ascii", errors="replace").decode()) cut = "café".encode()[:4].decode(errors="replace") print("truncated :", cut.encode("unicode_escape").decode())

bytes in : 12 as ascii : \ufffd\ufffd\ufffd\ufffd\ufffd\ufffd U+FFFD count : 12 bytes out : 36 ascii replace: ?????? truncated : caf\ufffd

Двенадцать байтов вошло и тридцать шесть вышло, и ни один из тридцати шести не несёт буквы из исходного текста. Последняя строка — файл, обрезанный посреди é: ведущий байт символа остался без продолжения, и декодер отметил дыру.

BOM устроен иначе: U+FEFF — допустимый символ, нулевой ширины и невидимый, и метка порядка байтов в начале файла UTF-8 даже разрешена. Повреждением она становится, когда читатель оставляет её текстом, когда после второго сохранения появляется вторая метка, или когда файл — страница PHP: всё до <?php уходит в браузер, а заголовки уже отправлены.

text = "\ufeffcafé" print("characters:", len(text)) print("bytes :", text.encode()) print("first char:", text[0].encode("unicode_escape").decode())

characters: 5 bytes : b'\xef\xbb\xbfcaf\xc3\xa9' first char: \ufeff

Смешанный случай заметить труднее всего: один файл, несколько строк, часть переписана правильно, часть повреждена. Весь файл — корректный UTF-8, поэтому iconv и любой валидатор его пропускают, и сломанную строку видит только человек. Построчная попытка восстановления её находит: строка, которая вернулась другим текстом, была повреждена; строка, которую не удалось прочитать в кандидате, — нет.

lines = ["Первая строка", "Вторая строка", "Третья строка"] data = "\n".join(lines).encode() data.decode("utf-8") print("bytes:", len(data), "- no UnicodeDecodeError, the file is valid UTF-8") for number, line in enumerate(data.decode("utf-8").splitlines(), 1): try: fixed = line.encode("cp1251").decode("utf-8") except UnicodeError: fixed = line print(number, "ok " if fixed == line else "bad", fixed)

bytes: 104 - no UnicodeDecodeError, the file is valid UTF-8 1 ok Первая строка 2 bad Вторая строка 3 ok Третья строка

Как его получить

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

Одна строка на Python:

python3 -c "print('café'.encode().decode('cp1252'))"

café

Как функция, с читателем в аргументе и с двойным кругом одним лишним вызовом:

def damage(text, reader="cp1252"): return text.encode().decode(reader) # encode() writes UTF-8 print(damage("café")) print(damage("Привет", reader="cp1251")) print(damage(damage("café")))

café Привет café

В PHP чтение не в той кодировке — один вызов: mb_convert_encoding($text, "UTF-8", "Windows-1252") считает байты $text кодировкой Windows-1252 и записывает их как UTF-8. Обратное действие делает iconv(): iconv("UTF-8", "Windows-1252", $broken) превращает два видимых символа обратно в два байта, с которых строка начиналась:

<?php $text = 'café'; // UTF-8: 63 61 66 C3 A9 $broken = mb_convert_encoding($text, 'UTF-8', 'Windows-1252'); echo $broken, "\n"; echo iconv('UTF-8', 'Windows-1252', $broken), "\n";

Сохранённый как mojibake.php, скрипт печатает повреждение, а затем исправление:

php mojibake.php

café café

В оболочке та же пара — два вызова iconv: прочитать вход в кодировке, которая не отказывает, записать как UTF-8. Экранирование printf обозначает два байта C3 A9 символа é, в этом и смысл примера: на входе байты, а не символы.

printf 'caf\xc3\xa9\n' | iconv -f CP1252 -t UTF-8

café

Чтобы увидеть байты, а не то, что из них сделал терминал, добавьте xxd:

printf 'caf\xc3\xa9\n' | iconv -f CP1252 -t UTF-8 | xxd

00000000: 6361 66c3 83c2 a90a caf.....

Исправление идёт в обратную сторону, из UTF-8 в cp1252, и возвращает байты, с которых файл начинался:

printf 'caf\xc3\x83\xc2\xa9\n' | iconv -f UTF-8 -t CP1252

café

Как его прочитать

Повреждённый текст выдаёт себя несколькими последовательностями, которые почти не встречаются в правильном тексте, и по их семейству видно, какая кодировка читала:

Характерные последовательности
Что видноЧто читало байты
Ã, Â, †перед буквой или знаком препинания: é, ü, —UTF-8 прочитан как cp1252 или latin-1
à и  там, где при одном повреждении стоят à и Â, и †перед типографской кавычкойто же повреждение, второй раз
Ð и Ñ перед высоким символом: Пр, инкириллица UTF-8 прочитана как cp1252
Р и С перед џ, Ђ, ‚, µ: РџСЂ, РёРЅкириллица UTF-8 прочитана как cp1251
U+FFFD или пустой квадрат в терминаледекодирование с потерями: восстанавливать нечего
подряд идущие ?конвертация с потерями: восстанавливать нечего
невидимый символ перед первой буквойBOM

Восстановление — та же операция в обратную сторону: закодировать видимый текст кодировкой-кандидатом, затем декодировать результат как UTF-8. Правильный кандидат возвращает исходный текст. Неправильный либо вообще не может представить эти символы, либо даёт байты, не являющиеся корректным UTF-8. Когда выживает несколько кандидатов, посчитайте буквы ожидаемого языка: в правильном восстановлении почти каждый символ — из них.

CYRILLIC = set("абвгдеёжзийклмнопрстуфхцчшщъыьэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ ") def score(text): return sum(ch in CYRILLIC for ch in text) / len(text) broken = "Привет" print(f"before: {score(broken):.2f}") for enc in ("cp1251", "cp1252", "latin-1", "koi8-r", "mac_cyrillic"): try: fixed = broken.encode(enc).decode("utf-8") except UnicodeError: print(f"{enc:13} cannot hold these characters") continue print(f"{enc:13} {score(fixed):.2f} {fixed}")

before: 0.58 cp1251 1.00 Привет cp1252 cannot hold these characters latin-1 cannot hold these characters koi8-r cannot hold these characters mac_cyrillic cannot hold these characters

Только cp1251 может вместить эти символы, и он восстанавливает строку в Привет: оценка повреждённой строки была 0.58, оценка восстановления — 1.00. Оценка — эвристика: она упорядочивает кандидатов, и на короткой строке подойти могут два.

Файл, повреждённый дважды, требует двух кругов, а повреждённый один раз — одного, поэтому число кругов их различает. Применяйте восстановление, пока оно работает, и считайте, сколько раз оно изменило текст:

def repair(text, enc): for attempt in range(1, 5): try: text = text.encode(enc).decode("utf-8") except UnicodeError: return attempt - 1, text return 4, text single = "café".encode().decode("cp1252") double = single.encode().decode("cp1252") for name, broken in (("single", single), ("double", double)): repairs, fixed = repair(broken, "cp1252") print(f"{name:7} rounds={repairs} {fixed}")

single rounds=1 café double rounds=2 café

Третий круг падает с UnicodeDecodeError, потому что восстановленный текст больше не является допустимым чтением UTF-8 в cp1252. Это и есть правило остановки: восстанавливать столько раз, сколько нужно файлу, и не больше.

Восстановление — догадка, и на длинном тексте догадка лучше, чем на коротком. "é" может означать один символ, прочитанный неправильно, или два символа, записанных так намеренно. Прежде чем доверять восстановлению, его сверяют со второй копией: версией в репозитории, исходной таблицей, тем же текстом на другой странице. Когда в тексте уже есть U+FFFD или вопросительные знаки, сверять нечего, и вернуть исходное может только источник.

В тестах

Для мойибаке тестам нужны три вещи: набор фикстур, который говорит, какое повреждение каким исправлением лечится, тест круга, доказывающий, что пара кодировок работает без потерь, и регрессионный тест на то, что код обнаружения повреждений их по-прежнему находит.

Фикстуры строят повреждённую сторону из правильного текста при импорте, поэтому в самом файле теста нет мойибаке, за который мог бы зацепиться редактор, хук или читатель. Каждый случай — правильная строка, та же строка после неправильного чтения и кодировка, которая это отменяет:

import pytest CASES = [ ("café", "café".encode().decode("cp1252"), "cp1252"), ("Привет", "Привет".encode().decode("cp1251"), "cp1251"), ("café — 5 €", "café — 5 €".encode().decode("cp1252"), "cp1252"), ] PAIRS = ("é", "Ã", "©", "П", "Ñ€", "Рџ", "СЂ", "â€") def repair(text, enc): return text.encode(enc).decode("utf-8") def looks_broken(text): return any(pair in text for pair in PAIRS) @pytest.mark.parametrize(("good", "broken", "enc"), CASES) def test_repair_restores_the_text(good, broken, enc): assert broken != good assert repair(broken, enc) == good @pytest.mark.parametrize(("good", "broken", "enc"), CASES) def test_broken_form_is_flagged(good, broken, enc): del good, enc assert looks_broken(broken) def test_clean_text_is_not_flagged(): for text in ("café", "Привет", "Japanese text", "naïve — 5 €"): assert not looks_broken(text) def test_correct_pair_round_trips(): for text in ("café", "Привет", "日本語", "naïve — 5 €", ""): assert text.encode("utf-8").decode("utf-8") == text def test_lossy_pair_does_not_round_trip(): text = "Привет" assert text.encode("ascii", errors="replace").decode() != text

pytest -q tests/test_mojibake.py

......... [100%] 9 passed in 0.03s

Первые два теста — одна таблица, прочитанная дважды: восстановление должно вернуть правильную строку, а детектор должен пометить сломанную. Детектор ищет пары, а не отдельные символы, потому что Р и С — обычные русские буквы; повреждение отмечает пара, а не каждая буква по отдельности. Последние два теста — само свойство: decode(encode(x)) == x выполняется для UTF-8 и не выполняется для конвертации с потерями, поэтому пара, которая называет себя работающей без потерь, доказывается данными, а не своей документацией.

В этом репозитории git запускает то же правило на каждом коммите. Проверка pre-commit на повреждения концов строк и кодировки считает двойные последовательности, которые добавляет индексированное изменение, по одному шаблону на семейство: семейство Ã/Â, семейство Ð/Ñ и семейство Р/С. Десять новых последовательностей останавливают коммит строкой ARTIFACT и счётчиком; одно слово-образец, которое несёт страница, лишь упоминающая мойибаке, остаётся ниже порога. Проверка сравнивает новую сторону файла с базовой, поэтому повреждение, закоммиченное раньше, не проваливает более поздний коммит, а перевод, переписывающий каждую строку, проходит.

Сама эта страница выше порога: она цитирует слишком много образцов, чтобы пройти, поэтому коммит, который её добавляет, должен идти с SKIP=check-diff-artifacts — тем путём для намеренного срабатывания, который описан на странице хука. Тесты хука идут тем же путём с другой стороны: они строят повреждённое содержимое во время прогона, поэтому файл теста никогда не несёт мойибаке, которое он проверяет.

Автор статьи: Arthur Isaev