Рефакторинг для улучшения модульности и обработки ошибок
Чтобы улучшить нашу программу, мы исправим четыре проблемы, связанные со структурой программы и тем, как она обрабатывает потенциальные ошибки. Во-первых, наша функция main теперь выполняет две задачи: она разбирает аргументы и читает файлы. По мере роста программы количество отдельных задач, которые обрабатывает функция main, будет увеличиваться. По мере того как функция приобретает обязанности, становится всё труднее рассуждать о ней, труднее тестировать и труднее изменять, не сломав какую-либо из её частей. Лучше разделить функциональность так, чтобы каждая функция отвечала за одну задачу.
Эта проблема также связана со второй проблемой: хотя query и file_path являются конфигурационными переменными для нашей программы, переменные вроде contents используются для выполнения логики программы. Чем длиннее становится main, тем больше переменных нам нужно будет ввести в область видимости; чем больше переменных у нас в области видимости, тем труднее будет отслеживать назначение каждой. Лучше сгруппировать конфигурационные переменные в одну структуру, чтобы сделать их назначение ясным.
Третья проблема заключается в том, что мы использовали expect для печати сообщения об ошибке, когда чтение файла не удаётся, но сообщение об ошибке просто печатает Should have been able to read the file. Чтение файла может завершиться неудачей по ряду причин: например, файл может отсутствовать, или у нас может не быть разрешения на его открытие. Прямо сейчас, независимо от ситуации, мы печатали бы одно и то же сообщение об ошибке для всего, что не дало бы пользователю никакой информации!
В-четвёртых, мы используем expect для обработки ошибки, и если пользователь запускает нашу программу, не указав достаточно аргументов, он получит ошибку index out of bounds от Rust, которая не объясняет проблему чётко. Было бы лучше, если бы весь код обработки ошибок находился в одном месте, чтобы будущим сопровождающим нужно было проконсультироваться только в одном месте, если логику обработки ошибок потребуется изменить. Наличие всего кода обработки ошибок в одном месте также гарантирует, что мы печатаем сообщения, которые будут значимы для наших конечных пользователей.
Давайте решим эти четыре проблемы, проведя рефакторинг нашего проекта.
Разделение обязанностей в бинарных проектах
Организационная проблема распределения ответственности за несколько задач между функцией main характерна для многих бинарных проектов. В результате многие программисты на Rust находят полезным разделить отдельные задачи бинарной программы, когда функция main начинает разрастаться. Этот процесс состоит из следующих шагов:
- Разделите программу на файл main.rs и файл lib.rs и переместите логику программы в lib.rs.
- Пока логика разбора командной строки невелика, она может оставаться в функции
main. - Когда логика разбора командной строки начинает усложняться, извлеките её из функции
mainв другие функции или типы.
Обязанности, которые остаются в функции main после этого процесса, должны быть ограничены следующим:
- Вызов логики разбора командной строки со значениями аргументов
- Настройка любой другой конфигурации
- Вызов функции
runв lib.rs - Обработка ошибки, если
runвозвращает ошибку
Этот шаблон заключается в разделении обязанностей: main.rs отвечает за запуск программы, а lib.rs отвечает за всю логику текущей задачи. Поскольку вы не можете тестировать функцию main напрямую, эта структура позволяет вам тестировать всю логику вашей программы, переместив её из функции main. Код, который остаётся в функции main, будет достаточно мал, чтобы проверить его корректность путём чтения. Давайте переработаем нашу программу, следуя этому процессу.
Извлечение парсера аргументов
Мы извлечём функциональность разбора аргументов в функцию, которую вызовет main. Листинг 12-5 показывает новое начало функции main, которая вызывает новую функцию parse_config, которую мы определим в src/main.rs.
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let (query, file_path) = parse_config(&args);
// --snip--
println!("Searching for {query}");
println!("In file {file_path}");
let contents = fs::read_to_string(file_path)
.expect("Should have been able to read the file");
println!("With text:\n{contents}");
}
fn parse_config(args: &[String]) -> (&str, &str) {
let query = &args[1];
let file_path = &args[2];
(query, file_path)
}
parse_config из mainМы по-прежнему собираем аргументы командной строки в вектор, но вместо того, чтобы присваивать значение аргумента по индексу 1 переменной query, а значение аргумента по индексу 2 переменной file_path внутри функции main, мы передаём весь вектор функции parse_config. Функция parse_config затем содержит логику, которая определяет, какой аргумент в какую переменную попадает, и передаёт значения обратно в main. Мы по-прежнему создаём переменные query и file_path в main, но main больше не несёт ответственности за определение того, как аргументы командной строки и переменные соответствуют друг другу.
Эта переработка может показаться излишней для нашей небольшой программы, но мы проводим рефакторинг небольшими, постепенными шагами. После внесения этого изменения запустите программу снова, чтобы убедиться, что разбор аргументов по-прежнему работает. Хорошо часто проверять прогресс, чтобы помочь выявить причину проблем, когда они возникают.
Группировка конфигурационных значений
Мы можем сделать ещё один небольшой шаг для дальнейшего улучшения функции parse_config. На данный момент мы возвращаем кортеж, но затем сразу же снова разбиваем этот кортеж на отдельные части. Это признак того, что, возможно, у нас ещё нет правильной абстракции.
Ещё один индикатор, показывающий, что есть место для улучшения, — это часть config в parse_config, которая подразумевает, что два возвращаемых значения связаны и оба являются частью одного конфигурационного значения. Мы в настоящее время не передаём это значение в структуре данных иначе, как только группируя два значения в кортеж; вместо этого мы поместим два значения в одну структуру и дадим каждому из полей структуры осмысленное имя. Это облегчит будущим сопровождающим этого кода понимание того, как различные значения связаны друг с другом и каково их назначение.
Листинг 12-6 показывает улучшения функции parse_config.
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let config = parse_config(&args);
println!("Searching for {}", config.query);
println!("In file {}", config.file_path);
let contents = fs::read_to_string(config.file_path)
.expect("Should have been able to read the file");
// --snip--
println!("With text:\n{contents}");
}
struct Config {
query: String,
file_path: String,
}
fn parse_config(args: &[String]) -> Config {
let query = args[1].clone();
let file_path = args[2].clone();
Config { query, file_path }
}
parse_config для возврата экземпляра структуры ConfigМы добавили структуру с именем Config, определённую с полями query и file_path. Сигнатура parse_config теперь указывает, что она возвращает значение Config. В теле parse_config, где мы раньше возвращали срезы строк, ссылающиеся на значения String в args, мы теперь определяем Config, чтобы он содержал владеющие значения String. Переменная args в main является владельцем значений аргументов и только позволяет функции parse_config заимствовать их, что означает, что мы нарушили бы правила заимствования Rust, если бы Config попытался взять на себя владение значениями в args.
Есть несколько способов, которыми мы могли бы управлять данными String; самый простой, хотя и несколько неэффективный, путь — вызвать метод clone для значений. Это сделает полную копию данных, которой будет владеть экземпляр Config, что занимает больше времени и памяти, чем хранение ссылки на строковые данные. Однако клонирование данных также делает наш код очень простым, потому что нам не нужно управлять временами жизни ссылок; в этих обстоятельствах отказ от небольшой производительности ради простоты — это стоящий компромисс.
Компромиссы использования clone
Среди многих Rustaceans существует тенденция избегать использования clone для решения проблем владения из-за его стоимости во время выполнения. В главе 13 вы узнаете, как использовать более эффективные методы в такой ситуации. Но пока нормально копировать несколько строк, чтобы продолжать двигаться вперёд, потому что вы сделаете эти копии только один раз, и ваш путь к файлу и строка запроса очень малы. Лучше иметь работающую программу, которая немного неэффективна, чем пытаться гипероптимизировать код с первого прохода. По мере того как вы будете приобретать больше опыта с Rust, будет легче начинать с наиболее эффективного решения, но пока вполне приемлемо вызывать clone.
Мы обновили main так, чтобы она помещала экземпляр Config, возвращаемый parse_config, в переменную с именем config, и мы обновили код, который ранее использовал отдельные переменные query и file_path, так что теперь он использует поля структуры Config.
Теперь наш код более ясно передаёт, что query и file_path связаны и что их назначение — настроить, как будет работать программа. Любой код, использующий эти значения, знает, что их нужно искать в экземпляре config в полях, названных в соответствии с их назначением.
Создание конструктора для Config
До сих пор мы извлекли логику, отвечающую за разбор аргументов командной строки, из main и поместили её в функцию parse_config. Это помогло нам увидеть, что значения query и file_path связаны, и эта связь должна быть передана в нашем коде. Затем мы добавили структуру Config, чтобы назвать связанное назначение query и file_path и иметь возможность возвращать имена значений в качестве имён полей структуры из функции parse_config.
Итак, теперь, когда назначение функции parse_config — создать экземпляр Config, мы можем изменить parse_config с обычной функции на функцию с именем new, связанную со структурой Config. Внесение этого изменения сделает код более идиоматичным. Мы можем создавать экземпляры типов в стандартной библиотеке, таких как String, вызывая String::new. Аналогично, изменив parse_config на функцию new, связанную с Config, мы сможем создавать экземпляры Config, вызывая Config::new. Листинг 12-7 показывает изменения, которые нам нужно внести.
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args);
println!("Searching for {}", config.query);
println!("In file {}", config.file_path);
let contents = fs::read_to_string(config.file_path)
.expect("Should have been able to read the file");
println!("With text:\n{contents}");
// --snip--
}
// --snip--
struct Config {
query: String,
file_path: String,
}
impl Config {
fn new(args: &[String]) -> Config {
let query = args[1].clone();
let file_path = args[2].clone();
Config { query, file_path }
}
}
parse_config на Config::newМы обновили main там, где вызывали parse_config, чтобы вместо этого вызывать Config::new. Мы изменили имя parse_config на new и переместили его внутрь блока impl, который связывает функцию new с Config. Попробуйте снова скомпилировать этот код, чтобы убедиться, что он работает.
Исправление обработки ошибок
Теперь мы займёмся исправлением нашей обработки ошибок. Вспомните, что попытка получить доступ к значениям в векторе args по индексу 1 или индексу 2 вызовет панику программы, если вектор содержит меньше трёх элементов. Попробуйте запустить программу без аргументов; это будет выглядеть так:
$ cargo run
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep`
thread 'main' (6023615) panicked at src/main.rs:27:21:
index out of bounds: the len is 1 but the index is 1
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Строка index out of bounds: the len is 1 but the index is 1 — это сообщение об ошибке, предназначенное для программистов. Оно не поможет нашим конечным пользователям понять, что им следует делать вместо этого. Давайте исправим это сейчас.
Улучшение сообщения об ошибке
В листинге 12-8 мы добавляем проверку в функцию new, которая проверит, достаточно ли длинный срез перед доступом к индексу 1 и индексу 2. Если срез недостаточно длинный, программа паникует и отображает лучшее сообщение об ошибке.
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args);
println!("Searching for {}", config.query);
println!("In file {}", config.file_path);
let contents = fs::read_to_string(config.file_path)
.expect("Should have been able to read the file");
println!("With text:\n{contents}");
}
struct Config {
query: String,
file_path: String,
}
impl Config {
// --snip--
fn new(args: &[String]) -> Config {
if args.len() < 3 {
panic!("not enough arguments");
}
// --snip--
let query = args[1].clone();
let file_path = args[2].clone();
Config { query, file_path }
}
}
Этот код похож на функцию Guess::new, которую мы написали в листинге 9-13, где мы вызывали panic!, когда аргумент value был вне диапазона допустимых значений. Вместо проверки диапазона значений здесь мы проверяем, что длина args не меньше 3, и остальная часть функции может работать в предположении, что это условие выполнено. Если в args меньше трёх элементов, это условие будет true, и мы вызываем макрос panic!, чтобы немедленно завершить программу.
С этими дополнительными несколькими строками кода в new давайте снова запустим программу без аргументов, чтобы увидеть, как теперь выглядит ошибка:
$ cargo run
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep`
thread 'main' (6023776) panicked at src/main.rs:26:13:
not enough arguments
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Этот вывод лучше: теперь у нас есть разумное сообщение об ошибке. Однако у нас также есть посторонняя информация, которую мы не хотим давать нашим пользователям. Возможно, техника, которую мы использовали в листинге 9-13, не лучшая для использования здесь: вызов panic! больше подходит для проблемы программирования, чем для проблемы использования, как обсуждалось в главе 9. Вместо этого мы будем использовать другую технику, которую вы узнали в главе 9, — возврат Result, который указывает либо на успех, либо на ошибку.
Возврат Result вместо вызова panic!
Вместо этого мы можем вернуть значение Result, которое будет содержать экземпляр Config в случае успеха и описывать проблему в случае ошибки. Мы также собираемся изменить имя функции с new на build, потому что многие программисты ожидают, что функции new никогда не будут завершаться неудачей. Когда Config::build сообщает main, мы можем использовать тип Result, чтобы сигнализировать о проблеме. Затем мы можем изменить main, чтобы преобразовать вариант Err в более практичную ошибку для наших пользователей без окружающего текста про thread 'main' и RUST_BACKTRACE, который вызывает вызов panic!.
Листинг 12-9 показывает изменения, которые нам нужно внести в возвращаемое значение функции, которую мы теперь называем Config::build, и в тело функции, необходимое для возврата Result. Обратите внимание, что этот код не скомпилируется, пока мы также не обновим main, что мы сделаем в следующем листинге.
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args);
println!("Searching for {}", config.query);
println!("In file {}", config.file_path);
let contents = fs::read_to_string(config.file_path)
.expect("Should have been able to read the file");
println!("With text:\n{contents}");
}
struct Config {
query: String,
file_path: String,
}
impl Config {
fn build(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let file_path = args[2].clone();
Ok(Config { query, file_path })
}
}
Result из Config::buildНаша функция build возвращает Result с экземпляром Config в случае успеха и строковым литералом в случае ошибки. Наши значения ошибок всегда будут строковыми литералами, имеющими время жизни 'static.
Мы сделали два изменения в теле функции: вместо вызова panic!, когда пользователь не передаёт достаточно аргументов, мы теперь возвращаем значение Err, и мы обернули возвращаемое значение Config в Ok. Эти изменения заставляют функцию соответствовать её новой сигнатуре типа.
Возврат значения Err из Config::build позволяет функции main обработать значение Result, возвращаемое функцией build, и более чисто завершить процесс в случае ошибки.
Вызов Config::build и обработка ошибок
Чтобы обработать случай ошибки и напечатать удобное для пользователя сообщение, нам нужно обновить main, чтобы обработать Result, возвращаемый Config::build, как показано в листинге 12-10. Мы также возьмём на себя ответственность за выход из инструмента командной строки с ненулевым кодом ошибки у panic! и вместо этого реализуем это вручную. Ненулевой статус выхода — это соглашение, чтобы сигнализировать процессу, который вызвал нашу программу, что программа завершилась с состоянием ошибки.
use std::env;
use std::fs;
use std::process;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::build(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {err}");
process::exit(1);
});
// --snip--
println!("Searching for {}", config.query);
println!("In file {}", config.file_path);
let contents = fs::read_to_string(config.file_path)
.expect("Should have been able to read the file");
println!("With text:\n{contents}");
}
struct Config {
query: String,
file_path: String,
}
impl Config {
fn build(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let file_path = args[2].clone();
Ok(Config { query, file_path })
}
}
Config не удаласьВ этом листинге мы использовали метод, который ещё не рассматривали подробно: unwrap_or_else, который определён для Result<T, E> стандартной библиотекой. Использование unwrap_or_else позволяет нам определить некоторую пользовательскую, не-panic! обработку ошибок. Если Result является значением Ok, поведение этого метода похоже на unwrap: он возвращает внутреннее значение, которое оборачивает Ok. Однако если значение является значением Err, этот метод вызывает код в замыкании, которое является анонимной функцией, которую мы определяем и передаём в качестве аргумента в unwrap_or_else. Мы рассмотрим замыкания более подробно в главе 13. Пока вам просто нужно знать, что unwrap_or_else передаст внутреннее значение Err, которое в данном случае является статической строкой "not enough arguments", которую мы добавили в листинге 12-9, нашему замыканию в аргументе err, который появляется между вертикальными чертами. Код в замыкании затем может использовать значение err, когда оно выполняется.
Мы добавили новую строку use, чтобы привнести process из стандартной библиотеки в область видимости. Код в замыкании, который будет выполняться в случае ошибки, состоит всего из двух строк: мы печатаем значение err и затем вызываем process::exit. Функция process::exit немедленно остановит программу и вернёт число, которое было передано в качестве кода статуса выхода. Это похоже на обработку на основе panic!, которую мы использовали в листинге 12-8, но мы больше не получаем весь дополнительный вывод. Давайте попробуем:
$ cargo run
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/minigrep`
Problem parsing arguments: not enough arguments
Отлично! Этот вывод гораздо дружелюбнее для наших пользователей.
Извлечение логики из main
Теперь, когда мы закончили рефакторинг разбора конфигурации, давайте перейдём к логике программы. Как мы заявили в разделе «Разделение обязанностей в бинарных проектах», мы извлечём функцию с именем run, которая будет содержать всю логику, находящуюся в настоящее время в функции main и не связанную с настройкой конфигурации или обработкой ошибок. Когда мы закончим, функция main будет краткой и легкой для проверки путём осмотра, и мы сможем написать тесты для всей остальной логики.
Листинг 12-11 показывает небольшое постепенное улучшение, извлекающее функцию run.
use std::env;
use std::fs;
use std::process;
fn main() {
// --snip--
let args: Vec<String> = env::args().collect();
let config = Config::build(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {err}");
process::exit(1);
});
println!("Searching for {}", config.query);
println!("In file {}", config.file_path);
run(config);
}
fn run(config: Config) {
let contents = fs::read_to_string(config.file_path)
.expect("Should have been able to read the file");
println!("With text:\n{contents}");
}
// --snip--
struct Config {
query: String,
file_path: String,
}
impl Config {
fn build(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let file_path = args[2].clone();
Ok(Config { query, file_path })
}
}
run, содержащей остальную логику программыФункция run теперь содержит всю оставшуюся логику из main, начиная с чтения файла. Функция run принимает экземпляр Config в качестве аргумента.
Возврат ошибок из run
С отделённой в функцию run оставшейся логикой программы мы можем улучшить обработку ошибок, как мы делали с Config::build в листинге 12-9. Вместо того чтобы позволять программе паниковать, вызывая expect, функция run будет возвращать Result<T, E>, когда что-то пойдёт не так. Это позволит нам ещё больше консолидировать логику обработки ошибок в main удобным для пользователя способом. Листинг 12-12 показывает изменения, которые нам нужно внести в сигнатуру и тело run.
use std::env;
use std::fs;
use std::process;
use std::error::Error;
// --snip--
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::build(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {err}");
process::exit(1);
});
println!("Searching for {}", config.query);
println!("In file {}", config.file_path);
run(config);
}
fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.file_path)?;
println!("With text:\n{contents}");
Ok(())
}
struct Config {
query: String,
file_path: String,
}
impl Config {
fn build(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let file_path = args[2].clone();
Ok(Config { query, file_path })
}
}
run для возврата ResultМы сделали три значительных изменения здесь. Во-первых, мы изменили тип возвращаемого значения функции run на Result<(), Box<dyn Error>>. Эта функция ранее возвращала unit-тип (), и мы сохраняем его в качестве значения, возвращаемого в случае Ok.
Для типа ошибки мы использовали трейт-объект Box<dyn Error> (и мы привнесли std::error::Error в область видимости с помощью инструкции use вверху). Мы рассмотрим трейт-объекты в главе 18. Пока просто знайте, что Box<dyn Error> означает, что функция вернёт тип, реализующий трейт Error, но нам не нужно указывать, какой конкретный тип будет иметь возвращаемое значение. Это даёт нам гибкость возвращать значения ошибок, которые могут быть разных типов в разных случаях ошибок. Ключевое слово dyn — это сокращение от dynamic (динамический).
Во-вторых, мы удалили вызов expect в пользу оператора ?, как мы говорили в главе 9. Вместо panic! при ошибке ? вернёт значение ошибки из текущей функции для обработки вызывающей стороной.
В-третьих, функция run теперь возвращает значение Ok в случае успеха. Мы объявили успешный тип функции run как () в сигнатуре, что означает, что нам нужно обернуть значение unit-типа в значение Ok. Этот синтаксис Ok(()) может показаться немного странным поначалу. Но использование () таким образом — это идиоматический способ указать, что мы вызываем run только ради его побочных эффектов; она не возвращает значение, которое нам нужно.
Когда вы запустите этот код, он скомпилируется, но отобразит предупреждение:
$ cargo run -- the poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
warning: unused `Result` that must be used
--> src/main.rs:19:5
|
19 | run(config);
| ^^^^^^^^^^^
|
= note: this `Result` may be an `Err` variant, which should be handled
= note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default
help: use `let _ = ...` to ignore the resulting value
|
19 | let _ = run(config);
| +++++++
warning: `minigrep` (bin "minigrep") generated 1 warning
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.71s
Running `target/debug/minigrep the poem.txt`
Searching for the
In file poem.txt
With text:
I'm nobody! Who are you?
Are you nobody, too?
Then there's a pair of us - don't tell!
They'd banish us, you know.
How dreary to be somebody!
How public, like a frog
To tell your name the livelong day
To an admiring bog!
Rust сообщает нам, что наш код проигнорировал значение Result, и значение Result может указывать на то, что произошла ошибка. Но мы не проверяем, была ли ошибка, и компилятор напоминает нам, что мы, вероятно, имели в виду какой-то код обработки ошибок здесь! Давайте исправим эту проблему сейчас.
Обработка ошибок, возвращаемых из run, в main
Мы будем проверять наличие ошибок и обрабатывать их, используя технику, подобную той, которую мы использовали с Config::build в листинге 12-10, но с небольшим отличием:
Имя файла: src/main.rs
use std::env;
use std::error::Error;
use std::fs;
use std::process;
fn main() {
// --snip--
let args: Vec<String> = env::args().collect();
let config = Config::build(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {err}");
process::exit(1);
});
println!("Searching for {}", config.query);
println!("In file {}", config.file_path);
if let Err(e) = run(config) {
println!("Application error: {e}");
process::exit(1);
}
}
fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.file_path)?;
println!("With text:\n{contents}");
Ok(())
}
struct Config {
query: String,
file_path: String,
}
impl Config {
fn build(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let file_path = args[2].clone();
Ok(Config { query, file_path })
}
}
Мы используем if let, а не unwrap_or_else, чтобы проверить, возвращает ли run значение Err, и вызвать process::exit(1), если оно возвращает. Функция run не возвращает значение, которое мы хотим unwrap так же, как Config::build возвращает экземпляр Config. Поскольку run возвращает () в случае успеха, нас интересует только обнаружение ошибки, поэтому нам не нужен unwrap_or_else для возврата развёрнутого значения, которым было бы только ().
Тела if let и функций unwrap_or_else одинаковы в обоих случаях: мы печатаем ошибку и выходим.
Разделение кода на библиотечный крейт
Наш проект minigrep пока выглядит хорошо! Теперь мы разделим файл src/main.rs и поместим часть кода в файл src/lib.rs. Таким образом, мы сможем тестировать код и иметь файл src/main.rs с меньшим количеством обязанностей.
Давайте определим код, отвечающий за поиск текста, в src/lib.rs, а не в src/main.rs, что позволит нам (или любому другому пользователю нашей библиотеки minigrep) вызывать функцию поиска из большего числа контекстов, чем наш бинарный файл minigrep.
Сначала давайте определим сигнатуру функции search в src/lib.rs, как показано в листинге 12-13, с телом, которое вызывает макрос unimplemented!. Мы объясним сигнатуру более подробно, когда заполним реализацию.
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
unimplemented!();
}
search в src/lib.rsМы использовали ключевое слово pub в определении функции, чтобы обозначить search как часть публичного API нашего библиотечного крейта. Теперь у нас есть библиотечный крейт, который мы можем использовать из нашего бинарного крейта и который мы можем тестировать!
Теперь нам нужно привнести код, определённый в src/lib.rs, в область видимости бинарного крейта в src/main.rs и вызвать его, как показано в листинге 12-14.
use std::env;
use std::error::Error;
use std::fs;
use std::process;
// --snip--
use minigrep::search;
fn main() {
// --snip--
let args: Vec<String> = env::args().collect();
let config = Config::build(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {err}");
process::exit(1);
});
if let Err(e) = run(config) {
println!("Application error: {e}");
process::exit(1);
}
}
// --snip--
struct Config {
query: String,
file_path: String,
}
impl Config {
fn build(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let file_path = args[2].clone();
Ok(Config { query, file_path })
}
}
fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.file_path)?;
for line in search(&config.query, &contents) {
println!("{line}");
}
Ok(())
}
search библиотечного крейта minigrep в src/main.rsМы добавляем строку use minigrep::search, чтобы привнести функцию search из библиотечного крейта в область видимости бинарного крейта. Затем в функции run вместо печати содержимого файла мы вызываем функцию search и передаём ей значение config.query и contents в качестве аргументов. Затем run будет использовать цикл for для печати каждой строки, возвращённой из search, которая совпала с запросом. Это также хорошее время, чтобы удалить вызовы println! в функции main, которые отображали запрос и путь к файлу, чтобы наша программа печатала только результаты поиска (если не возникает ошибок).
Обратите внимание, что функция search будет собирать все результаты в вектор, который она возвращает, прежде чем произойдёт какая-либо печать. Эта реализация может быть медленной при выводе результатов поиска в больших файлах, потому что результаты не печатаются по мере их обнаружения; мы обсудим возможный способ исправить это с помощью итераторов в главе 13.
Ух! Это была большая работа, но мы подготовили себя к успеху в будущем. Теперь гораздо легче обрабатывать ошибки, и мы сделали код более модульным. Почти вся наша работа будет выполняться в src/lib.rs с этого момента.
Давайте воспользуемся этой вновь обретённой модульностью, сделав то, что было бы трудно со старым кодом, но легко с новым кодом: мы напишем несколько тестов!