Rust на примерах

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

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

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

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 = 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);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Больше методов 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);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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

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.