0Pricing
Learn Rust Coding · Lektion

Variablen, Veränderlichkeit und Shadowing

Verstehen Sie, wie Sie Variablen deklarieren, Veränderlichkeit verwalten und Shadowing für eine flexible Neudefinition von Variablen einsetzen.

Variablen, Veränderlichkeit und Shadowing ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. 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 3 Lektionen.

Einführung in Rust-Variablen

Willkommen! In Rust sind Variablen grundlegend für das Speichern von Daten. Sie sind wie beschriftete Boxen, in denen Sie Informationen aufbewahren, die Ihr Programm benötigt.

Rust legt großen Wert auf Sicherheit, und das beginnt damit, wie Variablen behandelt werden. Sie lernen, wie Sie Variablen deklarieren, ihre Änderbarkeit steuern und sie auf geschickte Weise „neu definieren“.

Variablen mit `let` deklarieren

Um in Rust eine Variable zu erstellen, verwenden wir das Schlüsselwort let. Dadurch wird einem Wert ein Name zugewiesen. Rust leitet den Typ häufig automatisch her, sodass Sie ihn nicht immer angeben müssen.

Führen Sie dieses einfache Beispiel aus:

fn main() {
  let apples = 5;
  println!("I have {} apples.", apples);
}

Rusts Standard: Unveränderlichkeit

Ein wichtiges Konzept in Rust ist, dass Variablen standardmäßig unveränderlich sind. Sobald Sie einer Variable einen Wert zugewiesen haben, können Sie ihn später nicht mehr ändern.

Das mag einschränkend wirken, hilft aber, Fehler zu vermeiden, und macht Ihren Code sicherer und leichter nachvollziehbar, besonders bei nebenläufiger Programmierung.

Variablen mit `mut` veränderlich machen

Wenn sich der Wert einer Variable ändern muss, können Sie sie ausdrücklich mit dem Schlüsselwort mut vor dem Variablennamen veränderlich machen.

Damit teilen Sie Rust und anderen Entwicklern mit, dass der Wert dieser Variable geändert werden soll.

fn main() {
  let mut score = 100;
  println!("Initial score: {}", score);

  score = 150; // We can change it now!
  println!("New score: {}", score);
}

Wann Sie `mut` verwenden sollten

Obwohl mut nützlich ist, sollten Sie es nur verwenden, wenn es notwendig ist. Bevorzugen Sie standardmäßig unveränderliche Variablen.

  • Verwenden Sie mut für Zähler, Zustandsvariablen oder Werte, die tatsächlich aktualisiert werden müssen.
  • Wenn sich ein Wert nach seiner ersten Zuweisung nie ändert, lassen Sie ihn unveränderlich (ohne mut).
  • Übersichtlichkeit: Die ausdrückliche Kennzeichnung einer Variable als mut macht die Absicht Ihres Codes klarer.

Konstanten mit `const` definieren

Konstanten sind besondere Arten unveränderlicher Variablen. Sie werden mit dem Schlüsselwort const statt let deklariert und müssen immer mit einer expliziten Typannotation versehen werden.

Konstanten können nur auf konstante Ausdrücke gesetzt werden, nicht auf das Ergebnis eines Funktionsaufrufs oder auf einen Wert, der erst zur Laufzeit berechnet werden kann.

fn main() {
  const MAX_USERS: u32 = 10_000; // Type annotation is required!
  println!("Max users allowed: {}", MAX_USERS);
}

`let`-Variablen und `const`-Konstanten im Vergleich

Hier sind die wichtigsten Unterschiede zwischen let-Variablen und const-Konstanten:

  • Veränderbarkeit: let-Variablen sind standardmäßig unveränderlich, können aber mit mut veränderlich gemacht werden. const-Konstanten sind immer unveränderlich.
  • Deklaration: Für let-Variablen wird let verwendet. Für const-Konstanten wird const verwendet.
  • Typannotation: Bei let-Variablen kann der Typ häufig hergeleitet werden. Bei const-Konstanten muss der Typ angegeben werden.
  • Gültigkeitsbereich: const-Konstanten können in jedem Gültigkeitsbereich deklariert werden, auch im globalen.

Shadowing kennenlernen

Rust erlaubt es Ihnen, eine neue Variable mit demselben Namen wie eine vorherige Variable zu deklarieren. Dies wird als Shadowing bezeichnet.

Die neue Variable „überschattet“ die alte, sodass nachfolgender Code den Wert der neuen Variable sieht. Die alte Variable existiert weiterhin im Speicher, kann aber nicht mehr direkt aufgerufen werden.

fn main() {
  let x = 5;
  println!("First x: {}", x); // Outputs 5

  let x = x + 1; // 'x' is shadowed by a new 'x'
  println!("Second x: {}", x); // Outputs 6

  { // Inner scope
    let x = x * 2; // 'x' is shadowed again
    println!("Inner x: {}", x); // Outputs 12
  }
  println!("Outer x: {}", x); // Outputs 6 (inner x is out of scope)
}

Shadowing zur Typumwandlung

Eine besonders nützliche Anwendung von Shadowing besteht darin, den Wert und sogar den Typ einer Variable umzuwandeln und dabei denselben Namen beizubehalten. Das ist üblich, wenn Sie eine Zeichenkette in eine Zahl umwandeln müssen.

Statt einen neuen Variablennamen zu erstellen (z. B. string_val und anschließend num_val), können Sie denselben Namen wiederverwenden.

fn main() {
  let spaces = "   ";
  println!("Spaces string: '{}'", spaces);

  // Shadow 'spaces' with a new variable that holds its length
  let spaces = spaces.len();
  println!("Spaces count: {}", spaces);
}

Schnelltest: Variablen und Veränderbarkeit

Betrachten Sie den folgenden Rust-Code. Welcher endgültige Wert von y wird in die Konsole ausgegeben?

Zusammenfassung: Variablen, Veränderbarkeit und Shadowing

Sehr gut! Sie haben die Grundlagen von Variablen in Rust gelernt:

  • Verwenden Sie let, um Variablen zu deklarieren, die standardmäßig unveränderlich sind.
  • Fügen Sie mut hinzu, um eine Variable veränderlich zu machen, sodass sich ihr Wert ändern kann.
  • Verwenden Sie const für Konstanten, die immer unveränderlich sind und Typannotationen erfordern.
  • Mit Shadowing können Sie eine neue Variable mit demselben Namen deklarieren und dadurch die vorherige ersetzen. Das ist für Typumwandlungen nützlich.

Als Nächstes sehen wir uns die verschiedenen primitiven Datentypen von Rust an!

Häufig gestellte Fragen

Ist die Lektion „Variablen, Veränderlichkeit und Shadowing“ kostenlos?

Ja — der vollständige Text von „Variablen, Veränderlichkeit und 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 3 Lektionen.

Was lerne ich in „Variablen, Veränderlichkeit und Shadowing“?

Verstehen Sie, wie Sie Variablen deklarieren, Veränderlichkeit verwalten und Shadowing für eine flexible Neudefinition von Variablen einsetzen. 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 1 von 3.

Wie lange dauert die Lektion „Variablen, Veränderlichkeit und 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.

Alle Lektionen in diesem Kurs

  1. Variablen, Veränderlichkeit und Shadowing
  2. Primitive Datentypen und Operatoren
  3. Funktionen und Kontrollfluss
← Zurück zu Learn Rust Coding