Как получить символ строки по индексу в Rust? Индексация строк

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

Это одна из самых частых "ловушек" для новичков в Rust. Причина кроется в кодировке UTF-8. В отличие от языков вроде Python, где строки — это массивы Unicode-символов фиксированной длины, в Rust строки хранятся как последовательности байтов в кодировке UTF-8. Это значит, что один "символ" (графема) может занимать от 1 до 4 байтов. Например, русская буква "П" занимает 2 байта, а эмодзи "🔥" — 4 байта.

Если бы Rust разрешил индексацию как hello[0], вы бы получили не символ, а первый байт, который может быть частью многобайтового символа. Это привело бы к трудноуловимым багам и нарушению гарантий безопасности, которые Rust так ценит.

Правильные способы работы с символами строки

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

Метод .chars() возвращает итератор по Unicode-символам (тип char). Это самый безопасный способ:

fn main() {
    let hello = String::from("Привет");
    
    // Получить n-й символ (осторожно: O(n)!)
    let n = 2;
    let third_char = hello.chars().nth(n).unwrap();
    println!("Символ #{}: '{}'", n, third_char); // Выведет: 'и'
    
    // Перебрать все символы
    for (i, c) in hello.chars().enumerate() {
        println!("Индекс {}: '{}'", i, c);
    }
}

Важно: .nth() имеет сложность O(n), так как ему нужно пройти все предыдущие символы. Для частого доступа по индексу лучше собрать символы в вектор:

let chars: Vec<char> = hello.chars().collect();
println!("Первый символ: {}", chars[0]); // 'П'

2. Работа с байтами через .bytes()

Если вам действительно нужны отдельные байты (например, для бинарных протоколов):

fn main() {
    let s = String::from("Hi🔥");
    for (i, byte) in s.bytes().enumerate() {
        println!("Байт {}: {}", i, byte);
    }
    // Вывод: Байт 0: 72 ('H')
    //        Байт 1: 105 ('i')
    //        Байт 2: 240 (начало 🔥)
    //        Байт 3: 159
    //        Байт 4: 145
    //        Байт 5: 162
}

3. Получение подстроки через срезы

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

fn main() {
    let hello = String::from("Привет мир!");
    
    // Безопасный срез (осторожно с индексами!)
    if let Some(sub) = hello.get(0..6) {
        println!("Первые 6 байт: '{}'", sub); // "При"
    }
    
    // Если индекс попадает не на границу символа - panic!
    // hello[0..1] - вызовет панику, т.к. 'П' занимает 2 байта
    
    // Безопасный вариант с проверкой
    match hello.get(0..1) {
        Some(_) => println!("Успех"),
        None => println!("Неверная граница символа"),
    }
}

Почему это хорошо, а не плохо?

• Безопасность: Вы никогда не получите "битый" символ на стыке байтов.
• Производительность: Строки не нужно перекодировать при передаче в C-библиотеки или по сети.
• Предсказуемость: Длина строки в байтах известна сразу (.len()), а количество символов можно узнать только итерацией (.chars().count()).

В итоге: если вам нужно работать с символами — используйте .chars(). Если с байтами — .bytes(). Если с подстроками — .get() с явными байтовыми границами. Так вы получите всю мощь Rust без неожиданных ошибок!

// Добавьте в Cargo.toml: unicode-segmentation = "1.10"
use unicode_segmentation::UnicodeSegmentation;

fn main() {
    let family = "👨‍👩‍👧‍👦";
    
    // Графемные кластеры (то, что видит пользователь)
    let graphemes: Vec<&str> = family.graphemes(true).collect();
    println!("Количество графем: {}", graphemes.len()); // 1
    
    // Сравните с .chars()
    println!("Количество char: {}", family.chars().count()); // 7
}