Lär dig programmera i Rust · Lektion

let och mutabilitet

Bindningar och mut

Lektion 1 av 413 steg

let och mutabilitet ä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.

Binda värden med let

I Rust skapar ni en variabel med nyckelordet let. Det binder ett namn till ett värde.

Som standard är varje bindning oföränderlig — när ni väl har gett den ett värde kan ni inte ändra det.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

Oföränderlig som standard

Rust gör variabler oföränderliga med avsikt. Det förhindrar oavsiktliga ändringar och gör koden enklare att förstå.

Om ni försöker tilldela en oföränderlig bindning ett nytt värde uppstår ett kompileringsfel, inte en krasch under körning.

let x = 5; följt av x = 6; kompilerar inte.

fn main() {
    let x = 5;
    // x = 6; // this would cause a compile error
    println!("x stays {}", x);
}

Göra variabler föränderliga

När ni behöver ändra ett värde lägger ni till nyckelordet mut. Då markeras bindningen som föränderlig.

Nu kan ni tilldela den nya värden hur många gånger ni vill.

fn main() {
    let mut count = 0;
    count = count + 1;
    count += 1;
    println!("count is {}", count);
}

Typinferens

Rust räknar vanligtvis ut en variabels typ från dess värde. Detta kallas typinferens.

let x = 5; ger automatiskt x typen i32.

fn main() {
    let n = 42;      // inferred as i32
    let pi = 3.14;   // inferred as f64
    println!("{} and {}", n, pi);
}

Typannoteringar

Ni kan också ange typen uttryckligen med ett kolon och ett typnamn. Detta kallas en typannotering.

Annoteringar är användbara när kompilatorn inte kan härleda typen eller när ni vill göra koden tydligare.

fn main() {
    let age: u32 = 30;
    let price: f64 = 9.99;
    println!("age {} price {}", age, price);
}

Konstanter

En const är alltid oföränderlig och måste ha en typannotering. Dess värde måste vara känt vid kompilering.

Enligt konvention skrivs konstanter med SCREAMING_SNAKE_CASE.

fn main() {
    const MAX_POINTS: u32 = 100_000;
    println!("Max is {}", MAX_POINTS);
}

const jämfört med let

Viktiga skillnader mellan const och let:

const kan aldrig vara mut.
const kräver en typannotering.
const måste vara ett konstant uttryck vid kompilering.
Värden med let kan beräknas under körning.

fn main() {
    const SECONDS_PER_HOUR: u32 = 60 * 60;
    let hours = 3;
    println!("{} seconds", SECONDS_PER_HOUR * hours);
}

Ändra värden i en loop

Föränderliga variabler är vanliga i loopar där ett värde byggs upp över tid.

Här summerar vi tal med hjälp av en ackumulator som är markerad med mut.

fn main() {
    let mut total = 0;
    for i in 1..=5 {
        total += i;
    }
    println!("Sum is {}", total);
}

Understreck för oanvända värden

Om ni binder ett värde men aldrig använder det varnar Rust er. Prefixa namnet med ett understreck för att tysta varningen.

let _unused = 10; talar om för kompilatorn att detta är avsiktligt.

fn main() {
    let _temp = 99;
    let used = 1;
    println!("{}", used);
}

Flera bindningar

Ni kan deklarera flera variabler på separata rader, var och en med sitt eget let.

Varje bindning är självständig och oföränderlig om den inte markeras med mut.

fn main() {
    let name = "Rust";
    let year = 2010;
    let mut version = 1;
    version += 1;
    println!("{} born {} v{}", name, year, version);
}

Varför oföränderlighet är användbart

Oföränderlighet är en säkerhetsfunktion. När kompilatorn vet att ett värde inte kan ändras kan den ge starkare garantier och förhindra hela klasser av buggar.

Använd mut endast när ni verkligen behöver ändra ett värde.

fn main() {
    let config = "production";
    // config is guaranteed not to change
    println!("Running in {}", config);
}

Snabbtest

Vilket nyckelord gör en Rust-variabel förändringsbar?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er grunderna i bindningar i Rust:

let binder ett namn till ett värde och är oföränderligt som standard.
mut gör en bindning föränderlig.
Rust härleder typer, men ni kan lägga till annoteringar med :.
const gäller vid kompilering, är alltid oföränderlig och behöver en typ.

fn main() {
    let mut score: u32 = 0;
    const BONUS: u32 = 10;
    score += BONUS;
    println!("Final score: {}", score);
}

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 ”let och mutabilitet” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”let och mutabilitet”, 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 ”let och mutabilitet”?

Bindningar och mut 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 ”let och mutabilitet”?

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