Как строка связана с руной в Go?

Взаимосвязь строк и рун в Go

В языке Go строка (string) и руна (rune) тесно связаны на уровне представления текстовых данных. Понимание этой связи критически важно для корректной работы с Unicode и многобайтовыми символами.

Основные определения

Руна (rune) в Go — это псевдоним для типа int32, представляющий собой кодовую точку Unicode. Каждая руна соответствует одному символу Unicode, независимо от того, сколько байт требуется для его кодировки в UTF-8.

// rune - это alias для int32
var r rune = 'A'       // Латинская 'A' (код 65)
var r2 rune = 'Я'      // Кириллическая 'Я' (код 1071)
var r3 rune = '😊'     // Эмодзи (код 128522)

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

// Строка - последовательность байт в UTF-8
str := "Привет, мир! 😊"

Ключевые аспекты взаимосвязи

1. UTF-8 кодировка строк

По умолчанию строки в Go содержат текст в кодировке UTF-8, где каждый символ Unicode (руна) может занимать от 1 до 4 байт:

package main

import "fmt"

func main() {
    str := "Go😊"  // 4 символа: 'G', 'o', '😊'
    
    // Длина в байтах (не в символах!)
    fmt.Println(len(str)) // Вывод: 6
    
    // Итерация по байтам
    for i := 0; i < len(str); i++ {
        fmt.Printf("%d: %x\n", i, str[i])
    }
    
    // Итерация по рунам
    for i, r := range str {
        fmt.Printf("%d: %U '%c'\n", i, r, r)
    }
}

2. Конвертация между строками и рунами

Строку можно преобразовать в срез рун и обратно:

func convertExamples() {
    // Строка -> срез рун
    str := "Привет"
    runes := []rune(str)  // Преобразование в срез рун
    
    // Теперь каждый элемент - отдельная кодовая точка
    fmt.Println(len(runes))  // 6 символов (не байт!)
    
    // Руна -> строка
    r := '世'
    strFromRune := string(r)  // Преобразование руны в строку
    
    // Срез рун -> строка
    runesSlice := []rune{'界', '!', '😊'}
    strFromRunes := string(runesSlice)
}

3. Индексация и итерация

При индексации строки по индексу (str[i]) вы получаете байт, а не символ:

func indexingExample() {
    str := "мир"
    
    // Индексация возвращает байт
    b := str[0]  // 209 (первый байт кириллической 'м')
    
    // Правильный способ итерации - range
    for index, runeValue := range str {
        fmt.Printf("Index: %d, Rune: %U, Char: %c\n", 
                   index, runeValue, runeValue)
    }
}

4. Практические различия в работе

func practicalDifferences() {
    str := "café"
    
    // Неправильно: подсчет байтов
    byteCount := len(str)  // 5 байт
    
    // Правильно: подсчет символов
    runeCount := len([]rune(str))  // 4 символа
    
    // Получение подстроки по индексам байт
    subStr := str[0:3]  // "caf" - может обрезать символ!
    
    // Работа с отдельными символами
    for _, r := range str {
        // Каждая итерация получает полный символ Unicode
        processRune(r)
    }
}

Важные практические рекомендации

Когда использовать руны:

• Обработка отдельных символов (например, нормализация, сравнение)
• Подсчет количества символов в строке (не байтов!)
• Манипуляции с символами (изменение регистра, проверка категорий Unicode)

import "unicode"

func runeOperations() {
    r := 'Я'
    
    // Проверка категории Unicode
    if unicode.IsLetter(r) {
        // Преобразование регистра
        lower := unicode.ToLower(r)
    }
}

Когда работать напрямую со строками:

• Чтение/запись в файлы или сетевые соединения
• Поиск подстрок (функции из пакета strings)
• Конкатенация и базовые манипуляции

Преобразования между типами

func typeConversions() {
    // string -> []rune (символьное представление)
    str := "Hello, 世界!"
    runeSlice := []rune(str)
    
    // []rune -> string
    newStr := string(runeSlice)
    
    // string -> []byte (байтовое представление)
    byteSlice := []byte(str)
    
    // []byte -> string
    strFromBytes := string(byteSlice)
}

Распространенные ошибки

1. Использование индексации для символов вместо итерации через range
2. Подсчет длины строки через len() для получения количества символов
3. Обрезание строк по индексам байт без учета границ символов UTF-8
4. Предположение, что все символы занимают 1 байт

Оптимизации производительности

• Преобразование string → []rune создает новый аллоцированный срез
• Итерация через range по строке эффективна и не аллоцирует память
• Для частых операций с символами выгоднее один раз преобразовать в []rune

Заключение

Строка в Go — это байтовый контейнер с UTF-8 содержимым, а руна — отдельная кодовая точка Unicode. Их взаимосвязь обеспечивает эффективную работу с текстом на всех языках мира, но требует понимания разницы между байтами и символами. Правильное использование этих типов позволяет создавать интернационализированные приложения без ошибок, связанных с кодировками.