Разбирането на enum и съпоставянето на шаблони е фундаментално в Rust. Разгледайте ефективни техники за прилагане и на двете.

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

Enums (изброяване) е тип данни, който позволява представянето на фиксиран набор от стойности, като дните от седмицата и цвета на дъгата. Енумите са удобни, когато възможните стойности за променлива са ограничени и известни.

Дефиниране на енуми в Rust

Декларирането на enum в Rust е подобно на деклариране на enum в C#. Ще използвате изброяване ключова дума след името и набор от фигурни скоби за дефиниране на изброявания. Можете да дефинирате възможните варианти (обекти) във фигурните скоби със запетая като разделител.

Ето изброяване на дните от седмицата:

изброяванеДелничен ден {
 понеделник,
 вторник,
 сряда,
 четвъртък,
 петък,
 събота,
 неделя,
}
instagram viewer

The Делничен ден enum представлява дните от седмицата. The варианти са имената на деня и нямат свързани стойности. Също така, вариантите на вашето enum могат да бъдат всякакви Тип данни Rust.

Можете да получите достъп до варианти, като посочите името на варианта с помощта на оператора за разделител на пътя (::) в enum.

позволявам ден = делничен ден:: понеделник;
// статично въведена версия на променливата `day`
позволявам ден: Делничен ден = Делничен ден:: Понеделник;

Кодът указва, че искате да получите достъп до понеделник вариант на Weekday enum.

Варианти и дискриминанти на енуми

Вариантите на enum са свързани с целочислени стойности, наречени дискриминанта. По подразбиране дискриминантните стойности започват от нула и се увеличават с 1 за следващите варианти; въпреки това е възможно да се зададат персонализирани стойности на дискриминант за всеки вариант.

Ето пример за изброяването Weekday с присвоени стойности варианти.

изброяванеДелничен ден {
 понеделник = 1,
 вторник = 2,
 сряда = 3,
 четвъртък = 4,
 петък = 5,
 събота = 6,
 неделя = 7,
}

Преброяването Weekday има седем варианта, представляващи всеки ден от седмицата и всеки ден има стойност (наречена дискриминант), която му е присвоена. Вариантите са по ред от първия до последния ден от седмицата.

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

fnосновен() {
println!(„Понеделник: {}“, делничен ден:: понеделник катоi32);
println!(„Вторник: {}“, делничен ден:: вторник катоi32);
println!(„Сряда: {}“, делничен ден:: сряда катоi32);
println!(„Четвъртък: {}“, делничен ден:: четвъртък катоi32);
println!(„Петък: {}“, делничен ден:: петък катоi32);
println!(„Събота: {}“, делничен ден:: събота катоi32);
println!(„Неделя: {}“, делничен ден:: неделя катоi32);
}

The println! макросът се използва за отпечатване на дискриминантите. Всеки печат! извикването на макрос приема два аргумента: форматиращ низ и стойност. Форматиращият низ указва как да форматирате изхода; стойността е действителната стойност, която се отпечатва.

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

Изричното прехвърляне към i32 е необходимо, тъй като преброяванията на Rust са представени като цели числа, но конкретният тип цяло число зависи от размера на преброяването. По подразбиране Rust присвоява най-малкия тип цяло число, който може да представи всички дискриминанти в enum. Но в този случай искате да отпечатате стойностите като i32 цели числа, така че трябва да ги прехвърлите изрично.

Ето резултата от стартирането на основен функция:

Съвпадение на модели в Rust

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

Ще използвате съвпада ключова дума, последвана от => разделител за шаблона и съответно операцията за шаблона. Моделът може да бъде всеки Rust израз, включително литерали, променливи и извиквания на функции.

Ето примерна декларация за съответствие:

fnосновен(){
позволявам x = 5;
съвпада х {
1 => println!("един"),
2 => println!("две"),
3 => println!("три"),
// изпълнява се, ако нито един от шаблоните не съвпада
 _ => println!("нещо друго"),
 }
}

The основен функционални съвпадения х срещу няколко шаблона и след това отпечатва стойността въз основа на стойността на x. Долната черта (_) е образец с заместващ знак, който се използва като универсален за случаи, които не се обработват изрично.

Енуми и съпоставяне на шаблони

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

Ето изброяване на цветовете в дъгата:

изброяванедъга {
 Червен,
 портокал,
 жълто,
 зелено,
 Син,
 индиго,
 виолетово,
}

Всеки вариант на дъга enum представлява цвят на дъгата. Можете да използвате съпоставяне на шаблон с оператора за съвпадение, за да съпоставите шаблони с варианта, за да контролирате потока на програмата въз основа на цвета на дъгата.

Ето функция, която приема цветовия вариант от преброяването Rainbow и отпечатва съобщение въз основа на цвета.

fnпечат_цвят(цвят: дъга) {
съвпада цвят {
 Дъга:: Червено => println!("Цветът е червен!"),
 Дъга:: Оранжево => println!("Цветът е оранжев!"),
 Дъга:: Жълто => println!("Цветът е жълт!"),
 Дъга:: Зелено => println!("Цветът е зелен!"),
 Дъга:: Синьо => println!("Цветът е син!"),
 Дъга:: Индиго => println!("Цветът е индиго!"),
 Дъга:: Виолетов => println!("Цветът е виолетов!"),
 }
}
fnосновен() {
позволявам цвят = Rainbow:: Blue;
 print_color (цвят);
}

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

The печат_цвят функцията приема цветен параметър от типа enum Rainbow. Изявлението за съвпадение съвпада с цвета от набор от цветове, достъпни чрез имената на вариантите. И накрая, съобщението се отпечатва въз основа на съответстващия цвят.

Можете да използвате съвпадение на образец за сложни операции като множество връщани стойности въз основа на условие.

fnизчисляване на дължина на_вълната(цвят: Rainbow) -> u32 {
съвпада цвят {
 Дъга:: Червено => 700,
 Дъга:: Оранжево => 590,
 Дъга:: Жълто => 570,
 Дъга:: Зелено => 510,
 Дъга:: Синьо => 475,
 Дъга:: Индиго => 445,
 Дъга:: Виолетов => 400,
 }
}

The изчисляване на дължина на_вълната функцията приема цветен вариант на типа enum Rainbow като параметър и връща 32-битово цяло число без знак, което е дължината на вълната на цвета, който съответства на шаблона.

Rust също предоставя структури за създаване на персонализирани типове

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

Rust също предоставя структури, които можете да използвате за създаване на потребителски типове с наименувани полета. За разлика от enum, структурите ви позволяват да дефинирате полета от различни типове, до които имате достъп и които можете да променяте поотделно.