Definiera Er första enum
Skapa enkla uppräknade typer.
Definiera Er första enum är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
What Is an Enum?
En enum (uppräkning) låter dig definiera en typ genom att lista dess möjliga värden, vilka kallas varianter. Ett värde av den typen kan endast vara en av dessa varianter.
Enums är extra användbara när något har en fast uppsättning tillstånd, som väderstreck eller färgerna i en kortlek.
enum Direction {
North,
South,
East,
West,
}Deklarera en enum
Ni deklarerar en enum med nyckelordet enum, ett namn och en kommaseparerad lista över varianter inom klammerparenteser.
Enligt konvention använder enum-namn PascalCase (som Direction), och det gör även variantnamnen (som North).
enum TrafficLight {
Red,
Yellow,
Green,
}Skapa ett enum-värde
För att skapa ett värde skriver ni enumens namn, två kolon :: och sedan varianten.
Exempelvis skapar Direction::North ett värde av typen Direction. :: visar för Rust vilken enum varianten tillhör.
enum Direction {
North,
South,
East,
West,
}
fn main() {
let heading = Direction::East;
println!("Created a direction value!");
}Enum-värden är typer
När en enum har definierats är den en riktig typ, precis som i32 eller bool. Ni kan lagra dess värden i variabler och skicka dem till funktioner.
En funktion som tar en Direction accepterar vilken som helst av dess varianter, men inget annat.
enum Direction {
North,
South,
}
fn describe(d: Direction) {
println!("Got a direction");
}
fn main() {
describe(Direction::North);
}Varför inte bara använda tal?
Ni skulle kunna representera ett trafikljus med 0, 1 och 2, men inget hindrar er från att av misstag använda 7.
En enum gör ogiltiga tillstånd omöjliga: kompilatorn garanterar att värdet alltid är en av de angivna varianterna. Det är säkrare och mycket enklare att läsa.
Härled Debug för utskrift
Som standard vet Rust inte hur en enum ska skrivas ut. Om ni lägger till #[derive(Debug)] ovanför enumen kan ni skriva ut den med formatteraren {:?}.
Det är utmärkt för snabb felsökning medan ni lär er.
#[derive(Debug)]
enum Direction {
North,
South,
}
fn main() {
let d = Direction::South;
println!("{:?}", d);
}Jämföra enum-värden
Lägg till #[derive(PartialEq)] så att ni kan jämföra varianter med ==.
Det är praktiskt för enkla kontroller, men för mer avancerat beteende är uttrycket match (som kommer snart) oftast ett bättre verktyg.
#[derive(PartialEq)]
enum Light {
Red,
Green,
}
fn main() {
let l = Light::Red;
if l == Light::Red {
println!("Stop!");
}
}Hur många varianter som helst
En enum kan ha så många varianter som ni behöver. De tillhör alla samma typ.
Genom att samla relaterade tillstånd hålls koden organiserad och de möjliga alternativen blir tydliga vid en snabb blick.
enum Suit {
Hearts,
Diamonds,
Clubs,
Spades,
}Enumer i standardbiblioteket
Rusters eget standardbibliotek använder enumar överallt. Två välkända är Option (ett värde som kan finnas eller saknas) och Result (lyckat resultat eller fel).
Genom att lära er enumar nu blir det lättare att förstå dessa grundläggande typer senare.
// Option is an enum in std:
// enum Option<T> {
// Some(T),
// None,
// }Kopiera enkla enumar
Enumar vars varianter inte innehåller data kan härleda Clone och Copy. Då kopieras värden automatiskt i stället för att flyttas.
Det gör att små tillståndsenumar fungerar som enkla värden, till exempel heltal.
#[derive(Clone, Copy)]
enum Coin {
Heads,
Tails,
}
fn main() {
let a = Coin::Heads;
let b = a; // a is still usable
}Sätta ihop allt
Här är ett komplett program: definiera en enum, skapa ett värde och skriv ut det med Debug.
Kör det och prova att ändra Green till en annan variant för att se hur utskriften uppdateras.
#[derive(Debug)]
enum TrafficLight {
Red,
Yellow,
Green,
}
fn main() {
let current = TrafficLight::Green;
println!("Light is {:?}", current);
}Snabbtest
Testa er förståelse av grunderna i enumar.
Sammanfattning
Ni har lärt er att en enum definierar en typ från en fast lista med varianter, deklarerad med nyckelordet enum.
Ni skapar värden med EnumName::Variant, och ni kan härleda Debug, PartialEq eller Copy för att skriva ut, jämföra och kopiera dem. Nästa steg är att lära er reagera på varje variant med match.
Lär dig Rust med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 144
Vanliga frågor
Är lektionen ”Definiera Er första enum” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Definiera Er första enum”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Vad lär jag mig i ”Definiera Er första enum”?
Skapa enkla uppräknade typer. Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?
Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Definiera Er första enum”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?
Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Definiera Er första enum
- Matcha enum-varianter
- Enum med data
- Match-villkor och bindningar