Просмотр кода страницы UTF-8

'''UTF-8''' (от {{lang-en|Unicode Transformation Format, 8-bit}} — «формат преобразования Юникода, 8-бит») — распространённый стандарт кодирования [[Набор символов|символов]], позволяющий более компактно хранить и передавать символы [[Юникод]]а, используя переменное количество байт (от 1 до 4), и обеспечивающий полную обратную совместимость с 7-битной кодировкой [[ASCII]]. Стандарт UTF-8 официально закреплён в документах RFC 3629 и ISO/IEC 10646 Annex D.

Кодировка UTF-8 сейчас является доминирующей в веб-пространстве. Она также нашла широкое применение в [[UNIX-подобная операционная система|UNIX-подобных операционных системах]]<ref>[https://w3techs.com/technologies/overview/character_encoding/all Usage Statistics of Character Encodings for Websites, June 2011]{{ref|en}}</ref>.

Формат UTF-8 был разработан [[2 сентября]] [[1992 год]]а [[Томпсон, Кен|Кеном Томпсоном]] и [[Пайк, Роб|Робом Пайком]], и реализован в [[Plan 9]]<ref>{{Cite web |url=http://www.cl.cam.ac.uk/~mgk25/ucs/utf-8-history.txt |title=Архивированная копия |access-date=2007-02-27 |archive-date=2011-03-01 |archive-url=https://web.archive.org/web/20110301051538/http://www.cl.cam.ac.uk/~mgk25/ucs/utf-8-history.txt |url-status=dead |lang=en}}</ref>. Идентификатор кодировки в Windows — 65001<ref>{{Cite web |url=https://docs.microsoft.com/en-us/windows/desktop/intl/code-page-identifiers |title=Code Page Identifiers — Windows applications {{!}} Microsoft Docs<!-- Заголовок добавлен ботом --> |access-date=2018-07-14 |archive-date=2019-06-16 |archive-url=https://web.archive.org/web/20190616012252/https://docs.microsoft.com/en-us/windows/desktop/intl/code-page-identifiers |url-status=live }}</ref>.

UTF-8, по сравнению с [[UTF-16]], наибольший выигрыш в компактности даёт для текстов на [[латиница|латинице]], поскольку латинские буквы без [[Диакритические знаки|диакритических знаков]], цифры и наиболее распространённые знаки препинания кодируются в UTF-8 лишь одним байтом, и коды этих символов соответствуют их кодам в [[ASCII]].<ref name="stringtheory">
{{Cite web
 |url           = http://weblogs.mozillazine.org/roc/archives/2008/01/string_theory.html
 |title         = String Theory
 |author        = Well, I'm Back
 |work          = Robert O'Callahan
 |lang          = en
 |datepublished = 2008-03-01
 |access-date    = 2008-03-01
 |archive-url    = https://www.webcitation.org/6193EbztY?url=http://robert.ocallahan.org/2008/01/string-theory_08.html
 |archive-date   = 2011-08-23
}}
</ref><ref name="vsem">
{{Cite web
 |url         = http://webmastak.com/article.aspx?id=300
 |title       = Всем кодировкам кодировка. UTF‑8: современно, грамотно, удобно.
 |author      = Ростислав Чебыкин
 |work        = HTML и CSS
 |access-date  = 2009-03-22
 |archive-url  = https://www.webcitation.org/6193F9SrL?url=http://webmastak.com/article.aspx?id=300
 |archive-date = 2011-08-23
}}</ref>

== Алгоритм кодирования (сериализации) ==
Алгоритм кодирования в UTF-8 стандартизирован в [https://www.rfc-editor.org/rfc/rfc3629 RFC 3629] и состоит из 3 этапов:

1. Определить количество [[Октет (информатика)|октетов]], требуемых для кодирования символа. Номер символа берётся из стандарта [[Юникод]]а.
{| class="wikitable"
!Диапазон номеров символов
!Требуемое количество [[Октет (информатика)|октетов]]
|-
|<code>00000000-0000007F</code>
|1
|-
|<code>00000080-000007FF</code>
|2
|-
|<code>00000800-0000FFFF</code>
|3
|-
|<code>00010000-0010FFFF</code>
|4
|}
Для символов [[Юникод]]а с номерами от <code>U+0000</code> до <code>U+007F</code> (занимающими один октет c нулём в старшем бите) кодировка UTF-8 полностью соответствует 7-битной кодировке US-ASCII.

2. Установить старшие [[бит]]ы первого октета в соответствии с необходимым количеством октетов для кодирования символа, определённом на первом этапе:
* 0xxxxxxx — если для кодирования потребуется ''один'' октет;
* 110xxxxx — если для кодирования потребуется ''два'' октета;
* 1110xxxx — если для кодирования потребуется ''три'' октета;
* 11110xxx — если для кодирования потребуется ''четыре'' октета.
Если для кодирования требуется больше одного октета, то в октетах 2-4 два старших бита всегда устанавливаются равными 10<sub>2</sub> (10xxxxxx). Это позволяет легко отличать первый октет в потоке, от других октетов
{| class="wikitable"
!Количество [[Октет (информатика)|октетов]]
!Значащих бит
!Шаблон
|-
|1
|7
|<code>0xxxxxxx</code>
|-
|2
|11
|<code>110xxxxx 10xxxxxx</code>
|-
|3
|16
|<code>1110xxxx 10xxxxxx 10xxxxxx</code>
|-
|4
|21
|<code>11110xxx 10xxxxxx 10xxxxxx 10xxxxxx</code>
|}

3. Установить значащие биты октетов в соответствии с номером символа [[Юникод]]а, выраженном в двоичном виде. Начать заполнение с младших битов номера символа, поставив их в младшие биты последнего октета, продолжить справа налево до первого октета. Свободные биты первого октета, оставшиеся незадействованными, заполнить нулями.

=== Примеры кодирования ===
{| class="wikitable" style="text-align:right;"
|-
!colspan=2|Символ
! Двоичный код символа
! UTF-8 в двоичном виде
! UTF-8 в шестнадцатеричном виде
|-
|[[Символ доллара|$]] || <code>U+0024</code>
|<code>{{color|red|0100100}}</code>
|<code>0{{color|red|0100100}}</code>
|<code>{{color|black|24}}</code>
|-
|[[Символ цента|¢]] || <code>U+00A2</code>
|<code>{{color|green|10}}{{color|red|100010}}</code>
|<code>110{{color|green|00010}} 10{{color|red|100010}}</code>
|<code>{{color|black|C2}} {{color|black|A2}}</code>
|-
|[[Символ евро|€]] || <code>U+20AC</code>
|<code>{{color|blue|10}}{{color|green|0000}} {{color|green|10}}{{color|red|101100}}</code>
|<code>1110{{color|blue|0010}} 10{{color|green|000010}} 10{{color|red|101100}}</code>
|<code>{{color|black|E2}} {{color|black|82}} {{color|black|AC}}</code>
|-
|[[Хвайр|𐍈]] || <code>U+10348</code>
|<code>{{color|blue|1 0000}}{{color|green|0011 01}}{{color|red|001000}}</code>
|<code>11110{{color|#C000C0|000}} 10{{color|blue|010000}} 10{{color|green|001101}} 10{{color|red|001000}}</code>
|<code>{{color|black|F0}} {{color|black|90}} {{color|black|8D}} {{color|black|88}}</code>
|}

== Пример кодирования Unicode-строки в UTF-8 без предварительного просчёта длины на языке C ==
<syntaxhighlight lang="c" line="1">
#ifdef _WIN32 
	typedef unsigned __int8 u_int8_t;
	typedef unsigned __int16 u_int16_t;
	typedef unsigned __int32 u_int32_t;
	typedef unsigned __int64 u_int64_t;
	typedef wchar_t uchar_t;
#else
	#include <sys/types.h>
	typedef u_int16_t uchar_t;
#endif

size_t UnicodeToUTF8(char** pDest, const uchar_t* Src, size_t SrcLen) {
	size_t dlen = 0;				// Длина целевой строки
	char* offset = *pDest = NULL	// Итератор по целевой строке
		, header = (char)0x80		// "заголовок" первого байта
		, fcap = 0b00111111;		// Вместимость первого бийта
	const uchar_t* src = Src		// указатель на кодируемую точку
		, * end = Src + SrcLen;		// Указатель на конец исходной строки
	uchar_t code = 0;				// Кодируемая точка
	u_int32_t* ibuf = NULL;			// Указатель на целевую строку представленную как беззнаковое целое 32 бита
	// Выделяем память, сохраняем указатель в *pDest, заодно инициализируем итератор
	offset = *pDest = (char*)malloc(SrcLen * 4 + 4);
	// Проверяем выделена ли память
	if (NULL != offset) {
		// основной цикл
		while (src < end) {
			/* Проверяем размерность исходного символа, если величина
				меньше чем 0x80U, значит его кодировать не нужно */
			if (*src < 0x80UL) {
				// копируем значение
				*(offset) = *(char*)(src);
			}
			else {
				// Коируем кодовую точку
				code = *src;
				// сохраняем указатель на первый байт как на беззнаковое целое 32 бита
				ibuf = (u_int32_t*)offset;
				// Обнуляем 4 байта
				(*ibuf) = 0UL;
				// Инициализируем заголовок
				header = (char)0x80;
				// выставляем вместимость первого байта
				fcap = 0b00111111U;
				/* цикл непосредственно кодирования точки в последовательность байтов */
				while (code) {
					// 
					// сравниваем вместимость первого байта и остаток незакодированных битов
					if (fcap < code) {
						// вместимость не меньше остатка
						// копируем младшие 6 битов
						*ibuf |= code & 0b00111111UL;
						// копируем маркер последующего байта
						*ibuf |= 0x80UL;
						// сдвигаем все биты в более старший байт
						*ibuf <<= 8;
						// убираем закодированные 6 битов
						code >>= 6;
						// сдвигаем "заголовок" первого байта на 1 вправо
						header >>= 1;
						// уменьшаем вместимость первого байта
						fcap >>= 1;
						// инкрементируем длину целевой строки
						++dlen;
						// смещаем указатель на на итоговую строку вправо на 1 символ
						++offset;
					}
					else {
						// сохраняем заголовок и оставшиеся биты в первый байт последовательности
						*(u_int8_t*)ibuf |= (header | (u_int8_t)code);
						// обнуляем кодовую точку
						code = 0U;
					}
				}
			}
			// Смещаем указатель на целевую строку
			++offset;
			// Смещаем указатель на исходную строку
			++src;
			// Увеличиваем показатель длины итоговой целевой строки
			++dlen;
		}
	}
	// Проверяем на ошибки, если их нет - обозначаем конец целевой строки
	if (dlen)
		*offset = '\0';
	// возвращаем итоговую длину
	return dlen;
}

</syntaxhighlight>

== Алгоритм декодирования (десериализации) ==
Алгоритм декодирования требуется для того, чтобы преобразовать сырую последовательность октетов, в готовую для использования [[Юникод]] точку. Алгоритм состоит из 3-х этапов:

1. Определить длину символа в октетах. Для определения длины символа, декодер UTF-8 смотрит на служебные биты (то есть те, которые сами по себе не несут полезной нагрузки, но при этом критически важны для определения длины символа в октетах.

служебные биты в UTF-8 всегда старшие) установленные при кодировании [[Юникод]] точки в UTF-8 символ.

если служебные биты равны 110,1110 или 11110 то текущий октет — начало символа. если служебный бит равен 0 — это ASCII символ.если служебные биты равны 10 — текущий октет является продолжением.

2. Убрать служебные биты. Поскольку декодер UTF-8 уже определил длину символа, служебные биты больше не являются нужными, а также будут мешать этапу 3, именно поэтому декодер UTF-8 «вырезает» служебные биты из потока октетов используя побитовую операцию «И» с необходимой маской, обнуляющую служебные биты оставляя при этом биты с данными не подвергнутыми изменениям.

3. соединить изолированные биты в [[Юникод]] точку. После того, как декодер UTF-8 убрал служебные биты, его основной задачей является соединить изолированные между собой биты в [[Юникод]] точку.

Для этого декодер UTF-8 использует побитовый оператор «сдвига влево» (<<) который выполняет 2 операции:

1. перемещает младшие в кодировке UTF-8 биты на их изначальную, более старшую позицию.

2. защищает от наложений групп битов друг на друга тем, что перемещает группу битов в другое положение, оставляя свободное место для других групп битов.

После того, как декодер UTF-8 переместил младшие биты в кодировке UTF-8 в их изначальное более старшое место, он должен поместить и младшие биты исходного символа. Для этого он использует побитовую операцию «ИЛИ» (|), которая соединяет более младшую часть исходного символа, в уже существующий октет, где есть старшая часть исходного символа.

== Пример декодирования Unicode-строки из UTF-8 без предварительного расчёта итоговой длины на языке C ==
<syntaxhighlight lang="c" line="1">
#ifdef _WIN32 
	typedef unsigned __int8 u_int8_t;
	typedef unsigned __int16 u_int16_t;
	typedef unsigned __int32 u_int32_t;
	typedef unsigned __int64 u_int64_t;
	typedef wchar_t uchar_t;
#else
	#include <sys/types.h>
	typedef u_int16_t uchar_t;
#endif

size_t UTF8ToUnicode16LE(uchar_t** Dest, char* Src, size_t SrcLen) {
	// Буффер для ыорматированного вывода ошибок
	char buf[256];
	u_int8_t
		*src = (u_int8_t*)Src,				// Указатель на обрабатываемый байт
		*end = (u_int8_t*)(Src + SrcLen);	// Указатель на конец исходной строки
	uchar_t
		*dest =								// Указатель на декодируемую точку целевой строки
		(*Dest) = (uchar_t*)malloc((end - src + 1) * sizeof(**Dest)),	// Целевая строка
		head;								// сюда сохраняем первый байт последовательности
	u_int8_t
		tdata = 0b00111111U,	// Маска значимых битов последующих байтов
		check = 0b01000000U,	// Маска проверки последующих байтов
		fdata,					// Маска значащих битов первого байта
		iter,					// Маска-итератор первого байта
		fshift;					// счетчик сдвига битов первого байта
	/* Проверяем выделилась ли память */
	if (dest) {
		/* Инициализируем выделенную память нулями */
		memset(dest, 0, sizeof(**Dest) * SrcLen + sizeof(**Dest));
		/* Основной цикл прохода по исходной строке */
		for (; src < end; src++, dest++) {
			/* Если значение первого байта меньше 0x80 (128) */
			if ((*src) < 0x80UL) {
				// Значение меньше 128
				(*dest) = (*src);
			}
			else if (((*src) & 0b11000000U) == 0b11000000U) {
				/* Значение больше либо равно 192 */
				// сохраняем первый байт(заголовок)
				head = *src;
				// Сбрасываем счётчик сдвига
				fshift = 0;
				// Сбрасываем маску-итератор
				iter = 0b01000000U;
				// Сбрасываем маску значащих битов первого байта
				fdata = 0b00111111U;
				while (iter & head) {
					// Сдвигаем указатель на последовательность на следующий байт
					++src;
					/* Проверяем битовый маркер */
					if (((*src) ^ 0b01000000U) >= 0b11000000U) {
						// Сдвигаем биты влево на 6(количество значащих битов)
						(*dest) <<= 6;
						// Копируем младшие биты
						(*dest) |= ((*src) & 0b00111111U);
						// Увеличиваем счетчик сдвига
						fshift += 6;
						// Сдвигаем маску значащих битов первого байта вправо на 1 бит
						fdata >>= 1;
						// Сдвигаем маску-итератор вправо на 1 бит
						iter >>= 1;
					}
					else {
						/* Обрабатываем ошибку кодирования.
							Маркером ошибки служит обнуленный указатель на декодируемую точку */
						sprintf(buf, "Ошибка кодирования. Ожидалось: '0b10xxxxxx'. Индекс: %llu\n", dest - *Dest);
						perror(buf);
						// обнуляем указатель на декодируемую точку
						dest = NULL;
						break;
					}
				}
				/* Проверяем указатель на кодируемую точку */
				if (dest)
					// Копируем значащие биты первого байта сдвинув влево подсчитаное количество раз
					*dest |= ((uchar_t)(head & fdata) << fshift);
				else {
					// если Указатель обнулен - выходим из основного цикла
					break;
				}
			}
			else {
				// Обрабатываем ошибку кодирования первого байта
				sprintf(buf, "Ошибка кодирования. Ожидалось: '0b11xxxxxx' получено '0b10xxxxxx' Индекс: %llu\n", dest - *Dest);
				perror(buf);
				dest = NULL;
				break;
			}
		}
		// Проверяем на ошибки
		if (NULL != dest) {
			// На всякий случай обнуляем последний символ целевой строки
			*dest = (uchar_t)0U;
		}
		else {
			// Высвобождаем память
			free(*Dest);
			// Обнуляем целевой указатель для безопасности
			*Dest = NULL;
		}
	}
	// Ели возникла ошибка то вернётся 0, т.к. оба указателя будут равны NULL
	return dest - *Dest;
}

</syntaxhighlight>

== Маркер UTF-8 ==
Для указания, что файл или поток содержит символы [[Юникод]]а, в начале файла или потока может быть вставлен [[маркер последовательности байтов]] ({{lang-en|Byte order mark, BOM}}), который в случае кодирования в UTF-8 принимает форму трёх октетов: <code>EF BB BF<sub>16</sub></code>.
{| class="wikitable"
|-
! !! 1-й байт !! 2-й байт !! 3-й байт
|-
| [[Бинарный код|Двоичный код]] || <code>1110 1111</code> || <code>1011 1011</code> || <code>1011 1111</code>
|-
|[[Шестнадцатеричная система счисления|Шестнадцатеричный код]]
|<code>EF</code>
|<code>BB</code>
|<code>BF</code>
|}

== Пятый и шестой октеты ==
Изначально кодировка UTF-8 допускала использование до шести октетов для кодирования одного символа, однако в ноябре 2003 года стандарт RFC 3629 запретил использование пятого и шестого октетов, а диапазон кодируемых символов был ограничен символом <code>U+10FFFF</code>. Это было сделано для обеспечения совместимости с UTF-16.

== Возможные ошибки декодирования ==
Не всякая последовательность октетов является допустимой. Декодер UTF-8 должен понимать и адекватно обрабатывать такие ошибки:
* Недопустимый октет.
* октет продолжения (10xxxxxx) без начального октета.
* Отсутствие нужного количества октетов продолжения 10xxxxxx — например, двух после 1110xxxx.
* Строка обрывается посреди символа.
* Неэкономное кодирование — например, кодирование символа тремя октетами, когда можно двумя (существует нестандартный вариант UTF-8, который кодирует символ с кодом 0 как 1100.0000 1000.0000, отличая его от символа [[Нуль-терминированная строка|конца строки]] 0000.0000.)
* Последовательность октетов, декодирующаяся в недопустимую кодовую позицию (например символы суррогатных пар [[UTF-16]]).

== Примечания ==
{{примечания}}

== Ссылки ==
* [https://utf-8.su UTF-8 Стандарт кодирования]
* [https://symbl.cc/ru/ UTF-8 encoding table and Unicode characters]
* [https://habrahabr.ru/post/138173/ UTF-8: Кодирование и декодирование]
* [https://www.unicode.org/faq/utf_bom.html#UTF8 UTF-8, UTF-16, UTF-32 & BOM — Вопросы и ответы]
* [https://www.unicode.org/reports/tr26/ Compatibility Encoding Scheme for UTF-16: 8-Bit (CESU-8)]
* [http://www.unicode.org/ Полное описание стандарта Unicode]
* [https://utf8everywhere.org/ UTF-8 Everywhere Manifesto]
* [https://www.ietf.org/rfc/rfc3629.txt RFC-3629 «UTF-8, a transformation format of ISO 10646»]

{{Кодировки символов}}
{{Форматы данных}}

[[Категория:Юникод]]
[[Категория:Компьютерные кодировки]]