Result является более богатой версией типа Option, тип который описывает возможную ошибку вместо возможного её отсутствия.
Result имеет два возможных значения:
• Ok(T): Значение типа T
• Err(E): Ошибка обработки элемента, типа E
По соглашению, ожидаемый результат Ok, тогда как не ожидаемый - Err.
Подобно Option, Result имеет множество ассоциированных с ним методов. Например, unwrap() или возвращает T, или вызывает panic. Для обработки результата у Result существует множество комбинаторов, которые совпадают с комбинаторами Option.
При работе с Rust вы, скорее всего, столкнётесь с методами, которые возвращают тип Result, например метод parse(). Не всегда можно разобрать строку в другой тип, поэтому parse() возвращает Result, указывающий на возможный сбой.
Давайте посмотрим, что происходит, когда мы успешно и безуспешно попытаемся преобразовать строку с помощью parse():
fn multiply(first_number_str: &str, second_number_str: &str) -> i32 {
// Давайте попробуем использовать `unwrap()` чтобы получить число. Он нас укусит?
let first_number = first_number_str.parse::().unwrap();
let second_number = second_number_str.parse::().unwrap();
first_number * second_number
}
fn main() {
let twenty = multiply("10", "2");
println!("удовоенное {}", twenty);
let tt = multiply("t", "2");
println!("удвоенное {}", tt);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
При неудаче, parse() оставляет на с ошибкой, с которой unwrap() вызывает panic. Дополнительно, panic завершает нашу программу и предоставляет неприятное сообщение об ошибке.
Для повышения качества наших сообщений об ошибка, мы должны более явно указать возвращаемый тип и рассмотреть возможной явной обработки ошибок.
ИспользованиеResultвmain
Также Result может быть возвращаемым типом функции main, если это указано явно. Обычно функция main имеют следующую форму:
fn main() {
println!("Hello World!");
}
Однако main также может и возвращать тип Result. Если ошибка происходит в пределах функции main, то она возвращает код ошибки и выводит отладочное представление ошибки (используя типаж Debug). Следующий пример показывает такой сценарий и затрагивает аспекты, описанные в последующем разделе.
use std::num::ParseIntError;
fn main() -> Result<(), ParseIntError> {
let number_str = "10";
let number = match number_str.parse::() {
Ok(number) => number,
Err(e) => return Err(e),
};
println!("{}", number);
Ok(())
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
mapдляResult
Паника в предыдущем примере делает код ненадёжным. Обычно, мы хотим вернуть ошибку вызывающей стороне, чтобы уже она решала, как с ней поступить.
Первое, что нам нужно знать - это с каким типом ошибки мы работаем. Для определения типа Err, мы посмотрим на parse(), реализованную с типажом FromStr для i32. В результате, тип Err указан как ParseIntError.
В примере ниже, простой match делает код более громоздким.
use std::num::ParseIntError;
// Мы используем сопоставление с образцом без `unwrap()` и меняем тип результата.
fn multiply(first_number_str: &str, second_number_str: &str) -> Result {
match first_number_str.parse::() {
Ok(first_number) => {
match second_number_str.parse::() {
Ok(second_number) => {
Ok(first_number * second_number)
},
Err(e) => Err(e),
}
},
Err(e) => Err(e),
}
}
fn print(result: Result) {
match result {
Ok(n) => println!("n равно {}", n),
Err(e) => println!("Ошибка: {}", e),
}
}
fn main() {
// Это даёт разумный ответ.
let twenty = multiply("10", "2");
print(twenty);
// Следующее теперь предоставляет более понятное сообщение об ошибке.
let tt = multiply("t", "2");
print(tt);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
К счастью, map, and_then многие другие комбинаторы Option также реализованы и для Result. Документация поResult содержит полный их список.
use std::num::ParseIntError;
// Как и с `Option`, мы можем использовать комбинаторы, как `map()`.
// Эта функция в основном идентична предыдущей и читается как:
// изменяем n при валидном значении, иначе передаём ошибку.
fn multiply(first_number_str: &str, second_number_str: &str) -> Result {
first_number_str.parse::().and_then(|first_number| {
second_number_str.parse::().map(|second_number| first_number * second_number)
})
}
fn print(result: Result) {
match result {
Ok(n) => println!("n равно {}", n),
Err(e) => println!("Ошибка: {}", e),
}
}