Строки

В Rust есть два типа строк: String и &str.

String сохраняется как вектор байт (Vec<u8>), но с гарантией, что это всегда будет действительная UTF-8 последовательность. String выделяется в куче, расширяемая и не заканчивается нулевым байтом (не null-terminated).

&str - это срез (&[u8]), который всегда указывает на действительную UTF-8 последовательность, и является отображением String, так же как и &[T] - отображение Vec<T>.

fn main() {
    // (все аннотации типов избыточны)
    // Ссылка на строку, размещённую в read-only памяти
    let pangram: &'static str = "the quick brown fox jumps over the lazy dog";
    println!("Pangram: {}", pangram);

    // Итерируемся по словам в обратном прядке, новая строка не аллоцируется
    println!("Words in reverse");
    for word in pangram.split_whitespace().rev() {
        println!("> {}", word);
    }

    // Копируем символы в вектор, сортируем и удаляем дубликаты
    let mut chars: Vec<char> = pangram.chars().collect();
    chars.sort();
    chars.dedup();

    // Создаём пустую расширяемую `String`
    let mut string = String::new();
    for c in chars {
        // Добавляем символ в конец строки
        string.push(c);
        // Добавляем в конец строки другую строку
        string.push_str(", ");
    }

    // Усечённая строка - это срез оригинальной строки, а значит новых 
    // аллокаций не производится
    let chars_to_trim: &[char] = &[' ', ','];
    let trimmed_str: &str = string.trim_matches(chars_to_trim);
    println!("Used characters: {}", trimmed_str);

    // Строка, аллоцированная в куче
    let alice = String::from("I like dogs");
    // Выделяется новая память, в которую сохраняется модифицированная строка
    let bob: String = alice.replace("dog", "cat");

    println!("Alice says: {}", alice);
    println!("Bob says: {}", bob);
}

Больше методов str и String вы можете найти в описании модулей std::str и std::string.

Литералы и экранирование

Есть несколько способов написать строковый литерал со специальными символами в нём. Все способы приведут к одной и той же строке, так что лучше использовать тот способ, который легче всего написать. Аналогично все способы записать строковый литера из байтов в итоге дадут &[u8; N].

Обычно специальные символы экранируются с помощью обратной косой черты: \. В этом случае вы можете добавить в вашу строку любые символы, даже непечатаемые и те, которые вы не знаете как набрать. Если вы хотите добавить обратную косую черту, экранируйте его с помощью ещё одной: \\.

Строковые или символьные разделители литералов (кавычки, встречающиеся внутри другого литерала, должны быть экранированы: "\"", '.'.

fn main() {
    // Вы можете использовать экранирование для записи байтов 
    // при помощи их шестнадцатиричных значений...
    let byte_escape = "Я пишу на \x52\x75\x73\x74!";
    println!("Что ты делашь\x3F (\\x3F означает ?) {}", byte_escape);

    // ... или кодов Unicode.
    let unicode_codepoint = "\u{211D}";
    let character_name = "\"DOUBLE-STRUCK CAPITAL R\"";

    println!("Unicode символ {} (U+211D) называется {}",
                unicode_codepoint, character_name );


    let long_string = "Строковый литерал
                       может занимать несколько строк.
                       Разрыв строки и отступ ->\
                       <- также можно экранировать!";
    println!("{}", long_string);
}

Иногда приходится экранировать слишком много символов или легче записать строку как она есть. В этот момент в игру вступают сырые строковые литералы.

fn main() {
    let raw_str = r"Экранирование здесь не работает: \x3F \u{211D}";
    println!("{}", raw_str);

    // Если вам необходимы кавычки с сырой строке, добавьте пару `#`
    let quotes = r#"И затем я сказал: "Здесь нет экранирования!""#;
    println!("{}", quotes);

    // Если вам необходимо добавить в вашу строку `"#`, то просто добавьте больше `#` в разделитель.
    // Здесь нет ограничений на количество `#` которое вы можете использовать.
    let longer_delimiter = r###"Строка с "# внутри неё. И даже с "##!"###;
    println!("{}", longer_delimiter);
}

Хотите строку, которая не UTF-8? (Помните, str и String должны содержать действительные UTF-8 последовательности). Или возможно вы хотите массив байтов, которые в основном текст? Байтовые строки вас спасут!

use std::str;

fn main() {
    // Обратите внимание, что в действительности это не `&str`
    let bytestring: &[u8; 21] = b"это строка байтов";

    // Для массива байтов не реализован типаж `Display`, поэтому способы его печати ограничены
    println!("Строка байтов: {:?}", bytestring);

    // Байтовые строки могут содержать экранированные байты...
    let escaped = b"\x52\x75\x73\x74 как байты";
    // ... но не Unicode
    // let escaped = b"\u{211D} здесь не разрешён";
    println!("Экранированные байты: {:?}", escaped);


    // Сырые байтовые строки работают также, как и сырые строки
    let raw_bytestring = br"\u{211D} здесь не экранировано";
    println!("{:?}", raw_bytestring);

    // Преобразование массива байт в `str` может завершиться ошибкой
    if let Ok(my_str) = str::from_utf8(raw_bytestring) {
        println!("И то же самое в виде текста: '{}'", my_str);
    }

    let _quotes = br#"Вы также можете использовать удобное для вас форматирование, \
                      как и с обычными сырыми строками"#;

    // Байтовые строки не обязаны быть UTF-8
    let shift_jis = b"\x82\xe6\x82\xa8\x82\xb1\x82"; // "ようこそ" в SHIFT-JIS

    // Но из-за этого они не всегда могут быть преобразованы в `str`
    match str::from_utf8(shift_jis) {
        Ok(my_str) => println!("Удачное преобразование: '{}'", my_str),
        Err(e) => println!("Неудачное преобразование: {:?}", e),
    };
}

Для преобразования между кодировками символов, посмотрите крейт encoding.

Более детальный список способов записи строковых литералов и экранирования символов можно найти в главе 'Tokens' Rust Reference.