Typinferenz

Teil des Abschnitts Fundamentals der Rust-Journey von Coddy — Lektion 12 von 75.

In Rust ermöglicht die Typinferenz dem Compiler, den Typ einer Variablen basierend auf ihrem Wert und ihrer Verwendung automatisch abzuleiten. Das bedeutet, dass Sie den Typ beim Deklarieren einer Variablen oft nicht explizit angeben müssen, was Ihren Code prägnanter und leichter lesbar macht.

Zum Beispiel:

let x = 5;
// Rust leitet ab, dass x ein i32 ist

let y = 3.14;
// Rust leitet ab, dass y ein f64 ist

let message = "Hello, world!";
// Rust leitet ab, dass message ein &str (String) ist

let is_true = true;
// Rust leitet ab, dass is_true ein bool ist

In diesen Beispielen haben wir die Typen von x, y, message und is_true nicht angegeben. Der Rust-Compiler hat ihre Typen automatisch basierend auf den ihnen zugewiesenen Werten abgeleitet.

Typinferenz ist nicht nur praktisch, sondern hilft auch dabei, Fehler zu vermeiden. Der Compiler prüft, wie die Variablen verwendet werden, und stellt sicher, dass die abgeleiteten Typen im gesamten Code konsistent sind. Wenn ein Konflikt auftritt, erzeugt der Compiler eine Fehlermeldung.

Aufgabe

Anfänger

Schreibe ein Rust-Programm, das Typinferenz demonstriert. Deklariere und initialisiere die folgenden Variablen ohne explizite Typanmerkungen:

Eine Variable namens quantity mit dem Wert 10.
Eine Variable namens price mit dem Wert 99.99.
Eine Variable namens message mit dem Wert "Coddy is awesome!".
Eine Variable namens is_available mit dem Wert true.

Verwende nach der Deklaration dieser Variablen println!(), um ihre Werte auf der Konsole auszugeben. Beobachte, wie Rust die Typen dieser Variablen basierend auf ihren Werten ableitet.

Spickzettel

Die Typinferenz von Rust ermöglicht es dem Compiler, Variablentypen basierend auf ihren Werten automatisch abzuleiten, wodurch explizite Typanmerkungen in vielen Fällen überflüssig werden.

let x = 5;        // Rust leitet i32 ab
let y = 3.14;     // Rust leitet f64 ab
let message = "Hello, world!";  // Rust leitet &str ab
let is_true = true;  // Rust leitet bool ab

Der Compiler prüft die Verwendung von Variablen, um die Typkonsistenz sicherzustellen, und erzeugt Fehler, wenn Konflikte auftreten.

Probier es selbst

fn main() {
    // Variablen hier deklarieren
    
    
    // Die Werte ausgeben
    println!("Quantity: {}", quantity);
    println!("Price: {}", price);
    println!("Message: {}", message);
    println!("Is available: {}", is_available);
}