Lär dig programmera i Rust · Lektion

Deklarativa makron (`macro_rules!`)

Lär er skriva deklarativa makron för att abstrahera återkommande kodmönster och generera kod vid kompilering.

Lektion 1 av 311 steg

Deklarativa makron (`macro_rules!`) är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 1 av 3. 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 3 lektioner.

Vad är Rust-makron?

Makron är ett sätt att skriva kod som skriver kod! De liknar funktioner, men arbetar med syntaxträd (kodens struktur) i stället för värden.

De hjälper till att abstrahera repetitiv kod.
De möjliggör domänspecifika språk (DSL:er) i Rust.
De körs vid kompilering och expanderas till vanlig Rust-kod före kompileringen.

Deklarativ makrosyntax

Rusts deklarativa makron använder nyckelordet macro_rules!. De definierar en uppsättning regler som matchar specifika mönster av Rust-kod.

Tänk på det som mönstermatchning för kodavsnitt. När kompilatorn ser ett makroanrop försöker den matcha indata mot en av de regler Ni har definierat.

Ditt första `macro_rules!`

Vi ska skapa ett mycket enkelt makro som skriver ut en hälsning. Lägg märke till nyckelordet macro_rules! och syntaxen () => {}, som definierar en regel utan indatamönster.

Prova att köra exemplet:

macro_rules! greet {
    () => {
        println!("Hello from a macro!");
    };
}

fn main() {
    greet!(); // Call our macro!
}

Fånga indata med designatorer

Makron kan ta emot indata med hjälp av "designatorer". De anger vilken typ av Rust-syntax som makrot förväntas fånga.

$expr: Ett uttryck (till exempel 1 + 2, "hello")
$ident: En identifierare (till exempel ett variabelnamn eller funktionsnamn)
$ty: En typ (till exempel i32, String)
$block: Ett kodblock (till exempel { ... })
...och många fler!

Makron som tar argument

Här är ett makro som tar emot ett uttryck ($e:expr) och skriver ut dess värde. :expr är designatorn.

Det infångade $e blir sedan tillgängligt för användning i makrots kropp. Makrot stringify! omvandlar uttrycket till dess strängrepresentation.

macro_rules! debug_print {
    ($e:expr) => {
        println!("Debug: {} = {:?}", stringify!($e), $e);
    };
}

fn main() {
    let x = 10;
    debug_print!(x + 5);
    debug_print!("Rust macros are fun");
}

Hantera flera indata

Vad händer om du vill att ett makro ska ta flera argument av samma typ? Du kan använda repetitionsoperatorer: $()*.

$(): Innehållet inuti är mönstret som ska upprepas.
*: Noll eller flera upprepningar.
+: En eller flera upprepningar.
Du kan också ange en avgränsare, till exempel $(...),* för kommaseparerade objekt.

Makro med upprepade argument

Vi skapar ett makro som tar flera uttryck, separerade med kommatecken, och skriver ut vart och ett av dem individuellt. Detta är användbart när man vill skapa listliknande strukturer.

macro_rules! print_all {
    ( $( $x:expr ),* ) => {
        $( // This $(...)* repeats the `println!` call
            println!("Item: {:?}", $x);
        )*
    };
}

fn main() {
    print_all!(1, "hello", true, 3.14);
    print_all!("Just one item");
}

Förstå makrohygien

Rusts makron är ”hygieniska”. Det innebär att variabler som definieras inuti ett makro inte råkar krocka med variabler utanför makrot, även om de har samma namn.

Kompilatorn byter internt namn på saker under expansionen för att förhindra oavsiktliga bieffekter, vilket gör makron säkrare och mer förutsägbara att använda.

Så felsöker du makron

Ibland expanderas makron inte som du förväntar dig. Rust erbjuder ett sätt att visa den expanderade koden:

Kör cargo expand (kräver att verktyget cargo-expand installeras)
Använd rustc --pretty expanded direkt på din källfil.

Detta visar den råa Rust-kod som ditt makro genererar, vilket är ovärderligt när du felsöker och försöker förstå komplex makrofunktionalitet!

Frågesport om mönstermatchning i makron

Betrakta följande makrodefinition:

macro_rules! make_tuple {
    ( $x:expr, $y:expr ) => {
        ($x, $y)
    };
}

Vilken av följande rader skulle kompileras utan fel och använda makrot make_tuple!?

Besvara frågan i den interaktiva lektionen

Sammanfattning: deklarativa makron

I den här lektionen har du lärt dig om deklarativa makron med macro_rules!:

De genererar kod vid kompilering och abstraherar bort upprepade mönster.
De använder mönstermatchning för att fånga indata baserat på syntax.
Designatorer som $expr och $ident anger vilken typ av syntax som förväntas.
Repetitionsoperatorer som $()* hanterar flera argument med flexibla avgränsare.
Makron är hygieniska och förhindrar oavsiktliga namnkonflikter.

Makron är ett kraftfullt verktyg för att minska mängden standardkod och skapa flexibla, lättanvända API:er i Rust!

Gratis att börja

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Deklarativa makron (`macro_rules!`)” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Deklarativa makron (`macro_rules!`)”, 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 3 lektioner.

Vad lär jag mig i ”Deklarativa makron (`macro_rules!`)”?

Lär er skriva deklarativa makron för att abstrahera återkommande kodmönster och generera kod vid kompilering. 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 3.

Hur lång tid tar lektionen ”Deklarativa makron (`macro_rules!`)”?

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

← Tillbaka till Lär dig programmera i Rust