Learn Rust Coding · Lektion

let und Mutabilität

Bindings und mut

let und Mutabilität ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Werte mit let binden

In Rust erstellen Sie mit dem Schlüsselwort let eine Variable. Dadurch wird ein Name an einen Wert gebunden.

Standardmäßig ist jede Bindung unveränderlich — sobald Sie ihr einen Wert zuweisen, können Sie ihn nicht mehr ändern.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

Standardmäßig unveränderlich

Rust macht Variablen bewusst unveränderlich. Dadurch werden versehentliche Änderungen verhindert und der Code leichter nachvollziehbar.

Der Versuch, eine unveränderliche Bindung neu zuzuweisen, führt zu einem Kompilierfehler, nicht zu einem Absturz zur Laufzeit.

let x = 5; und anschließend x = 6; lässt sich nicht kompilieren.

fn main() {
    let x = 5;
    // x = 6; // this would cause a compile error
    println!("x stays {}", x);
}

Variablen veränderlich machen

Wenn Sie einen Wert ändern müssen, fügen Sie das Schlüsselwort mut hinzu. Dadurch wird die Bindung als veränderlich gekennzeichnet.

Nun können Sie ihr beliebig oft einen neuen Wert zuweisen.

fn main() {
    let mut count = 0;
    count = count + 1;
    count += 1;
    println!("count is {}", count);
}

Typinferenz

Rust ermittelt den Typ einer Variable normalerweise anhand ihres Werts. Dies wird als Typinferenz bezeichnet.

let x = 5; weist x automatisch den Typ i32 zu.

fn main() {
    let n = 42;      // inferred as i32
    let pi = 3.14;   // inferred as f64
    println!("{} and {}", n, pi);
}

Typannotationen

Sie können den Typ auch explizit mit einem Doppelpunkt und einem Typnamen angeben. Dies wird als Typannotation bezeichnet.

Annotationen sind nützlich, wenn der Compiler den Typ nicht ableiten kann, oder dienen der Klarheit.

fn main() {
    let age: u32 = 30;
    let price: f64 = 9.99;
    println!("age {} price {}", age, price);
}

Konstanten

Ein const-Wert ist immer unveränderlich und muss eine Typannotation besitzen. Sein Wert muss zur Kompilierzeit bekannt sein.

Konstanten werden nach Konvention in SCREAMING_SNAKE_CASE geschrieben.

fn main() {
    const MAX_POINTS: u32 = 100_000;
    println!("Max is {}", MAX_POINTS);
}

const vs let

Wichtige Unterschiede zwischen const und let:

const kann niemals mut sein.
const erfordert eine Typannotation.
const muss ein konstanter Ausdruck zur Kompilierzeit sein.
let-Werte können zur Laufzeit berechnet werden.

fn main() {
    const SECONDS_PER_HOUR: u32 = 60 * 60;
    let hours = 3;
    println!("{} seconds", SECONDS_PER_HOUR * hours);
}

Ändern in einer Schleife

Veränderliche Variablen kommen häufig in Schleifen vor, in denen sich ein Wert nach und nach ansammelt.

Hier summieren wir Zahlen mithilfe eines mut-Akkumulators.

fn main() {
    let mut total = 0;
    for i in 1..=5 {
        total += i;
    }
    println!("Sum is {}", total);
}

Unterstrich für ungenutzte Bindungen

Wenn Sie einen Wert binden, ihn aber nie verwenden, gibt Rust eine Warnung aus. Stellen Sie dem Namen einen Unterstrich voran, um die Warnung zu unterdrücken.

let _unused = 10; teilt dem Compiler mit, dass dies beabsichtigt ist.

fn main() {
    let _temp = 99;
    let used = 1;
    println!("{}", used);
}

Mehrere Bindungen

Sie können mehrere Variablen in separaten Zeilen deklarieren, jeweils mit einem eigenen let.

Jede Bindung ist unabhängig und unveränderlich, sofern sie nicht mit mut gekennzeichnet wird.

fn main() {
    let name = "Rust";
    let year = 2010;
    let mut version = 1;
    version += 1;
    println!("{} born {} v{}", name, year, version);
}

Warum Unveränderlichkeit hilfreich ist

Unveränderlichkeit ist eine Sicherheitsfunktion. Wenn der Compiler weiß, dass sich ein Wert nicht ändern kann, kann er stärkere Garantien geben und ganze Klassen von Fehlern verhindern.

Verwenden Sie mut nur dann, wenn Sie eine Veränderung tatsächlich benötigen.

fn main() {
    let config = "production";
    // config is guaranteed not to change
    println!("Running in {}", config);
}

Schnelltest

Welches Schlüsselwort macht eine Rust-Variable veränderlich?

Zusammenfassung

Sie haben die Grundlagen von Bindungen in Rust gelernt:

let bindet einen Namen an einen Wert, standardmäßig unveränderlich.
mut macht eine Bindung veränderlich.
Rust leitet Typen ab, Sie können jedoch mit : Annotationen hinzufügen.
const gilt zur Kompilierzeit, ist immer unveränderlich und benötigt einen Typ.

fn main() {
    let mut score: u32 = 0;
    const BONUS: u32 = 10;
    score += BONUS;
    println!("Final score: {}", score);
}

Häufig gestellte Fragen

Ist die Lektion „let und Mutabilität“ kostenlos?

Ja — der vollständige Text von „let und Mutabilität“ 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 „let und Mutabilität“?

Bindings und mut 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 4.

Wie lange dauert die Lektion „let und Mutabilität“?

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

← Zurück zu Learn Rust Coding