Shadowing
Variablen neu binden
Shadowing ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.
Was ist Shadowing?
Shadowing bedeutet, eine neue Variable mit demselben Namen wie eine vorherige zu deklarieren. Die neue Bindung „überschattet“ die alte.
Dazu wiederholen Sie let mit demselben Namen.
fn main() {
let x = 5;
let x = x + 1;
let x = x * 2;
println!("x is {}", x);
}Shadowing ist keine Mutation
Shadowing erstellt eine völlig neue Variable. Es unterscheidet sich von mut, das dieselbe Variable wiederverwendet.
Da jedes let eine neue Bindung erzeugt, können die Werte sogar unterschiedliche Typen haben.
fn main() {
let y = 10; // immutable
let y = y + 5; // new binding, also immutable
println!("y is {}", y);
}Typen mit Shadowing ändern
Eine leistungsfähige Anwendung von Shadowing besteht darin, einen Namen wiederzuverwenden und dabei seinen Typ zu ändern.
Hier wird eine Zeichenkette unter demselben Namen in eine Zahl eingelesen.
fn main() {
let spaces = " ";
let spaces = spaces.len();
println!("count is {}", spaces);
}Warum mut den Typ nicht ändern kann
Mit mut können Sie den Wert ändern, aber nicht den Typ.
Dies würde zu einem Kompilierungsfehler führen:
let mut spaces = " ";spaces = spaces.len();— Typkonflikt.
Shadowing vermeidet dieses Problem, weil dabei eine neue Variable erstellt wird.
fn main() {
let mut count = 3;
count = 4; // ok, same type
println!("{}", count);
}Shadowing in inneren Gültigkeitsbereichen
Eine Variable kann innerhalb eines inneren Blocks überschattet werden. Wenn der Block endet, ist wieder die äußere Bindung sichtbar.
fn main() {
let n = 1;
{
let n = n * 10;
println!("inner {}", n);
}
println!("outer {}", n);
}Schrittweise umwandeln
Mit Shadowing können Sie einen Wert in mehreren Schritten umwandeln und dabei einen eindeutigen Namen beibehalten.
fn main() {
let input = "42";
let input: i32 = input.trim().parse().unwrap();
let input = input * 2;
println!("result {}", input);
}Shadowing bewahrt die Unveränderlichkeit
Jede überschattete Bindung bleibt unveränderlich. Nach einer Umwandlung behalten Sie die Sicherheit der Unveränderlichkeit, ohne neue Namen wie x2 oder x_temp erfinden zu müssen.
fn main() {
let price = 100;
let price = price - 20; // discount applied
let price = price + 5; // shipping added
println!("final price {}", price);
}Shadowing mit anderer Logik
Sie können den neuen Wert auf beliebige Weise berechnen, auch mithilfe von Funktionsaufrufen oder Ausdrücken.
fn main() {
let text = "hello";
let text = text.to_uppercase();
println!("{}", text);
}Verwirrung vermeiden
Shadowing ist praktisch, aber eine übermäßige Verwendung kann Leser verwirren. Verwenden Sie es, wenn jeder Schritt eine klare Umwandlung desselben Konzepts darstellt, nicht einfach, um Namen beliebig wiederzuverwenden.
fn main() {
let raw = " Rust ";
let raw = raw.trim(); // clean version
println!("[{}]", raw);
}Zusammenfassung: Shadowing vs. Neuzuweisung
Es gibt zwei Möglichkeiten, einem Namen einen neuen Wert zu geben:
- Shadowing: Erneut
let x = ...;— neue Variable, kann den Typ ändern und bleibt unveränderlich. - Neuzuweisung:
x = ...;mitmut— dieselbe Variable, derselbe Typ erforderlich.
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);
}Ein praktisches Beispiel
Das Einlesen und Konvertieren von Benutzerdaten ist ein klassischer Anwendungsfall für Shadowing: Der aussagekräftige Name age bleibt erhalten, während sich der Typ von Text zu Zahl ändert.
fn main() {
let age = "25";
let age: u32 = age.parse().unwrap();
let age = age + 1; // next birthday
println!("next year you will be {}", age);
}Kurztest
Entscheiden Sie, worin sich Shadowing von der Verwendung von mut unterscheidet.
Zusammenfassung
Shadowing in Rust:
- Wiederholen Sie
letmit demselben Namen, um eine neue Bindung zu erstellen. - Die neue Bindung kann einen anderen Typ haben.
- Jeder überschatte Wert bleibt unveränderlich.
- Shadowing unterscheidet sich von
mut, das dieselbe Variable verändert und ihren Typ beibehält.
fn main() {
let data = "100";
let data: i32 = data.parse().unwrap();
let data = data / 4;
println!("final {}", data);
}Häufig gestellte Fragen
Ist die Lektion „Shadowing“ kostenlos?
Ja — der vollständige Text von „Shadowing“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Shadowing“?
Variablen neu binden Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Learn Rust Coding zu starten?
Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Shadowing“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?
Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.