Синтаксис шаблонов
В этом разделе мы соберём весь синтаксис, допустимый в шаблонах, и обсудим, почему и когда может понадобиться использовать каждый из них.
Сопоставление с литералами
Как вы видели в главе 6, шаблоны можно сопоставлять с литералами напрямую. Следующий код приводит несколько примеров:
fn main() {
let x = 1;
match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("anything"),
}
}
Этот код печатает one, потому что значение в x равно 1. Этот синтаксис полезен,
когда нужно, чтобы код выполнил действие при получении конкретного значения.
Сопоставление с именованными переменными
Именованные переменные — это неопровержимые шаблоны, которые соответствуют любому значению, и мы использовали
их много раз в этой книге. Однако есть complication при использовании
именованных переменных в выражениях match, if let или while let. Поскольку каждое
из этих видов выражений начинает новую область видимости, переменные, объявленные как часть
шаблона внутри этих выражений, затеняют те, что имеют то же имя за пределами
этих конструкций, как и все переменные. В листинге 19-11 мы объявляем
переменную с именем x со значением Some(5) и переменную y со значением
10. Затем мы создаём выражение match для значения x. Посмотрите на
шаблоны в ветвях match и println! в конце, и попробуйте понять,
что напечатает код, прежде чем запустить его или читать дальше.
fn main() {
let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
Some(y) => println!("Matched, y = {y}"),
_ => println!("Default case, x = {x:?}"),
}
println!("at the end: x = {x:?}, y = {y}");
}
match с ветвью, которая вводит новую переменную, затеняющую существующую переменную yДавайте пройдёмся по тому, что происходит при выполнении выражения match. Шаблон
в первой ветви match не соответствует определённому значению x, поэтому код
продолжается.
Шаблон во второй ветви match вводит новую переменную с именем y, которая
будет соответствовать любому значению внутри Some. Поскольку мы находимся в новой области видимости внутри
выражения match, это новая переменная y, а не y, которую мы объявили в
начале со значением 10. Эта новая привязка y будет соответствовать любому значению
внутри Some, которое у нас есть в x. Следовательно, эта новая y связывается с
внутренним значением Some в x. Это значение равно 5, поэтому выполняется выражение для
этой ветви и печатается Matched, y = 5.
Если бы x был значением None вместо Some(5), шаблоны в первых
двух ветвях не совпали бы, поэтому значение совпало бы с
подчёркиванием. Мы не ввели переменную x в шаблоне
ветви с подчёркиванием, поэтому x в выражении — это всё ещё внешний x, который не
был затенён. В этом гипотетическом случае match напечатал бы Default case, x = None.
Когда выражение match завершается, его область видимости заканчивается, как и область видимости
внутренней y. Последний println! выводит at the end: x = Some(5), y = 10.
Чтобы создать выражение match, которое сравнивает значения внешних x и
y, а не вводит новую переменную, затеняющую существующую переменную y,
нам нужно использовать условное условие match. Мы поговорим
об условиях match позже в разделе «Добавление условий с помощью условий
match».
Сопоставление с несколькими шаблонами
В выражениях match можно сопоставлять несколько шаблонов с помощью синтаксиса |,
который является оператором или для шаблонов. Например, в следующем коде мы сопоставляем
значение x с ветвями match, первая из которых имеет вариант или,
что означает, что если значение x совпадает с любым из значений в этой ветви, то
выполнится код этой ветви:
fn main() {
let x = 1;
match x {
1 | 2 => println!("one or two"),
3 => println!("three"),
_ => println!("anything"),
}
}
Этот код печатает one or two.
Сопоставление с диапазонами значений с помощью ..=
Синтаксис ..= позволяет сопоставлять с включающим диапазоном значений. В
следующем коде, когда шаблон совпадает с любым из значений в заданном
диапазоне, выполнится эта ветвь:
fn main() {
let x = 5;
match x {
1..=5 => println!("one through five"),
_ => println!("something else"),
}
}
Если x равен 1, 2, 3, 4 или 5, совпадёт первая ветвь. Этот синтаксис
удобнее для нескольких значений match, чем использование оператора | для
выражения той же идеи; если бы мы использовали |, нам пришлось бы указать 1 | 2 | 3 | 4 | 5. Указание диапазона намного короче, особенно если мы хотим сопоставить,
скажем, любое число от 1 до 1000!
Компилятор проверяет, что диапазон не пуст, во время компиляции, и поскольку
единственные типы, для которых Rust может определить, пуст ли диапазон, — это char и
числовые значения, диапазоны допускаются только с числовыми значениями или значениями char.
Вот пример с использованием диапазонов значений char:
fn main() {
let x = 'c';
match x {
'a'..='j' => println!("early ASCII letter"),
'k'..='z' => println!("late ASCII letter"),
_ => println!("something else"),
}
}
Rust может определить, что 'c' находится в диапазоне первого шаблона, и печатает early ASCII letter.
Деструктуризация для разделения значений
Мы также можем использовать шаблоны для деструктуризации структур, перечислений и кортежей, чтобы использовать разные части этих значений. Давайте пройдёмся по каждому значению.
Структуры
Листинг 19-12 показывает структуру Point с двумя полями, x и y, которую мы можем
разобрать с помощью шаблона в инструкции let.
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 0, y: 7 };
let Point { x: a, y: b } = p;
assert_eq!(0, a);
assert_eq!(7, b);
}
Этот код создаёт переменные a и b, которые соответствуют значениям полей x
и y структуры p. Этот пример показывает, что имена переменных
в шаблоне не обязательно должны совпадать с именами полей структуры.
Однако обычно имена переменных совпадают с именами полей, чтобы было
легче запомнить, какие переменные пришли из каких полей. Из-за этого
обычного использования и потому, что запись let Point { x: x, y: y } = p; содержит
много дублирования, в Rust есть сокращённая запись для шаблонов, соответствующих полям структуры:
достаточно перечислить имя поля структуры, и созданные из шаблона переменные
будут иметь те же имена. Листинг 19-13 ведёт себя так же, как код в листинге 19-12, но переменные, созданные в
шаблоне let, — это x и y вместо a и b.
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 0, y: 7 };
let Point { x, y } = p;
assert_eq!(0, x);
assert_eq!(7, y);
}
Этот код создаёт переменные x и y, которые соответствуют полям x и y
переменной p. В результате переменные x и y содержат значения
из структуры p.
Мы также можем деструктурировать с литеральными значениями как часть шаблона структуры, а не создавать переменные для всех полей. Это позволяет нам проверить некоторые поля на конкретные значения, создав при этом переменные для деструктуризации остальных полей.
В листинге 19-14 у нас есть выражение match, которое разделяет значения Point
на три случая: точки, которые лежат непосредственно на оси x (что верно, когда
y = 0), на оси y (x = 0) или ни на одной из осей.
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 0, y: 7 };
match p {
Point { x, y: 0 } => println!("On the x axis at {x}"),
Point { x: 0, y } => println!("On the y axis at {y}"),
Point { x, y } => {
println!("On neither axis: ({x}, {y})");
}
}
}
Первая ветвь совпадёт с любой точкой, лежащей на оси x, указав, что
поле y совпадает, если его значение совпадает с литералом 0. Шаблон по-прежнему
создаёт переменную x, которую мы можем использовать в коде для этой ветви.
Аналогично, вторая ветвь совпадает с любой точкой на оси y, указав, что
поле x совпадает, если его значение равно 0, и создаёт переменную y для
значения поля y. Третья ветвь не указывает никаких литералов, поэтому она
совпадает с любой другой Point и создаёт переменные для обоих полей x и y.
В этом примере значение p совпадает со второй ветвью благодаря тому, что x
содержит 0, поэтому этот код напечатает On the y axis at 7.
Помните, что выражение match прекращает проверку ветвей, как только находит
первый совпадающий шаблон, поэтому даже несмотря на то, что Point { x: 0, y: 0 } находится на оси x
и на оси y, этот код напечатал бы только On the x axis at 0.
Перечисления
Мы деструктурировали перечисления в этой книге (например, листинг 6-5 в главе 6),
но пока явно не обсуждали, что шаблон для деструктуризации перечисления
соответствует способу определения данных, хранящихся внутри перечисления. В качестве
примера, в листинге 19-15 мы используем перечисление Message из листинга 6-2 и пишем
match с шаблонами, которые деструктурируют каждое внутреннее значение.
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
fn main() {
let msg = Message::ChangeColor(0, 160, 255);
match msg {
Message::Quit => {
println!("The Quit variant has no data to destructure.");
}
Message::Move { x, y } => {
println!("Move in the x direction {x} and in the y direction {y}");
}
Message::Write(text) => {
println!("Text message: {text}");
}
Message::ChangeColor(r, g, b) => {
println!("Change color to red {r}, green {g}, and blue {b}");
}
}
}
Этот код напечатает Change color to red 0, green 160, and blue 255. Попробуйте
изменить значение msg, чтобы увидеть код из других ветвей в действии.
Для вариантов перечисления без каких-либо данных, таких как Message::Quit, мы не можем деструктурировать
значение дальше. Мы можем сопоставлять только с литеральным значением Message::Quit,
и в этом шаблоне нет переменных.
Для вариантов перечисления, похожих на структуры, таких как Message::Move, мы можем использовать шаблон,
аналогичный шаблону, который мы указываем для сопоставления со структурами. После имени варианта мы
ставим фигурные скобки и затем перечисляем поля с переменными, чтобы разобрать
части для использования в коде этой ветви. Здесь мы используем сокращённую
форму, как в листинге 19-13.
Для вариантов перечисления, похожих на кортежи, таких как Message::Write, который содержит кортеж с одним
элементом, и Message::ChangeColor, который содержит кортеж с тремя элементами,
шаблон аналогичен шаблону, который мы указываем для сопоставления с кортежами. Количество
переменных в шаблоне должно совпадать с количеством элементов в варианте, с которым мы
сопоставляем.
Вложенные структуры и перечисления
До сих пор все наши примеры сопоставляли структуры или перечисления на один уровень вглубь,
но сопоставление может работать и с вложенными элементами! Например, мы можем переработать
код в листинге 19-15, чтобы поддерживать цвета RGB и HSV в сообщении ChangeColor,
как показано в листинге 19-16.
enum Color {
Rgb(i32, i32, i32),
Hsv(i32, i32, i32),
}
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(Color),
}
fn main() {
let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));
match msg {
Message::ChangeColor(Color::Rgb(r, g, b)) => {
println!("Change color to red {r}, green {g}, and blue {b}");
}
Message::ChangeColor(Color::Hsv(h, s, v)) => {
println!("Change color to hue {h}, saturation {s}, value {v}");
}
_ => (),
}
}
Шаблон первой ветви в выражении match соответствует варианту перечисления
Message::ChangeColor, который содержит вариант Color::Rgb; затем
шаблон связывается с тремя внутренними значениями i32. Шаблон второй
ветви также соответствует варианту перечисления Message::ChangeColor, но внутреннее перечисление
вместо этого совпадает с Color::Hsv. Мы можем указать эти сложные условия в одном
выражении match, даже если задействованы два перечисления.
Структуры и кортежи
Мы можем смешивать, комбинировать и вкладывать шаблоны деструктуризации ещё более сложными способами. Следующий пример показывает сложную деструктуризацию, где мы вкладываем структуры и кортежи внутрь кортежа и деструктурируем все примитивные значения:
fn main() {
struct Point {
x: i32,
y: i32,
}
let ((feet, inches), Point { x, y }) = ((3, 10), Point { x: 3, y: -10 });
}
Этот код позволяет разбить сложные типы на их составные части, чтобы мы могли использовать интересующие нас значения отдельно.
Деструктуризация с помощью шаблонов — удобный способ использовать части значений, такие как значение из каждого поля структуры, отдельно друг от друга.
Игнорирование значений в шаблоне
Вы видели, что иногда полезно игнорировать значения в шаблоне, например
в последней ветви match, чтобы получить catch-all, который на самом деле ничего не
делает, но учитывает все оставшиеся возможные значения. Есть несколько
способов игнорировать целые значения или части значений в шаблоне: используя шаблон _
(который вы уже видели), используя шаблон _ внутри другого шаблона,
используя имя, начинающееся с подчёркивания, или используя .. для игнорирования оставшихся
частей значения. Давайте рассмотрим, как и зачем использовать каждый из этих шаблонов.
Целое значение с помощью _
Мы использовали подчёркивание как шаблон-подстановку, который будет соответствовать любому значению, но
не связывается со значением. Это особенно полезно в качестве последней ветви в match
выражении, но мы также можем использовать его в любом шаблоне, включая параметры
функции, как показано в листинге 19-17.
fn foo(_: i32, y: i32) {
println!("This code only uses the y parameter: {y}");
}
fn main() {
foo(3, 4);
}
_ в сигнатуре функцииЭтот код полностью проигнорирует значение 3, переданное в качестве первого аргумента,
и напечатает This code only uses the y parameter: 4.
В большинстве случаев, когда больше не нужен определённый параметр функции, сигнатуру меняют так, чтобы она не включала неиспользуемый параметр. Игнорирование параметра функции может быть особенно полезно в случаях, когда, например, реализуется трейт, где нужна определённая сигнатура типа, но тело функции в реализации не нуждается в одном из параметров. Тогда удаётся избежать предупреждения компилятора о неиспользуемых параметрах функции, которое появилось бы, если бы использовалось имя.
Части значения с помощью вложенного _
Мы также можем использовать _ внутри другого шаблона, чтобы игнорировать только часть значения,
например, когда мы хотим проверить только часть значения, но не использовать
другие части в соответствующем коде, который хотим выполнить. Листинг 19-18 показывает код,
отвечающий за управление значением настройки. Бизнес-требования таковы, что
пользователю не должно быть разрешено перезаписывать существующую настройку,
но он может сбросить настройку и присвоить ей значение, если она в настоящее время не установлена.
fn main() {
let mut setting_value = Some(5);
let new_setting_value = Some(10);
match (setting_value, new_setting_value) {
(Some(_), Some(_)) => {
println!("Can't overwrite an existing customized value");
}
_ => {
setting_value = new_setting_value;
}
}
println!("setting is {setting_value:?}");
}
Some, когда нам не нужно использовать значение внутри SomeЭтот код напечатает Can't overwrite an existing customized value, а затем
setting is Some(5). В первой ветви match нам не нужно сопоставлять или использовать
значения внутри любого из вариантов Some, но нам нужно проверить случай,
когда setting_value и new_setting_value являются вариантом Some. В этом
случае мы печатаем причину, по которой не изменяем setting_value, и оно не
изменяется.
Во всех остальных случаях (если либо setting_value, либо new_setting_value равно None)
выраженных шаблоном _ во второй ветви, мы хотим позволить
new_setting_value стать setting_value.
Мы также можем использовать подчёркивания в нескольких местах внутри одного шаблона, чтобы игнорировать конкретные значения. Листинг 19-19 показывает пример игнорирования второго и четвёртого значений в кортеже из пяти элементов.
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(first, _, third, _, fifth) => {
println!("Some numbers: {first}, {third}, {fifth}");
}
}
}
Этот код напечатает Some numbers: 2, 8, 32, а значения 4 и 16 будут
проигнорированы.
Неиспользуемая переменная с именем, начинающимся с _
Если создать переменную, но нигде её не использовать, Rust обычно выдаёт предупреждение, потому что неиспользуемая переменная может быть ошибкой. Однако иногда полезно иметь возможность создать переменную, которую пока не будете использовать, например, при прототипировании или только начиная проект. В этой ситуации можно сказать Rust не предупреждать о неиспользуемой переменной, начав имя переменной с подчёркивания. В листинге 19-20 мы создаём две неиспользуемые переменные, но при компиляции этого кода мы должны получить предупреждение только об одной из них.
fn main() {
let _x = 5;
let y = 10;
}
Здесь мы получаем предупреждение о неиспользовании переменной y, но не получаем
предупреждения о неиспользовании _x.
Обратите внимание, что есть тонкая разница между использованием только _ и использованием имени,
начинающегося с подчёркивания. Синтаксис _x всё равно связывает значение с
переменной, тогда как _ вообще не связывает. Чтобы показать случай, где это
различие важно, листинг 19-21 даст нам ошибку.
fn main() {
let s = Some(String::from("Hello!"));
if let Some(_s) = s {
println!("found a string");
}
println!("{s:?}");
}
Мы получим ошибку, потому что значение s всё равно будет перемещено в _s,
что не позволяет нам снова использовать s. Однако использование подчёркивания самого по себе
никогда не связывается со значением. Листинг 19-22 скомпилируется без ошибок,
потому что s не перемещается в _.
fn main() {
let s = Some(String::from("Hello!"));
if let Some(_) = s {
println!("found a string");
}
println!("{s:?}");
}
Этот код работает нормально, потому что мы никогда не связываем s с чем-либо; он не перемещается.
Оставшиеся части значения с помощью ..
Для значений, которые имеют много частей, мы можем использовать синтаксис .., чтобы использовать конкретные
части и игнорировать остальные, избегая необходимости перечислять подчёркивания для каждого
игнорируемого значения. Шаблон .. игнорирует любые части значения, которые мы не
явно сопоставили в остальной части шаблона. В листинге 19-23 у нас есть
структура Point, содержащая координату в трёхмерном пространстве. В
выражении match мы хотим работать только с координатой x и игнорировать
значения в полях y и z.
fn main() {
struct Point {
x: i32,
y: i32,
z: i32,
}
let origin = Point { x: 0, y: 0, z: 0 };
match origin {
Point { x, .. } => println!("x is {x}"),
}
}
Point, кроме x, с помощью ..Мы перечисляем значение x, а затем просто включаем шаблон ... Это быстрее,
чем перечислять y: _ и z: _, особенно когда мы работаем со
структурами, у которых много полей в ситуациях, где актуальны только одно или два поля.
Синтаксис .. раскроется в столько значений, сколько ему нужно. Листинг 19-24
показывает, как использовать .. с кортежем.
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(first, .., last) => {
println!("Some numbers: {first}, {last}");
}
}
}
В этом коде первое и последнее значения сопоставляются с first и last.
.. будет соответствовать и игнорировать всё в середине.
Однако использование .. должно быть однозначным. Если неясно, какие значения
предназначены для сопоставления, а какие следует игнорировать, Rust выдаст ошибку.
Листинг 19-25 показывает пример неоднозначного использования .., поэтому он не будет
компилироваться.
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(.., second, ..) => {
println!("Some numbers: {second}")
},
}
}
.. неоднозначным способомКогда мы компилируем этот пример, мы получаем эту ошибку:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
error: `..` can only be used once per tuple pattern
--> src/main.rs:5:22
|
5 | (.., second, ..) => {
| -- ^^ can only be used once per tuple pattern
| |
| previously used here
error: could not compile `patterns` (bin "patterns") due to 1 previous error
Невозможно определить для Rust, сколько значений в кортеже игнорировать
перед сопоставлением значения с second, а затем сколько ещё значений
игнорировать после этого. Этот код мог бы означать, что мы хотим игнорировать 2, связать
second с 4, а затем игнорировать 8, 16 и 32; или что мы хотим игнорировать
2 и 4, связать second с 8, а затем игнорировать 16 и 32; и так далее.
Имя переменной second ничего особенного не значит для Rust, поэтому мы получаем
ошибку компилятора, потому что использование .. в двух местах таким образом неоднозначно.
Добавление условий с помощью условий match
Условие match — это дополнительное условие if, указанное после шаблона в
ветви match, которое также должно совпасть, чтобы эта ветвь была выбрана. Условия match
полезны для выражения более сложных идей, чем позволяет один шаблон. Обратите внимание,
однако, что они доступны только в выражениях match, а не в if let или
while let.
Условие может использовать переменные, созданные в шаблоне. Листинг 19-26 показывает
match, где первая ветвь имеет шаблон Some(x) и также имеет условие
match if x % 2 == 0 (которое будет true, если число чётное).
fn main() {
let num = Some(4);
match num {
Some(x) if x % 2 == 0 => println!("The number {x} is even"),
Some(x) => println!("The number {x} is odd"),
None => (),
}
}
Этот пример напечатает The number 4 is even. Когда num сравнивается с
шаблоном в первой ветви, он совпадает, потому что Some(4) совпадает с Some(x). Затем
условие match проверяет, равен ли остаток от деления x на 2
0, и поскольку это так, выбирается первая ветвь.
Если бы num был Some(5), условие match в первой ветви было бы
false, потому что остаток от деления 5 на 2 равен 1, что не
равно 0. Затем Rust перешёл бы ко второй ветви, которая совпала бы, потому что
вторая ветвь не имеет условия match и поэтому совпадает с любым вариантом Some.
Нет способа выразить условие if x % 2 == 0 внутри шаблона, поэтому
условие match даёт нам возможность выразить эту логику. Обратной стороной
этой дополнительной выразительности является то, что компилятор не пытается проверить
исчерпывающность, когда задействованы выражения условий match.
При обсуждении листинга 19-11 мы упоминали, что могли бы использовать условия match, чтобы
решить нашу проблему затенения шаблона. Напомним, что мы создали новую переменную
внутри шаблона в выражении match вместо использования переменной
вне match. Эта новая переменная означала, что мы не могли проверить значение
внешней переменной. Листинг 19-27 показывает, как можно использовать условие match, чтобы исправить
эту проблему.
fn main() {
let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
Some(n) if n == y => println!("Matched, n = {n}"),
_ => println!("Default case, x = {x:?}"),
}
println!("at the end: x = {x:?}, y = {y}");
}
Этот код теперь напечатает Default case, x = Some(5). Шаблон во второй
ветви match не вводит новую переменную y, которая затенила бы внешнюю y,
что означает, что мы можем использовать внешнюю y в условии match. Вместо указания
шаблона как Some(y), который затенил бы внешнюю y, мы указываем
Some(n). Это создаёт новую переменную n, которая ничего не затеняет, потому что
вне match нет переменной n.
Условие match if n == y не является шаблоном и поэтому не вводит новые
переменные. Эта y является внешней y, а не новой y, которая её затеняет, и
мы можем искать значение, имеющее то же значение, что и внешняя y, сравнивая
n с y.
Вы также можете использовать оператор или | в условии match, чтобы указать несколько
шаблонов; условие match будет применяться ко всем шаблонам. Листинг
19-28 показывает приоритет при объединении шаблона, использующего |, с условием
match. Важная часть этого примера в том, что условие match if y
применяется к 4, 5, и 6, хотя может показаться, что if y применяется только
к 6.
fn main() {
let x = 4;
let y = false;
match x {
4 | 5 | 6 if y => println!("yes"),
_ => println!("no"),
}
}
Условие match гласит, что ветвь совпадает только если значение x
равно 4, 5 или 6 и если y равно true. При выполнении этого кода
шаблон первой ветви совпадает, потому что x равно 4, но условие match if y
равно false, поэтому первая ветвь не выбирается. Код переходит ко второй
ветви, которая совпадает, и эта программа печатает no. Причина в том, что
условие if применяется ко всему шаблону 4 | 5 | 6, а не только к последнему
значению 6. Другими словами, приоритет условия match по отношению к
шаблону ведёт себя так:
(4 | 5 | 6) if y => ...
а не так:
4 | 5 | (6 if y) => ...
После запуска кода поведение приоритета становится очевидным: если бы условие match
применялось только к последнему значению в списке значений, указанных с помощью
оператора |, ветвь совпала бы, и программа напечатала бы
yes.
Использование привязок @
Оператор at @ позволяет создать переменную, которая содержит значение в то же
время, когда мы проверяем это значение на соответствие шаблону. В листинге 19-29 мы хотим
проверить, что поле id сообщения Message::Hello находится в диапазоне 3..=7. Мы также
хотим связать значение с переменной id, чтобы использовать её в коде,
связанном с этой ветвью.
fn main() {
enum Message {
Hello { id: i32 },
}
let msg = Message::Hello { id: 5 };
match msg {
Message::Hello { id: id @ 3..=7 } => {
println!("Found an id in range: {id}")
}
Message::Hello { id: 10..=12 } => {
println!("Found an id in another range")
}
Message::Hello { id } => println!("Found some other id: {id}"),
}
}
@ для привязки к значению в шаблоне и его проверкиЭтот пример напечатает Found an id in range: 5. Указав id @ перед
диапазоном 3..=7, мы захватываем значение, совпавшее с диапазоном, в
переменную с именем id, одновременно проверяя, что значение соответствует шаблону диапазона.
Во второй ветви, где в шаблоне указан только диапазон, код,
связанный с ветвью, не имеет переменной, содержащей фактическое значение
поля id. Значение поля id могло быть 10, 11 или 12, но
код, связанный с этим шаблоном, не знает, какое именно. Код шаблона
не может использовать значение из поля id, потому что мы не сохранили
значение id в переменной.
В последней ветви, где мы указали переменную без диапазона, у нас
есть значение, доступное для использования в коде ветви в переменной с именем id. Причина
в том, что мы использовали сокращённую запись полей структуры. Но мы не применили
никакой проверки к значению в поле id в этой ветви, как мы это делали с
первыми двумя ветвями: любое значение совпало бы с этим шаблоном.
Использование @ позволяет проверить значение и сохранить его в переменной в одном шаблоне.
Итоги
Шаблоны Rust очень полезны для различения разных видов
данных. При использовании в выражениях match Rust гарантирует, что ваши шаблоны покрывают
все возможные значения, иначе программа не скомпилируется. Шаблоны в инструкциях
let и параметрах функций делают эти конструкции более полезными, позволяя
деструктурировать значения на более мелкие части и присваивать эти части
переменным. Мы можем создавать простые или сложные шаблоны в соответствии с нашими потребностями.
Далее, в предпоследней главе книги, мы рассмотрим некоторые продвинутые аспекты различных возможностей Rust.