Файл: Язык программирования Rust.pdf

Скачать файл (7,02Мб)

Заказать решение

ВУЗ: Не указан

Категория: Не указан

Дисциплина: Не указана

Добавлен: 11.01.2024

Просмотров: 1173

Скачиваний: 5

ВНИМАНИЕ! Если данный файл нарушает Ваши авторские права, то обязательно сообщите нам.

СОДЕРЖАНИЕ

Недействительные ссылкиВ языках с указателями легко ошибочно создать висячий указатель — указатель,ссылающийся на место в памяти, которое могло быть передано кому-то другому после освобождения этой части памяти, сохраняя при этом указатель на неё. В Rust, напротив,компилятор гарантирует, что ссылки никогда не будут висячими: если у вас есть ссылка на какие-то данные, компилятор убедится, что данные не выйдут за пределы области видимости до того, как это сделает ссылка на них.Давайте попробуем создать висячую ссылку, чтобы увидеть, как Rust предотвращает их появление с помощью ошибки во время компиляции:Файл: src/main.rsЗдесь ошибка:Это сообщение об ошибке относится к особенности языка, которую мы ещё не рассмотрели: времени жизни. Мы подробно обсудим времена жизни в главе 10. Но если вы не обращаете внимания на части, касающиеся времени жизни, сообщение будет содержать ключ к тому, почему этот код является проблемой:fn main() { let reference_to_nothing = dangle(); } fn dangle() -> &String { let s = String::from("hello"); &s } $ cargo run Compiling ownership v0.1.0 (file:///projects/ownership) error[E0106]: missing lifetime specifier --> src/main.rs:5:16 | 5 | fn dangle() -> &String { | ^ expected named lifetime parameter | = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from help: consider using the `'static` lifetime | 5 | fn dangle() -> &'static String { |

Определение и инициализация структурСтруктуры похожи на кортежи, рассмотренные в разделе "Кортежи", так как оба хранят несколько связанных значений. Как и кортежи, части структур могут быть разных типов.В отличие от кортежей, в структуре необходимо именовать каждую часть данных для понимания смысла значений. Добавление этих имён обеспечивает большую гибкость структур по сравнению с кортежами: не нужно полагаться на порядок данных для указания значений экземпляра или доступа к ним.Для определения структуры указывается ключевое слово struct и её название.Название должно описывать значение частей данных, сгруппированных вместе. Далее, в фигурных скобках для каждой новой части данных поочерёдно определяются имя части данных и её тип. Каждая пара имя: тип называется полем. Листинг 5-1 описывает структуру для хранения информации об учётной записи пользователя:Листинг 5-1: Определение структуры UserПосле определения структуры можно создавать её экземпляр, назначая определённое значение каждому полю с соответствующим типом данных. Чтобы создать экземпляр, мы указываем имя структуры, затем добавляем фигурные скобки и включаем в них пары ключ: значение (key: value), где ключами являются имена полей, а значениями являются данные, которые мы хотим сохранить в полях. Нет необходимости чётко следовать порядку объявления полей в описании структуры (но всё-таки желательно для удобства чтения). Другими словами, объявление структуры - это как шаблон нашего типа, в то время как экземпляр структуры использует этот шаблон, заполняя его определёнными данными, для создания значений нашего типа. Например, можно объявить пользователя как в листинге 5-2:Листинг 5-2: Создание экземпляра структуры UserЧтобы получить конкретное значение из структуры, мы используем запись через точку.Например, чтобы получить доступ к адресу электронной почты этого пользователя, мы structUser { active: bool, username: String, email: String, sign_in_count: u64, } fn main() { let user1 = User { email: String::from("someone@example.com"), username: String::from("someusername123"), active: true, sign_in_count: 1, }; } используем user1.email. Если экземпляр является изменяемым, мы можем поменять значение, используя точечную нотацию и присвоение к конкретному полю. В Листинге5-3 показано, как изменить значение в поле email изменяемого экземпляра UserЛистинг 5-3: Изменение значения в поле email экземпляра UserЗаметим, что весь экземпляр структуры должен быть изменяемым; Rust не позволяет помечать изменяемыми отдельные поля. Как и для любого другого выражения, мы можем использовать выражение создания структуры в качестве последнего выражения тела функции для неявного возврата нового экземпляра.На листинге 5-4 функция build_user возвращает экземпляр User с указанным адресом и именем. Поле active получает значение true, а поле sign_in_count получает значение1Листинг 5-4: Функция build_user, которая принимает email и имя пользователя и возвращает экземпляр UserИмеет смысл называть параметры функции теми же именами, что и поля структуры, но необходимость повторять email и username для названий полей и переменных несколько утомительна. Если структура имеет много полей, повторение каждого имени станет ещё более раздражающим. К счастью, есть удобное сокращение!Использование сокращённой инициализации поляТак как имена входных параметров функции и полей структуры являются полностью идентичными в листинге 5-4, возможно использовать синтаксис сокращённойfn main() { let mut user1 = User { email: String::from("someone@example.com"), username: String::from("someusername123"), active: true, sign_in_count: 1, }; user1.email = String::from("anotheremail@example.com"); } fn build_user(email: String, username: String) -> User { User { email: email, username: username, active: true, sign_in_count: 1, } } инициализации поля, чтобы переписать build_user так, чтобы он работал точно также,но не содержал повторений для email и username, как в листинге 5-5.Листинг 5-5: Функция build_user, использующая сокращённую инициализацию поля, когда параметры email и username имеют те же имена, что и поля structЗдесь происходит создание нового экземпляра структуры User, которая имеет поле с именем email. Мы хотим установить поле структуры email значением входного параметра email функции build_user. Так как поле email и входной параметр функции email имеют одинаковое название, можно писать просто email вместо кода email: emailСоздание экземпляра структуры из экземпляра другой структуры спомощью синтаксиса обновления структурыЧасто бывает полезно создать новый экземпляр структуры, который включает большинство значений из другого экземпляра, но некоторые из них изменяет. Это можно сделать с помощью синтаксиса обновления структуры.Сначала в листинге 5-6 показано, как обычно создаётся новый экземпляр User в user2без синтаксиса обновления. Мы задаём новое значение для email, но в остальном используем те же значения из user1, которые были заданы в листинге 5-2.Листинг 5-6: Создание нового экземпляра User с использованием некоторых значений из экземпляра user1Используя синтаксис обновления структуры, можно получить тот же эффект, используя меньше кода как показано в листинге 5-7. Синтаксис указывает, что оставшиеся поля fn build_user(email: String, username: String) -> User { User { email, username, active: true, sign_in_count: 1, } } fn main() { // --snip-- let user2 = User { active: user1.active, username: user1.username, email: String::from("another@example.com"), sign_in_count: user1.sign_in_count, }; } устанавливаются неявно и должны иметь значения из указанного экземпляра.Листинг 5-7: Использование синтаксиса обновления структуры для установки нового значения email дляэкземпляра User, но использование остальных значений из экземпляра user1Код в листинге 5-7 также создаёт экземпляр в user2, который имеет другое значение для email, но с тем же значением для полей username, active и sign_in_count из user1Оператор ..user1 должен стоять последним для указания на получение значений всех оставшихся полей из соответствующих полей в user1, но можно указать значения для любого количества полей в любом порядке, независимо от порядка полей в определении структуры.Заметим, что синтаксис обновления структуры использует = как присваивание. Это связано с перемещением данных, как мы видели в разделе "Способы взаимодействия переменных и данных: перемещение". В этом примере мы больше не можем использовать user1 после создания user2, потому что String в поле username из user1 было перемещено в user2. Если бы мы задали user2 новые значения String для email и username, и при этом использовать только значения active и sign_in_count из user1, то user1 все ещё будет действительным после создания user2. Типы active и sign_in_count являются типами, реализующими типаж Copy, поэтому будет применяться поведение, о котором мы говорили в разделе "Стековые данные:Копирование"Кортежные структуры: структуры без именованных полей длясоздания разных типовRust также поддерживает структуры, похожие на кортежи, которые называютсякортежные структуры. Кортежные структуры обладают дополнительным смыслом,который даёт имя структуры, но при этом не имеют имён, связанных с их полями. Скорее,они просто хранят типы полей. Кортежные структуры полезны, когда вы хотите дать имя всему кортежу и сделать кортеж отличным от других кортежей, и когда именование каждого поля, как в обычной структуре, было бы многословным или избыточным.Чтобы определить кортежную структуру, начните с ключевого слова struct и имени структуры, за которым следуют типы в кортеже. Например, здесь мы определяем и используем две кортежные структуры с именами Color и Point:fn main() { // --snip-- let user2 = User { email: String::from("another@example.com"), ..user1 }; } Обратите внимание, что значения black и origin — это разные типы, потому что они являются экземплярами разных кортежных структур. Каждая определяемая вами структура имеет собственный тип, даже если поля внутри структуры могут иметь одинаковые типы. Например, функция, принимающая параметр типа Color, не может принимать Point в качестве аргумента, даже если оба типа состоят из трёх значений i32. В остальном экземпляры кортежных структур похожи на кортежи в том смысле, что вы можете деструктурировать их на отдельные части и использовать , за которой следует индекс для доступа к отдельному значению.Единично-подобные структуры: структуры без полейТакже можно определять структуры, не имеющие полей! Они называются единично-подобными структурами, поскольку ведут себя аналогично (), единичному типу, о котором мы говорили в разделе "Кортежи". Единично-подобные структуры могут быть полезны, когда требуется реализовать типаж для некоторого типа, но у вас нет данных,которые нужно хранить в самом типе. Мы обсудим типажи в главе 10. Вот пример объявления и создание экземпляра единичной структуры с именем AlwaysEqual:Чтобы определить AlwaysEqual, мы используем ключевое слово struct, желаемое имя,а затем точку с запятой. Нет необходимости в фигурных или круглых скобках! Затем мы можем получить экземпляр AlwaysEqual в переменной subject аналогичным образом:используя имя, которое мы определили, без фигурных и круглых скобок. Представим, что в дальнейшем мы реализуем поведение для этого типа таким образом, что каждый экземпляр AlwaysEqual всегда будет равен каждому экземпляру любого другого типа,возможно, с целью получения ожидаемого результата для тестирования. Для реализации такого поведения нам не нужны никакие данные! В главе 10 вы увидите, как определять черты и реализовывать их для любого типа, включая единично-подобные структуры.Владение данными структурыstructColor(i32, i32, i32); structPoint(i32, i32, i32); fn main() { let black = Color(0, 0, 0); let origin = Point(0, 0, 0); } structAlwaysEqual; fn main() { let subject = AlwaysEqual; } В определении структуры User в листинге 5-1 мы использовали владеющий тип String вместо типа строковой срез &str. Это осознанный выбор, поскольку мы хотим, чтобы каждый экземпляр этой структуры владел всеми своими данными и чтобы эти данные были действительны до тех пор, пока действительна вся структура.Структуры также могут хранить ссылки на данные, принадлежащие кому-то другому,но для этого необходимо использовать возможность Rust время жизни, которую мы обсудим в главе 10. Время жизни гарантирует, что данные, на которые ссылается структура, будут действительны до тех пор, пока существует структура. Допустим,если попытаться сохранить ссылку в структуре без указания времени жизни, как в следующем примере; это не сработает:Имя файла: src/main.rsКомпилятор будет жаловаться на необходимость определения времени жизни ссылок:structUser { active: bool, username: &str, email: &str, sign_in_count: u64, } fn main() { let user1 = User { email: "someone@example.com", username: "someusername123", active: true, sign_in_count: 1, }; } В главе 10 мы обсудим, как исправить эти ошибки, чтобы иметь возможность хранить ссылки в структурах, а пока мы исправим подобные ошибки, используя владеющие типы вроде String вместо ссылок &str$ cargo run Compiling structs v0.1.0 (file:///projects/structs) error[E0106]: missing lifetime specifier --> src/main.rs:3:15 | 3 | username: &str, | ^ expected named lifetime parameter | help: consider introducing a named lifetime parameter | 1 struct User<'a> { 2 | active: bool, 3 username: &'a str, | error[E0106]: missing lifetime specifier --> src/main.rs:4:12 | 4 | email: &str, | ^ expected named lifetime parameter | help: consider introducing a named lifetime parameter | 1 struct User<'a> { 2 | active: bool, 3 | username: &str, 4 email: &'a str, | For more information about this error, try `rustc --explain E0106`. error: could not compile `structs` due to 2 previous errors Пример использования структурЧтобы понять, когда нам может понадобиться использование структур, давайте напишем программу, которая вычисляет площадь прямоугольника. Мы начнём с использования одиночных переменных, а затем будем улучшать программу до использования структур.Давайте создадим новый проект программы при помощи Cargo и назовём его rectangles.Наша программа будет получать на вход длину и ширину прямоугольника в пикселях и затем рассчитывать площадь прямоугольника. Листинг 5-8 показывает один из коротких вариантов кода, который позволит нам сделать именно то, что надо, в файле проектаsrc/main.rs.Файл: src/main.rsЛистинг 5-8: вычисление площади прямоугольника, заданного отдельными переменными ширины ивысотыТеперь запустим программу, используя cargo run:Этот код успешно вычисляет площадь прямоугольника, вызывая функцию area скаждым измерением, но мы можем улучшить его ясность и читабельность.Проблема данного метода очевидна из сигнатуры area:Функция area должна вычислять площадь одного прямоугольника, но функция, которую мы написали, имеет два параметра, и нигде в нашей программе не ясно, что эти параметры взаимосвязаны. Было бы более читабельным и управляемым сгруппировать fn main() { let width1 = 30; let height1 = 50; println!( "The area of the rectangle is {} square pixels.", area(width1, height1) ); } fn area(width: u32, height: u32) -> u32 { width * height } $ cargo run Compiling rectangles v0.1.0 (file:///projects/rectangles) Finished dev [unoptimized + debuginfo] target(s) in 0.42s Running `target/debug/rectangles` The area of the rectangle is 1500 square pixels. fn area(width: u32, height: u32) -> u32 { ширину и высоту вместе. В разделе «Кортежи» главы 3 мы уже обсуждали один из способов сделать это — использовать кортежи.Рефакторинг при помощи кортежейЛистинг 5-9 — это другая версия программы, использующая кортежи.Файл: src/main.rsЛистинг 5-9: определение ширины и высоты прямоугольника с помощью кортежаС одной стороны, эта программа лучше. Кортежи позволяют добавить немного структуры, и теперь мы передаём только один аргумент. Но с другой стороны, эта версия менее понятна: кортежи не называют свои элементы, поэтому нам приходится индексировать части кортежа, что делает наше вычисление менее очевидным.Если мы перепутаем местами ширину с высотой при расчёте площади, то это не имеет значения. Но если мы хотим нарисовать прямоугольник на экране, то это уже будет важно! Мы должны помнить, что ширина width находится в кортеже с индексом 0, а высота height — с индексом 1. Если кто-то другой поработал бы с кодом, ему бы пришлось разобраться в этом и также помнить про порядок. Легко забыть и перепутать эти значения — и это вызовет ошибки, потому что данный код не передаёт наши намерения.Рефакторинг при помощи структур: добавим больше смыслаМы используем структуры, чтобы добавить смысл данным при помощи назначения им осмысленных имён . Мы можем переделать используемый кортеж в структуру с единым именем для сущности и частными названиями её частей, как показано в листинге 5-10.Файл: src/main.rs fn main() { let rect1 = (30, 50); println!( "The area of the rectangle is {} square pixels.", area(rect1) ); } fn area(dimensions: (u32, u32)) -> u32 { dimensions.0 * dimensions.1} Листинг 5-10: определение структуры RectangleЗдесь мы определили структуру и дали ей имя Rectangle. Внутри фигурных скобок определили поля как width и height, оба — типа u32. Затем в main создали конкретный экземпляр Rectangle с шириной в 30 и высотой в 50 единиц.Наша функция area теперь определена с одним параметром, названным rectangle, чей тип является неизменяемым заимствованием структуры Rectangle. Как упоминалось в главе 4, необходимо заимствовать структуру, а не передавать её во владение. Таким образом функция main сохраняет rect1 в собственности и может использовать еёдальше. По этой причине мы и используем & в сигнатуре и в месте вызова функции.Функция area получает доступ к полям width и height экземпляра Rectangle (обратите внимание, что доступ к полям заимствованного экземпляра структуры не приводит к перемещению значений полей, поэтому вы часто видите заимствования структур). Наша сигнатура функции для area теперь говорит именно то, что мы имеем в виду: вычислить площадь Rectangle, используя его поля width и height. Это означает, что ширина и высота связаны друг с другом, и даёт описательные имена значениям, а не использует значения индекса кортежа 0 и 1. Это торжество ясности.Добавление полезной функциональности при помощи выводимых1 ... 6 7 8 9 10 11 12 13 ... 62

help: use `impl Fn(i32) -> i32` as the return type, as all return paths are of type `[closure@src/lib.rs:2:5: 2:14]`, which implements `Fn(i32) -> i32` | 1 | fn returns_closure() -> impl Fn(i32) -> i32 { |

Листинг 12-17: Итерация по каждой строке из
contents
Метод lines возвращает итератор. Мы подробно поговорим об итераторах в
Главе 13
,
но вспомните, что вы видели этот способ использования итератора в
Листинге 3-5
, где мы использовали цикл for с итератором, чтобы выполнить некоторый код для каждого элемента в коллекции.
Поиск в каждой строке текста запроса
Далее мы проверяем, содержит ли текущая строка нашу искомую строку. К счастью, у строк есть полезный метод contains
, который именно это и делает! Добавьте вызов метода contains в функции search
, как показано в листинге 12-18. Обратите внимание,
что это все ещё не компилируется.
Файл: src/lib.rs
Листинг 12-18. Добавление проверки, содержится ли
query
в строке
Сохранение совпавшей строки
Нам также нужен способ хранить строки, содержащие искомую строку. Для этого мы можем создать изменяемый вектор перед циклом for и вызывать метод push для сохранения line в векторе. После цикла for мы возвращаем вектор, как показано в листинге 12-19.
Файл: src/lib.rs pub fn search
<
'a
>(query: &
str
, contents: &
'a str
) ->
Vec
<&
'a str
> { for line in contents.lines() {
// do something with line
}
} pub fn search
<
'a
>(query: &
str
, contents: &
'a str
) ->
Vec
<&
'a str
> { for line in contents.lines() { if line.contains(query) {
// do something with line
}
}
}

Листинг 12-19. Сохранение совпадающих строк, чтобы вернуть их
Теперь функция search должна возвратить только строки, содержащие query
, и тест должен пройти. Запустим его:
Наш тест пройден, значит он работает!
На этом этапе мы могли бы рассмотреть возможности изменения реализации функции поиска, сохраняя прохождение тестов и поддерживая имеющуюся функциональность.
Код в функции поиска не так уж плох, но он не использует некоторые полезные функции итераторов. Вернёмся к этому примеру в главе 13
, где будем исследовать итераторы подробно, и посмотрим как его улучшить.
Использование функции search в функции run pub fn search
<
'a
>(query: &
str
, contents: &
'a str
) ->
Vec
<&
'a str
> { let mut results =
Vec
::new(); for line in contents.lines() { if line.contains(query) { results.push(line);
}
} results
}
$
cargo test
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished test [unoptimized + debuginfo] target(s) in 1.22s
Running unittests src/lib.rs (target/debug/deps/minigrep-9cd200e5fac0fc94) running 1 test test tests::one_result ... ok test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/main.rs (target/debug/deps/minigrep-9cd200e5fac0fc94) running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests minigrep running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Теперь, когда функция search работает и протестирована, нужно вызвать search из нашей функции run
. Нам нужно передать значение config.query и contents
, которые run читает из файла, в функцию search
. Тогда run напечатает каждую строку,
возвращаемую из search
:
Файл: src/lib.rs
Мы по-прежнему используем цикл for для возврата каждой строки из функции search и
её печати.
Теперь вся программа должна работать! Давайте попробуем сначала запустить её со словом «frog», которое должно вернуть только одну строчку из стихотворения Эмили
Дикинсон:
Здорово! Теперь давайте попробуем слово, которое будет соответствовать нескольким строкам, например «body»:
И наконец, давайте удостоверимся, что мы не получаем никаких строк, когда ищем слово, отсутствующее в стихотворении, например «monomorphization»:
Отлично! Мы создали собственную мини-версию классического инструмента и научились тому, как структурировать приложения. Мы также немного узнали о файловом вводе и pub 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
(())
}
$
cargo run -- frog poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.38s
Running `target/debug/minigrep frog poem.txt`
How public, like a frog
$
cargo run -- body poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep body poem.txt`
I'm nobody! Who are you?
Are you nobody, too?
How dreary to be somebody!
$
cargo run -- monomorphization poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep monomorphization poem.txt`

выводе, временах жизни, тестировании и разборе аргументов командной строки.
Чтобы завершить этот проект, мы кратко продемонстрируем пару вещей: как работать с переменными окружения и как печатать в стандартный поток ошибок, обе из которых полезны при написании консольных программ.

Работа с переменными окружения
Мы улучшим minigrep
, добавив дополнительную функцию: опцию для поиск без учёта регистра, которую пользователь может включить с помощью переменной среды окружения. Мы могли бы сделать эту функцию параметром командной строки и потребовать, чтобы пользователи вводили бы её каждый раз при её применении, но вместо этого мы будем использовать переменную среды окружения. Это позволит нашим пользователям устанавливать переменную среды один раз и все поиски будут не чувствительны к регистру в этом терминальном сеансе.
Написание ошибочного теста для функции search с учётом регистра
Мы хотим добавить новую функцию search_case_insensitive
, которую мы будем вызывать, когда переменная окружения включена. Мы продолжим следовать процессу
TDD, поэтому первый шаг - это снова написать не проходящий тест. Мы добавим новый тест для новой функции search_case_insensitive и переименуем наш старый тест из one_result в case_sensitive
, чтобы прояснить различия между двумя тестами, как показано в листинге 12-20.
Файл: src/lib.rs

Листинг 12-20. Добавление нового не проходящего теста для функции поиска нечувствительной к регистру,
которую мы собираемся добавить
Обратите внимание, что мы также отредактировали содержимое переменной contents из старого теста. Мы добавили новую строку с текстом "Duct tape."
, используя заглавную D, которая не должна соответствовать запросу "duct"
при поиске с учётом регистра. Такое изменение старого теста помогает избежать случайного нарушения функциональности поиска чувствительного к регистру, который мы уже реализовали.
Этот тест должен пройти сейчас и должен продолжать выполняться успешно, пока мы работаем над поиском без учёта регистра.
Новый тест для поиска нечувствительного к регистру использует "rUsT"
качестве строки запроса. В функции search_case_insensitive
, которую мы собираемся реализовать,
запрос "rUsT"
должен соответствовать строке содержащей "Rust:"
с большой буквы R
и соответствовать строке "Trust me."
, хотя обе имеют разные регистры из запроса. Это наш не проходящий тест, он не компилируется, потому что мы ещё не определили функцию search_case_insensitive
. Не стесняйтесь добавлять скелет реализация,
которая всегда возвращает пустой вектор, аналогично тому, как мы это делали для функции search в листинге 12-16, чтобы увидеть компиляцию теста и его сбой.
#[cfg(test)]
mod tests { use super::*;
#[test]
fn case_sensitive
() { let query =
"duct"
; let contents =
"\
Rust: safe, fast, productive.
Pick three.
Duct tape."
; assert_eq!
(
vec!
[
"safe, fast, productive."
], search(query, contents));
}
#[test]
fn case_insensitive
() { let query =
"rUsT"
; let contents =
"\
Rust: safe, fast, productive.
Pick three.
Trust me."
; assert_eq!
( vec!
[
"Rust:"
,
"Trust me."
], search_case_insensitive(query, contents)
);
}
}

Реализация функции search_case_insensitive
Функция search_case_insensitive
, показанная в листинге 12-21, будет почти такая же,
как функция search
. Разница лишь в том, что текст будет в нижнем регистре для query и
для каждой line
, так что для любого регистра входных аргументов это будет тот же случай, когда мы проверяем, содержит ли строка запрос.
Файл: src/lib.rs
Листинг 12-21. Определение функции
search_case_insensitive
с уменьшением регистра строки запроса и
строки содержимого перед их сравнением
Сначала преобразуем в нижний регистр строку query и сохраняем её в затенённой переменной с тем же именем. Вызов to_lowercase для строки запроса необходим, так что независимо от того, будет ли пользовательский запрос "rust"
,
"RUST"
,
"Rust"
или "rUsT"
, мы будем преобразовывать запрос к "rust"
и делать значение нечувствительным к регистру. Хотя to_lowercase будет обрабатывать Unicode, он не будет точным на 100%. Если бы мы писали реальное приложение, мы бы хотели проделать здесь немного больше работы, но этот раздел посвящён переменным среды, а не Unicode, поэтому мы оставим это здесь.
Обратите внимание, что query теперь имеет тип
String
, а не срез строки, потому что вызов to_lowercase создаёт новые данные, а не ссылается на существующие. К примеру,
запрос:
"rUsT"
это срез строки не содержащий строчных букв u
или t
, которые мы можем использовать, поэтому мы должны выделить новую
String
, содержащую
«rust»
Когда мы передаём запрос query в качестве аргумента метода contains
, нам нужно добавить амперсанд, поскольку сигнатура contains
, определена для приёмы среза строки.
Затем мы добавляем вызов to_lowercase у каждой строки line
, прежде чем проверять,
содержит ли она query из всех строчных символов. Теперь, когда мы преобразовали line и query в нижний регистр, мы найдём совпадения независимо от того, в каком регистре находится переменная с запросом.
pub fn search_case_insensitive
<
'a
>( query: &
str
, contents: &
'a str
,
) ->
Vec
<&
'a str
> { let query = query.to_lowercase(); let mut results =
Vec
::new(); for line in contents.lines() { if line.to_lowercase().contains(&query) { results.push(line);
}
} results
}

Давайте посмотрим, проходит ли эта реализация тесты:
Отлично! Тесты прошли. Теперь давайте вызовем новую функцию search_case_insensitive из функции run
. Во-первых, мы добавим параметр конфигурации в структуру
Config для переключения между поиском с учётом регистра и без учёта регистра. Добавление этого поля приведёт к ошибкам компилятора, потому что мы ещё нигде не инициализируем это поле:
Файл: src/lib.rs
Обратите внимание, что мы добавили поле case_sensitive
, которое содержит логическое значение. Далее нам нужна функция run
, чтобы проверить значение поля case_sensitive и использовать его, чтобы решить, вызывать ли функцию search или функцию search_case_insensitive
, как показано в листинге 12-22. Обратите внимание,
что код все ещё не компилируется.
Файл: src/lib.rs
$
cargo test
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished test [unoptimized + debuginfo] target(s) in 1.33s
Running unittests src/lib.rs (target/debug/deps/minigrep-9cd200e5fac0fc94) running 2 tests test tests::case_insensitive ... ok test tests::case_sensitive ... ok test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/main.rs (target/debug/deps/minigrep-9cd200e5fac0fc94) running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests minigrep running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s pub struct
Config
{ pub query:
String
, pub file_path:
String
, pub ignore_case: bool
,
}

1 ... 28 29 30 31 32 33 34 35 ... 62

Листинг 12-22. Вызов либо
search
, либо
search_case_insensitive
на основе значения в
config.case_sensitive
Наконец, нам нужно проверить переменную среды. Функции для работы с переменными среды находятся в модуле env стандартной библиотеки, поэтому мы хотим подключить этот модуль в область видимости с помощью строки use std::env;
в верхней части
src/lib.rs. Затем мы будем использовать функцию var из модуля env для проверки переменной среды с именем
CASE_INSENSITIVE
, как показано в листинге 12-23.
Файл: src/lib.rs
Листинг 12-23. Проверка переменной среды с именем
CASE_INSENSITIVE
Здесь мы создаём новую переменную case_sensitive
. Чтобы установить её значение,
мы вызываем функцию env::var и передаём ей имя переменной окружения pub fn run
(config: Config) ->
Result
<(),
Box
<
dyn
Error>> { let contents = fs::read_to_string(config.file_path)?; let results = if config.ignore_case { search_case_insensitive(&config.query, &contents)
} else
{ search(&config.query, &contents)
}; for line in results { println!
(
"{line}"
);
}
Ok
(())
} use std::env;
// --snip-- impl
Config { pub fn build
(args: &[
String
]) ->
Result
'static str
> { if args.len() <
3
{ return
Err
(
"not enough arguments"
);
} let query = args[
1
].clone(); let file_path = args[
2
].clone(); let ignore_case = env::var(
"IGNORE_CASE"
).is_ok();
Ok
(Config { query, file_path, ignore_case,
})
}
}

CASE_INSENSITIVE
. Функция env::var возвращает
Result
, который будет успешным вариантом
Ok содержащий значение переменной среды, если переменная среды установлена. Он вернёт вариант
Err
, если переменная окружения не установлена.
Мы используем метод is_err у
Result
, чтобы проверить возвращается ли ошибка и следовательно, переменная среды не установлена, что означает, что должен
выполняться чувствительный к регистру поиск. Если для переменной среды
CASE_INSENSITIVE
что-либо задано, то is_err вернёт значение false и программа выполнит поиск без учёта регистра. Мы не заботимся о значении переменной среды, нас интересует только установлена она или нет, поэтому мы проверяем is_err
, а не используем unwrap
, expect или любой другой метод, который мы видели у
Result
Мы передаём значение переменной case_sensitive экземпляру
Config
, чтобы функция run могла прочитать это значение и решить, следует ли вызывать search или search_case_insensitive
, как мы реализовали в листинге 12-22.
Давайте попробуем! Во-первых, мы запустим нашу программу без установленной переменной среды и с помощью значения запроса to
, который должен соответствовать любой строке, содержащей слово «to» в нижнем регистре:
Похоже, все ещё работает! Теперь давайте запустим программу с
CASE_INSENSITIVE
,
установленным в
1
, но с тем же значением запроса to
Если вы используете PowerShell, вам нужно установить переменную среды и запустить программу двумя командами, а не одной:
Это заставит переменную окружения
CASE_INSENSITIVE
сохраниться до конца сеанса работы консоли. Переменную можно отключить с помощью команды
Remove-Item
:
Мы должны получить строки, содержащие «to», которые могут иметь заглавные буквы:
$
cargo run -- to poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep to poem.txt`
Are you nobody, too?
How dreary to be somebody!
PS>
$Env
:CASE_INSENSITIVE=1; cargo run to poem.txt
PS>
Remove-Item Env:CASE_INSENSITIVE

Отлично, мы также получили строки, содержащие «To»! Наша программа minigrep теперь может выполнять поиск без учёта регистра, управляемая переменной среды.
Теперь вы знаете, как управлять параметрами, заданными с помощью аргументов командной строки или переменных среды.
Некоторые программы допускают использование аргументов и переменных среды для одной и той же конфигурации. В таких случаях программы решают, что из них имеет больший приоритет. Для другого самостоятельного упражнения попробуйте управлять нечувствительностью к регистру с помощью аргумента командной строки или переменной окружения. Решите, должен ли приоритет иметь аргумент командной строки или переменная среды, если программа запускается с установленным параметром для нечувствительного к регистру поиска и установленного для поиска с учётом регистра.
Модуль std::env содержит много других полезных функций для работы с переменными среды: ознакомьтесь с его документацией, чтобы узнать доступные.
$
CASE_INSENSITIVE=1 cargo run to poem.txt
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep to poem.txt`
Are you nobody, too?
How dreary to be somebody!
To tell your name the livelong day
To an admiring bog!

Запись сообщений ошибок в поток ошибок вместо
стандартного потока вывода
В данный момент мы записываем весь наш вывод в терминал, используя функцию println!
. В большинстве терминалов предоставлено два вида вывода: стандартный
поток вывода ( stdout
) для общей информации и стандартный поток ошибок ( stderr
)
для сообщений об ошибках. Это различие позволяет пользователям выбирать,
направлять ли успешный вывод программы в файл, но при этом выводить сообщения об ошибках на экран.
Функция println!
может печатать только в стандартный вывод, поэтому мы должны использовать что-то ещё для печати в стандартный поток ошибок.
Проверка, куда записываются ошибки
Во-первых, давайте посмотрим, как содержимое, напечатанное из minigrep в настоящее время записывается в стандартный вывод, включая любые сообщения об ошибках,
которые мы хотим вместо этого записать в стандартный поток ошибок. Мы сделаем это,
перенаправив стандартный поток вывода в файл, а также намеренно вызовем ошибку.
Мы не будем перенаправлять стандартный поток ошибок, поэтому любой контент,
отправленный в поток стандартных ошибок будет продолжать отображаться на экране.
Ожидается, что программы командной строки будут отправлять сообщения об ошибках в стандартный поток ошибок, поэтому мы все равно можем видеть сообщения об ошибках на экране, даже если мы перенаправляем стандартный поток вывода в файл. Наша программа в настоящее время не ведёт себя правильно: мы увидим, что она сохраняет вывод сообщения об ошибке в файл!
Способ продемонстрировать это поведение - запустите программу с
>
и именем файла
output.txt в который мы хотим перенаправить стандартный поток вывода. Мы не передадим никаких аргументов, что должно вызвать внутри ошибку:
Синтаксис
>
указывает оболочке записывать содержимое стандартного вывода в
output.txt вместо экрана. Мы не увидели сообщение об ошибке, которое мы ожидали увидеть на экране, так что это означает, что оно должно быть в файле. Вот что содержит
output.txt:
Да, наше сообщение об ошибке выводится в стандартный вывод. Гораздо более полезнее, чтобы подобные сообщения об ошибках печатались в стандартной поток
$
cargo run > output.txt
Problem parsing arguments: not enough arguments

ошибок, поэтому в файл попадают только данные из успешного запуска. Мы поменяем это.
Печать ошибок в поток ошибок
Мы будем использовать код в листинге 12-24, чтобы изменить способ вывода сообщений об ошибках. Из-за рефакторинга, который мы делали ранее в этой главе, весь код,
который печатает сообщения об ошибках, находится в одной функции: main
Стандартная библиотека предоставляет макрос eprintln!
который печатает в стандартный поток ошибок, поэтому давайте изменим два места, где мы вызывали println!
для печати ошибок, чтобы использовать eprintln!
вместо этого.
Файл: src/main.rs
Листинг 12-24. Запись сообщений об ошибках в стандартный поток ошибок вместо потока стандартного
вывода используя макрос
eprintln!
После изменения println!
на eprintln!
, давайте снова запустим программу без каких- либо аргументов и перенаправим стандартный вывод с помощью
>
:
Теперь мы видим ошибку на экране и output.txt не содержит ничего, что мы ожидаем от программы командной строки.
Давайте снова запустим программу с аргументами, которые не вызывают ошибку, но все же перенаправляют стандартный вывод в файл, например так:
Мы не увидим никакого вывода в терминал, а output.txt будет содержать наши результаты:
fn main
() { let args:
Vec
<
String
> = env::args().collect(); let config = Config::build(&args).unwrap_or_else(|err| { eprintln!(
"Problem parsing arguments: {err}"
); process::exit(
1
);
}); if let
Err
(e) = minigrep::run(config) { eprintln!(
"Application error: {e}"
); process::exit(
1
);
}
}
$
cargo run > output.txt
Problem parsing arguments: not enough arguments
$
cargo run to poem.txt > output.txt

Файл: output.txt
Это демонстрирует, что в зависимости от ситуации мы теперь используем стандартный поток вывода для успешного текста и стандартный поток ошибок для вывода ошибок.
Итоги
В этой главе были повторены некоторые основные концепции, которые вы изучили до сих пор и было рассказано, как выполнять обычные операции ввода-вывода в Rust.
Используя аргументы командной строки, файлы, переменные среды и макрос eprintln!
для печати ошибок и вы теперь готовы писать приложения командной строки. Благодаря использованию концепций из предыдущих главах ваш код будет хорошо организован,
будет эффективно хранить данные в соответствующих структурах, хорошо обрабатывать ошибки и хорошо тестироваться.
Далее мы рассмотрим некоторые возможности Rust, на которые повлияли функциональные языки: замыкания и итераторы.
Are you nobody, too?
How dreary to be somebody!

Функциональные возможности языка:
итераторы и замыкания
Дизайн языка Rust был вдохновлён многими существующими языками и техниками, и существенное влияние на него оказало функциональное программирование.
Программирование в функциональном стиле часто включает использование функций в качестве значений, передаваемых в аргументах, возвращаемых из других функций,
назначаемых переменным для последующего выполнения и так далее.
В этой главе мы не будем обсуждать вопрос о том, чем является или не является функциональное программирование. Вместо этого мы обсудим некоторые функции Rust,
которые похожи на функции во многих других языках, которые часто называются функциональными.
Более подробно мы поговорим про:
Замыкания, функциональную конструкцию, которую вы можете хранить в переменной,
Итераторы — способ обработки последовательности элементов,
То, как, используя замыкания и итераторы, улучшить работу с операциями ввода- вывода в проекте из главы 12
Производительность замыканий и итераторов (спойлер: они быстрее, чем вы думаете!)
Мы уже рассмотрели другие возможности Rust, такие как сопоставление с образцом и перечисления, на которые также влияет функциональный стиль. Поскольку освоение замыканий и итераторов — важная часть написания идиоматичного, быстрого кода на
Rust, мы посвятим им всю эту главу.

Закрытия: Анонимные функции, подхватывающие
своё окружение
Замыкания в Rust - это анонимные функции, которые можно сохранять в переменных или передавать в качестве аргументов другим функциям. Вы можете создать замыкание в одном месте, а затем вызвать его в каком-нибудь другом, чтобы выполнить обработку в другом контексте. В отличие от функций, замыкания могут использовать значения из области видимости, в которой они были определены. Мы продемонстрируем, как эти возможности замыканий позволяют повторно использовать код и изменять поведение.
Захват переменных окружения с помощью замыкания
Сначала мы рассмотрим, как можно использовать замыкания для фиксирования значений среды, в которой они определены, для последующего использования. Вот сценарий: Время от времени наша компания по производству футболок выдаёт эксклюзивную футболку, выпущенную ограниченным тиражом, кому-то из нашего списка рассылки в качестве рекламной акции. Люди в списке рассылки могут по желанию добавить свой любимый цвет в свой профиль. Если человек, выбранный для получения бесплатной футболки, указал свой любимый цвет, он получает футболку этого цвета. Если человек не указал свой любимый цвет, он получит рубашку того цвета, которых в данный момент у компании больше всего.
Существует множество способов реализовать это. В данном примере мы будем использовать перечисление
ShirtColor
, которое имеет варианты
Red и
Blue
(для простоты ограничим количество доступных цветов). Запасы компании мы представим структурой
Inventory
, которая имеет поле shirts
, содержащее
Vec
,
который содержит цвета рубашек, имеющихся на складе. Метод giveaway
,
определённый у
Inventory
, получает опциональный цвет рубашки, который предпочитает обладатель бесплатной рубашки, и возвращает цвет рубашки, которую он получит. Эта схема показана в листинге 13-1:
Файл : src/main.rs

Листинг 13-1: Ситуация с раздачей рубашек компанией
#[derive(Debug, PartialEq, Copy, Clone)]
enum
ShirtColor
{
Red,
Blue,
} struct
Inventory
{ shirts:
Vec
,
} impl
Inventory { fn giveaway
(&
self
, user_preference:
Option
) -> ShirtColor { user_preference.unwrap_or_else(|| self
.most_stocked())
} fn most_stocked
(&
self
) -> ShirtColor { let mut num_red =
0
; let mut num_blue =
0
; for color in
&
self
.shirts { match color {
ShirtColor::Red => num_red +=
1
,
ShirtColor::Blue => num_blue +=
1
,
}
} if num_red > num_blue {
ShirtColor::Red
} else
{
ShirtColor::Blue
}
}
} fn main
() { let store = Inventory { shirts: vec!
[ShirtColor::Blue, ShirtColor::Red, ShirtColor::Blue],
}; let user_pref1 =
Some
(ShirtColor::Red); let giveaway1 = store.giveaway(user_pref1); println!
(
"The user with preference {:?} gets {:?}"
, user_pref1, giveaway1
); let user_pref2 =
None
; let giveaway2 = store.giveaway(user_pref2); println!
(
"The user with preference {:?} gets {:?}"
, user_pref2, giveaway2
);
}

В магазине store
, определённом в main
, осталось две синие и одна красная рубашки для этой ограниченной акции. Мы вызываем метод giveaway для пользователя предпочитающего красную рубашку и для пользователя без каких-либо предпочтений.
Опять же, этот код мог быть реализован множеством способов, но в данном случае,
чтобы сосредоточиться на замыканиях, мы придерживались изученных ранее концепций, за исключением тела метода giveaway
, в котором используется замыкание. В
методе giveaway мы получаем пользовательское предпочтение цвета как параметр типа
Option
и вызываем метод unwrap_or_else на user_preference
. Метод unwrap_or_else на
Option
определён стандартной библиотекой. Он принимает один аргумент: замыкание без аргументов, которое возвращает значение
T
(тот же тип,
который хранится в
Some варианта
Option
, в данном случае
ShirtColor
). Если
Option
является вариантом
Some
, unwrap_or_else возвращает значение из
Some
Если
Option
является вариантом
None
, unwrap_or_else вызывает замыкание и вернёт значение, возвращённое замыканием.
В качестве аргумента unwrap_or_else мы передаём замыкание
|| self.most_stocked()
Это замыкание, которое само не принимает никаких параметров (если бы у замыкания были параметры, они появились бы между двумя вертикальными полосами). В теле замыкания вызывается self.most_stocked()
. Здесь мы определили замыкание, а реализация unwrap_or_else такова, что выполнится оно позднее, когда потребуется получить результат.
Выполнение этого кода выводит:
Интересным аспектом здесь является то, что мы передали замыкание, которое вызывает self.most_stocked()
текущего экземпляра
Inventory
. Стандартной библиотеке не нужно знать ничего о типах
Inventory или
ShirtColor
, которые мы определили, или о логике, которую мы хотим использовать в этом сценарии. Замыкание фиксирует неизменяемую ссылку на self
Inventory и передаёт её с указанным нами кодом в метод unwrap_or_else
. А вот функции не могут фиксировать своё окружение таким образом.
Выведение и аннотация типов замыкания
Есть и другие различия между функциями и замыканиями. Замыкания обычно не требуют аннотирования типов параметров или возвращаемого значения, как это делается в функциях fn
. Аннотации типов требуются для функций, потому что типы
$
cargo run
Compiling shirt-company v0.1.0 (file:///projects/shirt-company)
Finished dev [unoptimized + debuginfo] target(s) in 0.27s
Running `target/debug/shirt-company`
The user with preference Some(Red) gets Red
The user with preference None gets Blue

являются частью явного интерфейса, предоставляемого пользователям. Жёсткое определение этого интерфейса важно для того, чтобы все согласились с тем, какие типы значений использует и возвращает функция. С другой стороны, замыкания не используются подобным образом: они хранятся в переменных и используются без указания их имён и не предоставляются для использования пользователям нашей библиотеки.
Замыкания, как правило, короткие и уместны только в узком контексте, а не в произвольном сценарии. В этих ограниченных контекстах компилятор может вывести типы параметров и возвращаемого типа, подобно тому, как он может вывести типы большинства переменных (есть редкие случаи, когда компилятору также нужны аннотации типов замыканий).
Как и в случае с переменными, мы можем добавить аннотации типов, если хотим повысить ясность и чёткость описания ценой большей многословности, чем это необходимо. Аннотирование типов для замыкания будет выглядеть как определение,
показанное в листинге 13-2. В этом примере мы определяем замыкание и храним его в переменной, а не определяем замыкание в том месте, куда мы передаём его в качестве аргумента, как это было в листинге 13-1.
Файл : src/main.rs

1 ... 29 30 31 32 33 34 35 36 ... 62

Смотрите также файлы

Выполнение практических заданий по дисциплине административное право.docx

Лабораторная работа 1 Кобеидзе Николай Пример П1.docx

Рабочая программа по английскому языку.docx

Выбрать слово, в котором согласная буква s читается не так, как в остальных предложенных словах.docx

Задача 3 Общин положения.docx

Файл: Язык программирования Rust.pdf

Смотрите также файлы

Информация

Списки файлов

Дополнительно