// ... или кодов 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.
Option
Иногда желательно перехватить ошибку в какой-либо части программы вместо вызова паники с помощью макроса panic!. Это можно сделать с помощью перечисления Option.
Перечисление Option имеет два варианта:
• None, указывающий о наличии ошибки или отсутствия значений
• Some(value), кортежная структура, обёртка для значения типа T.
// Целочисленное деление, которое не вызывает `panic!`
fn checked_division(dividend: i32, divisor: i32) -> Option {
if divisor == 0 {
// В случае ошибки возвращаем `None`
None
} else {
// Результат деления возвращаем в варианте `Some`
Some(dividend / divisor)
}
}
// Эта функция обрабатывает деление, которое может выполнится с ошибкой
fn try_division(dividend: i32, divisor: i32) {
// Значение типа `Option` могут быть сопоставлены по шаблону
match checked_division(dividend, divisor) {
None => println!("{} / {} вызвало ошибку!", dividend, divisor),
Some(quotient) => {
println!("{} / {} = {}", dividend, divisor, quotient)
},
}
}
fn main() {
try_division(4, 2);
try_division(1, 0);
// Привязка `None` к переменной должна быть аннотированной по типу
let none: Option = None;
let _equivalent_none = None::;
let optional_float = Some(0f32);
// Распаковка варианта `Some` будет извлекать данные, которые в нем находятся.
println!("{:?} распаковывается в {:?}", optional_float, optional_float.unwrap());
// Распаковка варианта `None` вызовет `panic!`
println!("{:?} распаковывается в {:?}", none, none.unwrap());
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Result
Раньше мы видели, что в качестве возвращаемого значения из функции, которая может завершиться с ошибкой, можно использовать перечисление Option, в котором None будет обозначать неудачу. Однако иногда важно понять почему операция потерпела неудачу. Для этого у нас есть перечисление Result.
Перечисление Result имеет два варианта:
• Ok(value), который обозначает, что операция успешно завершилась, и оборачивает значение (value), возвращаемое операцией (value имеет тип T).
• Err(why), который показывает, что операция потерпела неудачу, оборачивает значение ошибки (причину, why), которое (надеемся) описывает причину неудачи. why имеет тип E.
mod checked {
// Математические "ошибки", которые мы хотим отлавливать
#[derive(Debug)]