Skuggning
Binda om variabler
Skuggning är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 4 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.
Vad är skuggning?
Skuggning innebär att en ny variabel deklareras med samma namn som en tidigare variabel. Den nya bindningen ”skuggar” den gamla.
Det gör ni genom att upprepa let med samma namn.
fn main() {
let x = 5;
let x = x + 1;
let x = x * 2;
println!("x is {}", x);
}Skuggning är inte mutation
Skuggning skapar en helt ny variabel. Det skiljer sig från mut, som återanvänder samma variabel.
Eftersom varje let skapar en ny bindning kan värdena till och med ha olika typer.
fn main() {
let y = 10; // immutable
let y = y + 5; // new binding, also immutable
println!("y is {}", y);
}Ändra typer med skuggning
En kraftfull användning av skuggning är att återanvända ett namn samtidigt som typen ändras.
Här parsas en sträng till ett tal under samma namn.
fn main() {
let spaces = " ";
let spaces = spaces.len();
println!("count is {}", spaces);
}Varför mut inte kan ändra typen
Med mut kan ni ändra värdet men inte typen.
Detta skulle inte gå att kompilera:
let mut spaces = " ";spaces = spaces.len();— fel på grund av typkonflikt.
Skuggning undviker detta eftersom den skapar en ny variabel.
fn main() {
let mut count = 3;
count = 4; // ok, same type
println!("{}", count);
}Skuggning i inre block
En variabel kan skuggas i ett inre block. När blocket avslutas blir den yttre bindningen synlig igen.
fn main() {
let n = 1;
{
let n = n * 10;
println!("inner {}", n);
}
println!("outer {}", n);
}Transformera steg för steg
Med skuggning kan ni transformera ett värde i flera steg och samtidigt behålla ett tydligt namn.
fn main() {
let input = "42";
let input: i32 = input.trim().parse().unwrap();
let input = input * 2;
println!("result {}", input);
}Skuggning bevarar oföränderlighet
Varje skuggad bindning förblir oföränderlig. Efter en transformation behåller ni säkerheten hos oföränderlighet utan att behöva hitta på nya namn som x2 eller x_temp.
fn main() {
let price = 100;
let price = price - 20; // discount applied
let price = price + 5; // shipping added
println!("final price {}", price);
}Skuggning med annan logik
Ni kan beräkna det nya värdet på valfritt sätt, bland annat med funktionsanrop eller uttryck.
fn main() {
let text = "hello";
let text = text.to_uppercase();
println!("{}", text);
}Undvik förvirring
Skuggning är praktiskt, men överdriven användning kan förvirra läsaren. Använd det när varje steg är en tydlig transformation av samma koncept, inte bara för att återanvända namn på måfå.
fn main() {
let raw = " Rust ";
let raw = raw.trim(); // clean version
println!("[{}]", raw);
}Sammanfattning: skuggning jämfört med tilldelning
Två sätt att ge ett namn ett nytt värde:
- Skuggning:
let x = ...;igen — en ny variabel som kan byta typ och förblir oföränderlig. - Ny tilldelning:
x = ...;medmut— samma variabel, och samma typ krävs.
fn main() {
let val = "7";
let val: i32 = val.parse().unwrap(); // shadow + type change
let mut val = val;
val += 1; // reassign, same type
println!("{}", val);
}Ett praktiskt exempel
Att läsa och konvertera användardata är ett klassiskt användningsområde för skuggning: behåll det meningsfulla namnet age medan typen ändras från text till tal.
fn main() {
let age = "25";
let age: u32 = age.parse().unwrap();
let age = age + 1; // next birthday
println!("next year you will be {}", age);
}Snabbtest
Avgör vad som skiljer skuggning från att använda mut.
Sammanfattning
Skuggning i Rust:
- Upprepa
letmed samma namn för att skapa en ny bindning. - Den nya bindningen kan ha en annan typ.
- Varje skuggat värde förblir oföränderligt.
- Det skiljer sig från
mut, som ändrar samma variabel och behåller dess typ.
fn main() {
let data = "100";
let data: i32 = data.parse().unwrap();
let data = data / 4;
println!("final {}", data);
}
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 ”Skuggning” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Skuggning”, 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 ”Skuggning”?
Binda om variabler 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 4 av 4.
Hur lång tid tar lektionen ”Skuggning”?
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.