let og mutabilitet
Bindinger og mutabilitet
let og mutabilitet er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.
Binding af værdier med let
I Rust opretter du en variabel med nøgleordet let. Det binder et navn til en værdi.
Som standard er enhver binding uforanderlig — når du først har givet den en værdi, kan du ikke ændre den.
fn main() {
let x = 5;
println!("The value of x is: {}", x);
}Uforanderlig som standard
Rust gør med vilje variabler uforanderlige. Det forhindrer utilsigtede ændringer og gør koden lettere at forstå.
Hvis du forsøger at tildele en uforanderlig binding en ny værdi, får du en kompileringsfejl, ikke et nedbrud under kørsel.
let x = 5;efterfulgt afx = 6;vil ikke kompilere.
fn main() {
let x = 5;
// x = 6; // this would cause a compile error
println!("x stays {}", x);
}Gør variabler foranderlige
Når du har brug for at ændre en værdi, skal du tilføje nøgleordet mut. Det markerer bindingen som foranderlig.
Nu kan du tildele den en ny værdi så mange gange, du vil.
fn main() {
let mut count = 0;
count = count + 1;
count += 1;
println!("count is {}", count);
}Typeinferens
Rust finder som regel typen for en variabel ud fra dens værdi. Det kaldes typeinferens.
let x = 5; giver automatisk x typen i32.
fn main() {
let n = 42; // inferred as i32
let pi = 3.14; // inferred as f64
println!("{} and {}", n, pi);
}Typeannoteringer
Du kan også angive typen eksplicit med et kolon og et typenavn. Det kaldes en typeannotering.
Annoteringer er nyttige, når compileren ikke kan udlede typen, eller når du vil gøre koden tydeligere.
fn main() {
let age: u32 = 30;
let price: f64 = 9.99;
println!("age {} price {}", age, price);
}Konstanter
En const er altid uforanderlig og skal have en typeannotering. Dens værdi skal være kendt på kompileringstidspunktet.
Efter konvention skrives konstanter med SCREAMING_SNAKE_CASE.
fn main() {
const MAX_POINTS: u32 = 100_000;
println!("Max is {}", MAX_POINTS);
}const sammenlignet med let
Vigtige forskelle mellem const og let:
constkan aldrig væremut.constkræver en typeannotering.constskal være et konstant udtryk ved kompilering.- Værdier med
letkan beregnes under kørsel.
fn main() {
const SECONDS_PER_HOUR: u32 = 60 * 60;
let hours = 3;
println!("{} seconds", SECONDS_PER_HOUR * hours);
}Ændring i en løkke
Foranderlige variabler er almindelige i løkker, hvor en værdi akkumuleres over tid.
Her lægger vi tal sammen ved hjælp af en akkumulator med mut.
fn main() {
let mut total = 0;
for i in 1..=5 {
total += i;
}
println!("Sum is {}", total);
}Brug understregning til ubrugte værdier
Hvis du binder en værdi, men aldrig bruger den, advarer Rust dig. Sæt en understregning foran navnet for at undertrykke advarslen.
let _unused = 10;fortæller compileren, at det er tilsigtet.
fn main() {
let _temp = 99;
let used = 1;
println!("{}", used);
}Flere bindinger
Du kan erklære flere variabler på separate linjer, hver med sin egen let.
Hver binding er uafhængig og uforanderlig, medmindre den er markeret med mut.
fn main() {
let name = "Rust";
let year = 2010;
let mut version = 1;
version += 1;
println!("{} born {} v{}", name, year, version);
}Hvorfor uforanderlighed hjælper
Uforanderlighed er en sikkerhedsfunktion. Når compileren ved, at en værdi ikke kan ændre sig, kan den give stærkere garantier og forhindre hele klasser af fejl.
Brug kun ændringer med mut, når du virkelig har brug for det.
fn main() {
let config = "production";
// config is guaranteed not to change
println!("Running in {}", config);
}Hurtigt tjek
Hvilket nøgleord gør en Rust-variabel foranderlig?
Opsummering
Du har lært det grundlæggende om bindinger i Rust:
letbinder et navn til en værdi, som er uforanderlig som standard.mutgør en binding foranderlig.- Rust udleder typer, men du kan tilføje annoteringer med
:. constbestemmes ved kompilering, er altid uforanderlig og kræver en type.
fn main() {
let mut score: u32 = 0;
const BONUS: u32 = 10;
score += BONUS;
println!("Final score: {}", score);
}
Lær Rust med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 39
- Lektioner
- 144
Ofte stillede spørgsmål
Er lektionen “let og mutabilitet” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “let og mutabilitet”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “let og mutabilitet”?
Bindinger og mutabilitet Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Lær at programmere i Rust?
Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.
Hvor lang tid tager lektionen “let og mutabilitet”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?
Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- let og mutabilitet
- Skalartyper
- Sammensatte typer
- Shadowing