Итерация по строке в Rust: как обойти символы без боли

Итерация по строке в Rust: как это работает под капотом

Вы когда-нибудь задумывались, что на самом деле происходит, когда вы пишете for c in "Привет".chars()? Если вы пришли из Python или JavaScript, где строки — это просто массивы символов, Rust может показаться вам строгим учителем, который заставляет вас думать перед каждым действием. И это здорово!

Вопрос "How do you iterate over a string by character" на Stack Overflow собрал тысячи просмотров. И неспроста. В Rust нет простого string[i] — и на то есть веские причины. Давайте разберёмся, как итерировать строку правильно, эффективно и без сюрпризов.

Почему Rust не даёт вам просто так взять символ по индексу?

Всё дело в кодировке UTF-8. В отличие от многих языков, Rust хранит строки именно в UTF-8, а не в ASCII или UCS-2. Это значит, что один символ может занимать от 1 до 4 байт. Например:

• 'a' — 1 байт
• 'é' — 2 байта
• '中' — 3 байта
• '😊' — 4 байта

Если бы Rust позволял делать string[0], то "😊"[0] вернул бы не смайлик, а половину его байтового представления — мусор. Поэтому Rust защищает вас от таких ошибок на уровне компилятора.

Основные способы итерации по строке

Rust предлагает три основных метода итерации, каждый со своим назначением. Выбор зависит от того, что именно вам нужно: символы, байты или графемы.

1. Итерация по символам (char)

Самый распространённый способ — метод .chars(). Он возвращает итератор по символам Unicode (тип char).

fn main() {
    let text = "Привет, мир! 🌍";
    
    for c in text.chars() {
        println!("{}", c);
    }
    
    // Вывод:
    // П
    // р
    // и
    // в
    // е
    // т
    // ,
    // (пробел)
    // м
    // и
    // р
    // !
    // (пробел)
    // 🌍
}

Под капотом .chars() разбирает байтовую последовательность UTF-8 и возвращает каждый корректный символ. Если в строке есть некорректные байты, итератор может вернуть std::char::REPLACEMENT_CHARACTER ('�').

Важно: .chars() — это O(n). Итератор проходит по всем байтам, декодируя их на лету. Для коротких строк это мгновенно, но для длинных (мегабайты текста) может быть заметно.

2. Итерация по байтам (bytes)

Если вам нужны сырые байты, используйте .bytes(). Это быстрый способ, но вы получаете байты, а не символы.

fn main() {
    let text = "Hello";
    
    for byte in text.bytes() {
        println!("{}", byte);
    }
    
    // Вывод:
    // 72 (H)
    // 101 (e)
    // 108 (l)
    // 108 (l)
    // 111 (o)
}

Для английского текста это эквивалентно итерации по символам. Но для русского или эмодзи — нет. Например, "Привет" в байтах будет 12 байт (по 2 на символ), а "🌍" — 4 байта.

Когда использовать: когда вы работаете с бинарными данными, протоколами или хотите максимальной производительности без декодирования UTF-8.

3. Итерация по графемам (grapheme clusters)

А вот это уже интереснее. Иногда один "символ" визуально состоит из нескольких Unicode-символов. Например, флаг страны или буква с диакритическими знаками: "é" может быть представлена как один символ é (U+00E9) или как комбинация e + ◌́ (U+0065 + U+0301).

Для работы с графемами нужно подключить крейт unicode-segmentation:

// Cargo.toml
// [dependencies]
// unicode-segmentation = "1.10"

use unicode_segmentation::UnicodeSegmentation;

fn main() {
    let text = "é";
    
    // chars() вернёт 1 символ, если é — один код
    // или 2 символа, если это комбинация
    println!("Количество char: {}", text.chars().count());
    
    // graphemes() всегда вернёт 1 графему
    println!("Количество графем: {}", text.graphemes(true).count());
}

Это особенно важно для:

• Визуального отображения текста
• Редакторов и полей ввода
• Обработки эмодзи (флаги, скин-тоны)

Производительность: что выбрать?

Давайте посмотрим на реальные цифры. Я протестировал три метода на строке длиной 100 000 символов (смесь латиницы, кириллицы и эмодзи):

Вывод: если вам не нужна семантика символов — берите .bytes(). Если нужны символы — .chars(). .graphemes() используйте только когда это действительно необходимо.

Подводные камни и частые ошибки

Даже опытные разработчики попадаются на этих граблях. Давайте разберём основные.

Ошибка 1: Попытка индексации

let s = "Привет";
// let c = s[0]; // Ошибка компиляции!
// Правильно:
let c = s.chars().next().unwrap(); // 'П'

Ошибка 2: Итерация по String vs &str

Методы .chars() и .bytes() работают как для String, так и для &str. Но есть нюанс: String — это владеющий тип, а &str — ссылка.