In Rust gibt es streng genommen keine Variablen im Sinne anderer Sprachen — es gibt Bindungen. Eine Bindung verknüpft einen Namen mit einem Wert, und sie ist standardmäßig unveränderlich. Wer schreiben möchte, muss das mit mut explizit erlauben. Wer den Typ wechseln will, nutzt Shadowing. Wer zur Compile-Zeit bekannte Werte ausdrücken will, nimmt const oder static. Dieses Kapitel arbeitet die sechs Konzepte nacheinander durch, immer mit dem Blick darauf, wie sie später mit Ownership und Lifetimes zusammenspielen.

01 · Abschnitt

Worum geht es in diesem Kapitel?

Rust dreht ein paar Default-Entscheidungen anderer Sprachen um. JavaScript, Python, Java, C++ — alle erlauben standardmäßig Mutation. Rust verbietet sie standardmäßig. Das ist mehr als eine syntaktische Macke; es ist ein zentrales Werkzeug, mit dem der Borrow Checker später nachweisen kann, welche Code-Pfade Daten verändern und welche nicht.

Die sechs Artikel dieses Kapitels führen Schritt für Schritt durch das Bindungs-Modell:

  • let-Bindung — warum let eine Bindung und keine Variable ist, was Pattern-Bindings sind und warum eine Bindung erst nach Initialisierung verwendet werden darf.
  • mut und Immutability — wie mut funktioniert, was Immutability genau verbietet und welche Stolperfallen es bei mut als Pattern, bei &mut und bei Interior Mutability gibt.
  • Shadowing — eine neue Bindung mit altem Namen anzulegen, ist in Rust ein eigenes Konzept. Es erlaubt sogar Typ-Wechsel — etwas, was mut nicht kann.
  • const vs. static — zwei Wege, zur Compile-Zeit feste Werte auszudrücken. Mit unterschiedlichen Speicher-Modellen und unterschiedlichen Anwendungsfällen.
  • Type Inference — wie der Compiler in 90 % aller Fälle den Typ selbst errät, wann er es nicht kann und wie der Turbofish (::<T>) hilft.
  • Scoping und Blocks — jede Schweifklammer eröffnet einen neuen Scope, und jeder Block ist gleichzeitig eine Expression. Die Drop-Reihenfolge ergibt sich daraus.

Warum ist das wichtig?

Drei Gründe, weshalb dieses Kapitel kein „Detail-Thema" ist, das man überspringen darf:

  • Ownership und Borrowing bauen darauf auf. Der Borrow Checker prüft, wer wann lesen oder schreiben darf — eine Bindung ohne mut ist eine harte Grenze, die er ausnutzt, um Aliasing-Konflikte zu vermeiden.
  • Idiomatische Rust-Patterns entstehen direkt aus dem Bindungs-Modell: Funktionen, die &T nehmen statt &mut T, geben Aufrufern Sicherheit. let-Shadowing nach Parsing ist Standard-Pattern in jedem CLI-Tool.
  • Fehlermeldungen werden lesbar, sobald man die Unterscheidung zwischen Bindung, Wert, Referenz und Mutabilität internalisiert hat. Die häufigsten Anfänger-Fehler in Kapitel 7 (Ownership) sind in Wirklichkeit Bindungs-Fehler aus Kapitel 2.
02 · Abschnitt

Was du nach diesem Kapitel kannst

  • let-Bindungen mit und ohne Type-Annotation anlegen und das Pattern-Binding (let (a, b) = ...) für Tupel und Structs nutzen.
  • mut korrekt einsetzen und den Unterschied zu &mut und Interior Mutability benennen.
  • Shadowing gezielt einsetzen — etwa um nach parse() den Typ von String zu i32 zu wechseln, ohne einen neuen Bezeichner zu erfinden.
  • Zwischen const und static situationsabhängig entscheiden und beide korrekt deklarieren.
  • Den Default-Typ in Inferenz-Situationen (i32, f64) verstehen und mit Turbofish gezielt eingreifen.
  • Drop-Reihenfolge und Block-Scope mental nachzeichnen — die Basis für späteres Verständnis von RAII-Patterns mit MutexGuard, File oder eigenen RAII-Typen.

Im nächsten Kapitel geht es um primitive Datentypen: Integer-Familien, Floats, bool, char, Tupel, Arrays und Slices.

Weiterführende Ressourcen

Externe Quellen

/ Weiter

Zurück zu Variablen & Bindungen

Zur Übersicht