Variablen in Rust

Eine Variable ist einfach ein Name, den du einem Wert gibst, damit du ihn später verwenden kannst. Stell sie dir wie eine beschriftete Kiste vor: Du legst etwas hinein, schreibst einen Namen darauf und sprichst sie über diesen Namen an, statt den Wert überall zu wiederholen.

Eine Variable anlegen

In Rust legst du eine Variable mit dem Schlüsselwort let an:

fn main() {
    let age = 30;
    println!("Ich bin {age} Jahre alt");
}

Ausgabe:

Ich bin 30 Jahre alt

▶ Selbst ausprobieren

Schauen wir uns die Zeile genauer an:

• let – sagt Rust: „Ich lege eine neue Variable an.“
• age – der Name, den wir gewählt haben.
• = – weist den Wert rechts dem Namen links zu.
• 30 – der Wert, den wir speichern.

Das {age} in println! gibt den Wert der Variable aus. Das nennt man String-Interpolation: Rust ersetzt {age} durch das, was gerade in age steckt.

Rust findet den Typ selbst heraus

Jeder Wert in Rust hat einen Typ (eine ganze Zahl, Text, true/false und so weiter). Vielleicht erwartest du, dass du diesen Typ angeben musst. Meistens ist das aber nicht nötig: Rust schaut sich den Wert an und erkennt den Typ selbst. Das nennt man Typinferenz.

fn main() {
    let score = 95;        // Rust erkennt: eine ganze Zahl
    let name = "Ferris";   // Rust erkennt: Text
    let is_active = true;  // Rust erkennt: ein Boolean
    println!("{name}: {score}, aktiv = {is_active}");
}

Ausgabe:

Ferris: 95, aktiv = true

▶ Selbst ausprobieren

Wenn du den Typ ausdrücklich angeben willst, schreibst du ihn nach einem Doppelpunkt:

let score: i32 = 95; // i32 = eine 32-Bit-Ganzzahl

Hinweis

i32 bedeutet einfach „eine ganze Zahl, die in 32 Bit passt“. Über die genauen Typen musst du dir jetzt noch keine Gedanken machen – die behandeln wir ausführlich bei den Datentypen. Fürs Erste ist es völlig in Ordnung, Rust den Typ erkennen zu lassen.

Variablen sind standardmäßig unveränderbar

Jetzt kommt der Teil, der viele überrascht, die von anderen Sprachen kommen: Wenn du in Rust einer Variable einen Wert gegeben hast, kannst du ihn standardmäßig nicht mehr ändern. „Unveränderbar“ (immutable) heißt genau das: Kann nicht geändert werden.

Dieser Code lässt sich nicht kompilieren:

fn main() {
    let count = 1;
    count = 2; // ❌ Fehler: unveränderbare Variable kann nicht zweimal zugewiesen werden
    println!("{count}");
}

Der Compiler stoppt dich mit einer klaren Meldung:

error[E0384]: cannot assign twice to immutable variable `count`

Auf Deutsch: Du kannst einer unveränderbaren Variable count nicht zweimal einen Wert zuweisen.

Warum macht eine Sprache so etwas absichtlich? Weil viele Bugs entstehen, wenn sich Werte ändern, obwohl du das nicht erwartest. Wenn Werte nur dann veränderbar sind, wenn du das ausdrücklich willst, wird dein Code vorhersehbarer. Das ist eine Stärke, keine Einschränkung.

Eine Variable mit mut veränderbar machen

Wenn sich ein Wert wirklich ändern soll, fügst du das Schlüsselwort mut hinzu (kurz für mutable = veränderbar):

fn main() {
    let mut count = 1;
    println!("Vorher: {count}");

    count = 2; // ✅ jetzt erlaubt, wegen `mut`
    println!("Nachher: {count}");
}

Ausgabe:

Vorher: 1
Nachher: 2

▶ Selbst ausprobieren

Tipp

Eine gute Gewohnheit: Fang ohne mut an. Füg es erst hinzu, wenn der Compiler meckert, weil du einen Wert ändern willst. So bleiben deine Variablen unveränderbar, solange sie sich nicht wirklich ändern müssen.

Shadowing: denselben Namen wiederverwenden

In Rust kannst du eine neue Variable mit demselben Namen wie eine alte anlegen. Das nennt man Shadowing (Verschatten): Die neue Variable „wirft einen Schatten“ auf die alte.

fn main() {
    let x = 5;
    let x = x + 1;   // ein neues x, basierend auf dem alten x -> 6
    let x = x * 2;   // noch ein neues x -> 12
    println!("x ist {x}");
}

Ausgabe:

x ist 12

▶ Selbst ausprobieren

Das sieht ähnlich aus wie mut, ist aber etwas anderes:

• mut ändert den Wert derselben Variable.
• Shadowing legt eine komplett neue Variable an, die zufällig denselben Namen hat – sie kann sogar einen anderen Typ haben.

Shadowing ist praktisch, wenn du einen Wert umwandeln, aber den Namen behalten willst:

fn main() {
    let spaces = "   ";        // Text
    let spaces = spaces.len(); // jetzt eine Zahl (wie viele Leerzeichen)
    println!("Anzahl der Leerzeichen: {spaces}");
}

Ausgabe:

Anzahl der Leerzeichen: 3

▶ Selbst ausprobieren

Konstanten

Eine Konstante ist ein Wert, der sich nie ändert und schon beim Kompilieren feststeht. Du legst sie mit const statt let an, und du musst den Typ angeben:

const MAX_SCORE: u32 = 100;

fn main() {
    println!("Die höchste Punktzahl ist {MAX_SCORE}");
}

Ausgabe:

Die höchste Punktzahl ist 100

▶ Selbst ausprobieren

Konstanten schreibt man nach Konvention in UPPER_SNAKE_CASE. So unterscheiden sie sich von normalen Variablen:

	let-Variable	const-Konstante
Veränderbar?	Nur mit mut	Nie
Typ nötig?	Optional (wird erkannt)	Pflicht
Namensstil	snake_case	UPPER_SNAKE_CASE
Wo erlaubt	In Funktionen	Überall, auch außerhalb von Funktionen

Nimm eine Konstante für Werte, die wirklich feststehen – etwa die Anzahl der Sekunden in einer Minute oder eine Obergrenze.

Regeln für Namen

• Verwende snake_case – kleingeschriebene Wörter, verbunden mit Unterstrichen: user_name, total_price.
• Namen dürfen Buchstaben, Ziffern und Unterstriche enthalten, aber nicht mit einer Ziffer beginnen.
• Wähle aussagekräftige Namen: age ist besser als a.

Häufige Fehler

• mut vergessen, obwohl du einen Wert ändern willst → cannot assign twice to immutable variable.
• Eine Variable verwenden, bevor du sie angelegt hast → das let muss zuerst kommen.
• Unbenutzte Variablen erzeugen eine Warnung. Wenn das Absicht ist, stell dem Namen einen Unterstrich voran: let _unused = 5;.

Übungen

1. Level-up

Lege eine Variable level an, die bei 1 startet. Gib sie aus, erhöhe sie zweimal um 1 und gib sie nach jeder Änderung aus. So erhältst du Level 1, Level 2, Level 3. Tipp: Ein Wert, der sich ändert, braucht mut, und level = level + 1; zählt eins dazu.

Lösung anzeigen

fn main() {
    let mut level = 1;
    println!("Level {level}");

    level = level + 1;
    println!("Level {level}");

    level = level + 1;
    println!("Level {level}");
}

Ausgabe:

Level 1
Level 2
Level 3

▶ Selbst ausprobieren

2. Minuten in Sekunden

Lege eine Konstante SECONDS_PER_MINUTE mit dem Wert 60 an. Beginne mit let time = 5; (in Minuten). Verwende dann Shadowing, damit time dieselbe Dauer in Sekunden enthält, und gib Das sind 300 Sekunden aus. Tipp: Das neue time kann aus dem alten berechnet werden: let time = time * ...;.

Lösung anzeigen

const SECONDS_PER_MINUTE: u32 = 60;

fn main() {
    let time = 5; // Minuten
    let time = time * SECONDS_PER_MINUTE; // ein neues `time`, jetzt in Sekunden
    println!("Das sind {time} Sekunden");
}

Ausgabe:

Das sind 300 Sekunden

▶ Selbst ausprobieren

Kein mut nötig: Das zweite let legt eine ganz neue Variable an, die den Namen wiederverwendet. Rust erkennt hier außerdem, dass time ein u32 ist, weil es mit der u32-Konstante multipliziert wird.

Zusammenfassung

• Lege Variablen mit let an; Rust erkennt den Typ meistens selbst.
• Variablen sind standardmäßig unveränderbar – mit mut erlaubst du Änderungen.
• Shadowing deklariert einen Namen mit let neu und erzeugt so eine neue Variable (auch mit anderem Typ).
• Konstanten (const) ändern sich nie, brauchen immer einen Typ und werden in UPPER_SNAKE_CASE geschrieben.

Kurzer Check

Kurzer Check

1. Kannst du einer let-Variable in Rust standardmäßig einen neuen Wert zuweisen?

Ja, immer Nein – nur wenn sie mit mut deklariert ist Nur wenn es eine Zahl ist

2. Was ist Shadowing in Rust?

Mit let eine neue Variable anlegen, die einen vorhandenen Namen wiederverwendet Eine Variable vor anderen Funktionen verstecken Eine Variable privat machen

3. Welche Namenskonvention verwenden Rust-Variablen laut dieser Seite?

camelCase PascalCase snake_case

Punkte: 0 / 3

Weiterlesen

• Variablen und Veränderbarkeit – Die Programmiersprache Rust: das offizielle Kapitel zu let, mut und Konstanten – und warum Unveränderbarkeit der Standard ist.
• Verschatten (Shadowing) – Die Programmiersprache Rust: mehr dazu, wie sich Shadowing von mut unterscheidet, auch beim Wechsel des Typs.
• Variable Bindings – Rust by Example (auf Englisch): kurze lauffähige Beispiele, mit Fortsetzungen zu Veränderbarkeit und Scope und Shadowing.
• Constants – Rust by Example (auf Englisch): const (und sein Verwandter static) in einem kleinen Programm.
• Schlüsselwort let – Doku der Standardbibliothek (auf Englisch): alles, was let kann – wenn du das ganze Bild sehen willst.