Enum के Basics
enum Name {
Variant1,
Variant2(Type),
Variant3 { field: Type },
}
let value = Name::Variant1;Defining a Simple Enum
एक enum एक type define करता है जिसकी value named variants के एक fixed set में से बिल्कुल एक हो सकती है, possibilities के एक closed set को represent करने के लिए उपयोगी।
उदाहरण: Defining a Simple Enum
// Auto-generate #[derive(Debug)] for the type below
#[derive(Debug)]
// Define an enum `Direction` listing its possible variants
enum Direction {
North,
South,
East,
West,
}
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `heading`, set to `Direction::North`
let heading = Direction::North;
// Print "{:?}" to the console, substituting in `heading` (with a trailing newline)
println!("{:?}", heading);
}Login to try C/C++/Java/PHP code in the editor
Enums With Data
Simple labels के विपरीत, Rust enum variants अपना खुद का associated data रख सकते हैं, और अलग-अलग variants अलग-अलग types और मात्रा में data रख सकते हैं।
उदाहरण: Enums With Data
// Auto-generate #[derive(Debug)] for the type below
#[derive(Debug)]
// Define an enum `Shape` listing its possible variants
enum Shape {
Circle(f64),
Rectangle(f64, f64),
}
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `shapes`, set to `[Shape::Circle(2.0), Shape::Rectangle(3.0, 4.0)]`
let shapes = [Shape::Circle(2.0), Shape::Rectangle(3.0, 4.0)];
// Loop over `shapes.iter()`, binding each item to `s`
for s in shapes.iter() {
// Print "{:?}" to the console, substituting in `s` (with a trailing newline)
println!("{:?}", s);
}
}Login to try C/C++/Java/PHP code in the editor
Matching on an Enum
यह जांचने का primary तरीका match है कि एक enum value किस variant को रखता है और इसके रखे किसी भी data को निकालने के लिए, हर possible variant के लिए एक अलग arm के साथ।
उदाहरण: Matching on an Enum
// Define an enum `TrafficLight` listing its possible variants
enum TrafficLight {
Red,
Yellow,
Green,
}
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `light`, set to `TrafficLight::Yellow`
let light = TrafficLight::Yellow;
// Match on `light` and branch by pattern
match light {
TrafficLight::Red => println!("Stop"),
TrafficLight::Yellow => println!("Slow down"),
TrafficLight::Green => println!("Go"),
}
}Login to try C/C++/Java/PHP code in the editor
Comparing Enum Values
किसी enum पर PartialEq derive करना इसकी values को सीधे == से compare करने देता है, जो एक पूरा match लिखे बिना साधारण checks के लिए उपयोगी है।
उदाहरण: Comparing Enum Values
// Auto-generate #[derive(PartialEq, Debug)] for the type below
#[derive(PartialEq, Debug)]
// Define an enum `Status` listing its possible variants
enum Status {
Active,
Inactive,
}
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `current`, set to `Status::Active`
let current = Status::Active;
// Print "Is active: {}" to the console, substituting in `current == Status::Active` (with a trailing newline)
println!("Is active: {}", current == Status::Active);
}Login to try C/C++/Java/PHP code in the editor
- यह भूल जाना कि एक enum variant अपना खुद का data रख सकता है, सिर्फ कुछ दूसरी languages की तरह एक plain label नहीं।
- enum पर
PartialEqderive करने से पहले variants को==से compare करने की कोशिश करना। - यह मान लेना कि enum variant names globally unique हैं -- import किए बिना इन्हें
EnumName::Variantसे qualify किया जाना चाहिए।
- एक enum एक type define करता है जो कई named variants में से बिल्कुल एक हो सकता है।
- Variants optionally associated data रख सकते हैं, हर variant के लिए अलग data सहित।
- Enum values को आमतौर पर यह branch करने के लिए
matchसे handle किया जाता है कि कौन सा variant मौजूद है। - किसी enum पर
DebugऔरPartialEqजैसे traits derive करना printing और comparison enable करता है।
Chapter Quiz — Complete all 7 topics to unlock
0/7 topics done
Complete these topics first: