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

Размер символа строки в Go: UTF-8 и управление памятью

В языке Go строка (string) представляет собой последовательность байтов, но важно понимать, что каждый символ (видимая единица текста) может занимать от 1 до 4 байтов. Это связано с тем, что строки в Go хранятся в памяти как байтовые последовательности в кодировке UTF-8. UTF-8 — это переменная многобайтная кодировка для представления символов Unicode.

Влияние Unicode на размер символа

UTF-8 кодирует символы следующим образом:

• 1 байт: для ASCII символов (английские буквы, цифры, основные знаки) — коды от 0 до 127.
• 2 байта: для символов из большинства европейских языков (например, латинские буквы с диакритическими знаками).
• 3 байта: для символов многих других алфавитов (например, китайские, японские, корейские иероглифы).
• 4 байта: для редких символов, эмодзи и некоторых специальных знаков.

Примеры на практике

Рассмотрим примеры, демонстрирующие разницу в размере:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	// Пример строки с различными символами
	str := "Hello, 世界! 🌍"
	
	// Длина в байтах (фактический размер в памяти)
	byteLength := len(str)
	fmt.Printf("Длина строки в байтах: %d\n", byteLength)
	
	// Длина в символах (количество видимых символов Unicode)
	charLength := utf8.RuneCountInString(str)
	fmt.Printf("Количество символов (рун): %d\n", charLength)
	
	// Подсчет байт для каждого символа
	fmt.Println("\nРазбор каждого символа:")
	for i, r := range str {
		// r — это руна (int32), представляющая один символ Unicode
		bytes := utf8.RuneLen(r)
		fmt.Printf("Символ '%c' занимает %d байт, начинается с позиции %d\n", r, bytes, i)
	}
	
	// Альтернативный способ с использованием декодирования рун
	fmt.Println("\nДекодирование рун:")
	for i := 0; i < len(str); {
		r, size := utf8.DecodeRuneInString(str[i:])
		fmt.Printf("Руна '%c' размер: %d байт\n", r, size)
		i += size
	}
}

Результат выполнения этого кода покажет, что:

• Символы H, e, l, o, ,, , ! занимают 1 байт (ASCII).
• Символы 世, 界 занимают 3 байта каждый (китайские иероглифы).
• Символ 🌍 занимает 4 байта (эмодзи).

Ключевые термины и функции для работы

• Руна (Rune): в Go тип rune представляет собой целочисленный тип (int32), используемый для одного символа Unicode.
• len(string): возвращает количество байтов в строке, не количество символов.
• utf8.RuneCountInString(): возвращает фактическое количество символов Unicode в строке.
• utf8.DecodeRuneInString(): декодирует первую руну в строке и возвращает ее размер в байтах.
• utf8.RuneLen(): возвращает количество байтов, необходимых для кодирования руны в UTF-8.

Практические рекомендации

1. Для подсчета символов всегда используйте utf8.RuneCountInString(), а не len(), если работаете с текстом, содержащим не-ASCII символы.
2. Для итерации по символам используйте цикл for range по строке, который автоматически декодирует руны:

   for index, runeValue := range str {
       // index — позиция начала руны в байтах
       // runeValue — сама руна как int32
   }
   

3. При работе с памятью учитывайте, что строки могут занимать значительно больше байтов, чем количество видимых символов.
4. Для эффективной обработки текстов в международных приложениях учитывайте многобайтную структуру UTF-8 при операциях подсчета, поиска подстрок или разбиения строк.

Таким образом, прямой ответ на вопрос: один символ строки в Go занимает от 1 до 4 байтов, в зависимости от его позиции в таблице Unicode и кодировки UTF-8. Для получения точного размера конкретного символа необходимо использовать функции из пакета unicode/utf8.