Има повече от един начин за справяне с грешки в Rust, така че не забравяйте да обмислите всички опции.

Грешките са неизбежни и могат да възникнат по различни причини, от невалиден потребителски вход до мрежови повреди, хардуерни неизправности или грешки в програмирането. Обработката на грешки е процес на откриване, докладване и възстановяване от такива грешки, за да се предотвратят сривове на програмата или повреда на данните.

Ефективното обработване на грешки е критично в Rust. Позволява ви да създавате стабилни, надеждни приложения, които могат да се справят с неочаквани грешки и откази. Механизмите на Rust за обработка на грешки ви позволяват да разработвате устойчиви, сигурни програми, които са по-лесни за поддръжка.

Видовете грешки в Rust

Rust има богата система от типове, която можете да използвате справяйте се с грешки умело, според видовете им. Предимствата на богатата система за грешки на Rust пред традиционните подходи за обработка на грешки не могат да бъдат подценени. Системата за тип грешка предоставя

instagram viewer
подобрена безопасност на типа, възможност за композиране, изразителност и възможност за отстраняване на грешки.

Ето списък с често срещани типове грешки в Rust:

  • The std:: io:: Грешка тип представлява входно/изходни грешки като файлът не е намерен, разрешението е отказано или е достигнат краят на файла.
  • The std:: num:: ParseIntError тип представлява грешки, които възникват при операции за анализиране на низ към цяло число.
  • The std:: option:: NoneError тип представлява грешки от разопаковане на празни опции.
  • The std:: result:: Резултат type е общ тип резултат, който можете да използвате за представяне на всяка грешка.

Всеки тип грешка има свой собствен набор от методи и характеристики за справяне с нея по специфични начини.

Ето пример за обработка на грешка в Rust за операция за четене на файл:

използване std:: fs:: файл;
използване std:: io:: Четене;
fnread_file(път: &ул) -> Резултат<низ, std:: io:: Грешка> {
позволяваммут файл = Файл:: отворен (път)?;
позволяваммут съдържание = низ::ново();
 file.read_to_string(&мут съдържание)?;
Добре(съдържание)
}

The read_file функцията чете съдържанието на файла в посочения път и го връща като низ. Връща a std:: io:: Грешка ако операцията за отваряне или четене на файла е неуспешна. The ? оператор разпространява грешката и връща грешката като a Резултат.

Механизми за обработка на грешки в Rust

Една ключова характеристика, която допринася за безопасността на Rust, са неговите механизми за обработка на грешки. В Rust има четири основни механизма за обработка на грешки: Резултат тип, на опция тип, на паника! макрос и Грешка Характерна черта.

Типовете Резултат и Опция позволяват структурирана обработка на грешки. Можете да използвате паниката! макрос за обработка на непоправими грешки. Характеристиката за грешка ви позволява да дефинирате персонализирани типове грешки и персонализирана обработка на грешки.

Тип резултат

The Резултат type е вграден тип, представящ резултата от операция, която може да се провали. Има два варианта: Добре вариант, който представлява успех и съдържа стойност, и грешка, което представлява грешка и съдържа стойност за грешка.

Ето как можете да използвате типа резултат, за да отворите файл и да прочетете съдържанието му:

използване std:: fs:: файл;
използване std:: io:: prelude::*;
fnread_file(файлова пътека: &ул) -> Резултат<низ, std:: io:: Грешка> {
позволяваммут файл = Файл:: отворен (път_на_файл)?;
позволяваммут съдържание = низ::ново();
 file.read_to_string(&мут съдържание)?;
Добре(съдържание)
}


fnосновен() {
позволявам резултат = read_file("файл.txt");
съвпада резултат {
Добре(съдържание) => println!("{}", съдържание),
грешка(д) => println!(„Грешка: {}“, д),
 }
}

The read_file функцията приема пътя на файла и връща a Резултат грешка. Ако операцията за четене или отваряне на файл е неуспешна, функцията връща грешка стойност. В противен случай функцията връща Добре стойност. В основен функция, на съвпада изявлението обработва Резултат стойност и отпечатва резултата в зависимост от ситуацията на файловата операция.

Тип опция

The опция type е вграден тип, представящ присъствието или отсъствието на стойност. The опция тип има два варианта. някои представлява стойност и Нито един представлява липсата на стойност.

Ето как можете да използвате опция тип за извличане на първия елемент от вектор.

fnget_first_elementКлонинг>(vec: Vec) -> опция {
ако vec.is_empty() {
Нито един
 } друго {
някои(vec.first().unwrap().clone())
 }
}
fnосновен() {
позволявам vec = vec![1, 2, 3];
позволявам резултат = get_first_element (vec);
съвпада резултат {
някои(елемент) => println!("{}", елемент),
Нито един => println!(„Векторът е празен.“),
 }
}

The get_first_element функцията връща an опция Тип. Ако векторът е празен, функцията се връща Нито един; в противен случай функцията се връща някои съдържащ първия елемент на вектора. В основен функция, на съвпада изявлението обработва опция стойност. Ако опция оценява до някои, функцията отпечатва първия елемент. В противен случай функцията отпечатва съобщение, което показва, че векторът е празен.

Паниката! Макро

The паника! макрос предоставя функционалност за обработка на непоправими грешки в Rust. При обаждане на паника! макрос, той отпечатва съобщение за грешка и прекратява програмата.

Ето пример за използване на паника! макрос, за да покаже, че дадена функция има невалидни аргументи.

fnразделям(дивидент: f64, делител: f64) -> f64 {
ако делител == 0.0 {
паника!("Делителят не може да бъде нула.");
 }
 дивидент / делител
}
fnосновен() {
позволявам резултат = деление(4.0, 0.0);
println!("{}", резултат);
}

The разделям функция проверява дали делителя е нула; ако делителят е нула, функцията извиква паника! макрос със съобщение за грешка; в противен случай функцията изчислява и връща резултата

The основен функцията извиква функцията за разделяне с невалидни аргументи, за да задейства паника! макрос.

Ето съобщението за грешка:

Чертата на грешката

The Грешка trait е вградена черта, която определя поведението на типовете грешки. The Грешка trait предоставя функционалност за дефиниране на потребителски типове грешки и персонализирана обработка на грешки.

Ето пример за дефиниране на персонализиран тип грешка, който представлява грешка, че файлът не е намерен.

използване std:: грешка:: грешка;
използване std:: fmt;
използване std:: io:: Четене;
#[извличане (отстраняване на грешки)]
структураФайлът не е намерен(низ);


импл fmt:: Дисплей за Файлът не е намерен {
fnfmt(&себе си, f: &мут fmt:: Formatter) -> fmt::Резултат {
пиши!(е, "Файлът не е намерен: {}", себе си.0)
 }
}


импл Грешка за Файлът не е намерен {}


fnread_file(файлова пътека: &ул) -> Резултат<низ, Кутия<дин Грешка>> {
позволяваммут file = std:: fs:: File:: open (file_path).map_err(|e| FileNotFound(формат!("{}", д)))?;
позволяваммут съдържание = низ::ново();
 file.read_to_string(&мут съдържание)?;
Добре(съдържание)
}


fnосновен() {
позволявам резултат = read_file("файл.txt");
съвпада резултат {
Добре(съдържание) => println!("{}", съдържание),
грешка(д) => println!(„Грешка: {}“, д),
 }
}

Персонализираният тип грешка е Файлът не е намерен структура Типът съдържа път към файла и Файлът не е намерен тип изпълнява Дисплей черта за връщане на удобни за потребителя съобщения за грешки и Грешка характеристика, която показва, че това е тип грешка.

В read_file функция, на Файлът не е намерен типът на грешката представлява грешка, че файлът не е намерен, а map_err метод преобразува грешката std:: io:: в грешка FileNotFound. накрая кутията type позволява на функцията да върне всеки тип, който имплементира характеристиката Error.

The основен функция извиква read_file функция с пътя на файла и, ако намери файла, отпечатва съдържанието му на конзолата. В противен случай той отпечатва съобщението за грешка.

Ето резултата за файл, който не съществува:

Можете да заложите на модела на собственост на Rust за безопасност на програмата

В съчетание с великолепния механизъм на Rust за обработка на грешки, Rust също използва модел на собственост, който помага да се гарантира, че вашите програми са безопасни за паметта.

Rust гарантира правилата за собственост с инструмент за проверка на заеми по време на компилация, преди вашата програма да се изпълни.