Lektionen des Moduls (1/2)
Variablen und Veränderbarkeit
In Rust wird die Verwaltung von Variablen und Speicher von zwei Grundprinzipien geleitet: Sicherheit und Kontrolle. Aus diesem Grund sind Variablen in Rust im Gegensatz zu vielen anderen Programmiersprachen standardmäßig unveränderlich (immutable).
Das bedeutet, dass ein einmal einer Variablen zugewiesener Wert nicht mehr geändert werden kann. Wenn Sie versuchen, dies zu tun, erzeugt der Compiler einen Fehler.
Unveränderliche Variablen und das Schlüsselwort mut
Um eine Variable zu deklarieren, wird das Schlüsselwort let verwendet:
let x = 5; // Immutabile di default
// x = 6; // ERRORE! Il compilatore si rifiuterà di compilare.
Wenn Sie den Wert einer Variablen ändern müssen, müssen Sie sie explizit veränderlich (mutable) machen, indem Sie das Schlüsselwort mut direkt nach let verwenden:
let mut y = 10; // Mutabile
println!("Il valore di y e: {}", y);
y = 15; // Valido!
println!("Il valore modificato di y e: {}", y);
Die Verwendung des Präfix mut teilt dem Compiler und dem Leser des Codes klar mit, dass sich dieser Wert im Laufe der Ausführung ändern wird.
Shadowing (Variablenbeschattung)
Rust erlaubt auch das Konzept des Shadowing (Beschattung), d. h. die erneute Deklaration einer Variablen mit demselben Namen unter erneuter Verwendung des Schlüsselworts let. Die neue Variable "deckt" die vorherige ab (oder stellt sie in den Schatten):
let x = 5;
let x = x + 1; // Shadowing: x ora vale 6
let x = x * 2; // Shadowing: x ora vale 12
Im Unterschied zu mut ermöglicht Ihnen das Shadowing:
- Den Datentyp einer Variablen zu ändern, während der gleiche Name beibehalten wird.
- Die Unveränderlichkeit der Variablen nach den Transformationen beizubehalten.
let spaces = " "; // Tipo: &str (stringa)
let spaces = spaces.len(); // Tipo: usize (numero intero)
Nutzen von Shadowing und Scopes (Gültigkeitsbereiche)
Shadowing ist nicht auf denselben Block beschränkt; es kann innerhalb verschachtelter Blöcke ({}) verwendet werden, um einen Wert vorübergehend zu überschreiben. Wenn der innere Block endet, wird die ursprüngliche Variable wieder sichtbar:
let x = 5;
{
let x = x * 2; // Shadowing valido solo all'interno del blocco
println!("Valore nel blocco interno: {}", x); // Stampa 10
}
println!("Valore nel blocco esterno: {}", x); // Stampa 5
Dieser Mechanismus ist äußerst sicher und effizient, da er vollständig zur Compilezeit stattfindet und Typsicherheit ohne jegliche Leistungskosten zur Laufzeit garantiert.
Probiere es aus
Deklarieren Sie eine veränderliche Variable namens x mit dem Anfangswert 5. Addieren Sie anschließend 10 zu x und geben Sie sie unter Verwendung des println!-Makros auf dem Bildschirm aus.
Hinweis anzeigen
Deklarieren Sie die Variable mit `let mut x = 5;`, erhöhen Sie sie dann mit `x += 10;` (oder `x = x + 10;`) und geben Sie sie schließlich mit `println!('{}', x);` aus.
Lösung nach 3 Versuchen verfügbar
Deklarieren Sie eine unveränderliche Variable y mit dem Wert 10. Führen Sie Shadowing für y durch, indem Sie sie erneut mit let deklarieren, um ihren vorherigen Wert mit 2 zu multiplizieren, und geben Sie sie schließlich mit println! aus.
Hinweis anzeigen
Verwenden Sie `let y = 10;`, führen Sie dann ein Shadowing durch, indem Sie sie erneut mit `let y = y * 2;` deklarieren, und verwenden Sie schließlich `println!`, um sie anzuzeigen.
Lösung nach 3 Versuchen verfügbar
Deklarieren Sie eine unveränderliche Variable input, die den String-Wert "42" enthält. Führen Sie ein Shadowing von input durch, indem Sie sie als Ganzzahl vom Typ i32 deklarieren und den ursprünglichen Wert mittels input.parse::<i32>().unwrap() konvertieren. Geben Sie sie schließlich unter Verwendung des println!-Makros aus.
Hinweis anzeigen
Deklarieren Sie `let input = "42";`, führen Sie dann das Shadowing mit `let input: i32 = input.parse().unwrap();` durch und geben Sie sie mit `println!("{}", input);` aus.
Lösung nach 3 Versuchen verfügbar