Rust Anfänger 25 min

Variablen & Datentypen

Variablen in Rust sind standardmaessig unveraenderbar. Lerne let, mut, Shadowing und die primitiven Typen von Rust.

Aktualisiert:
Inhaltsverzeichnis

Variablen & Datentypen in Rust

Rust hat ein paar Eigenarten bei Variablen, die dich am Anfang ueberraschen werden - aber sie sind der Grund, warum Rust so wenig Fehler zulaesst.

Variablen sind standardmaessig unveraenderbar

let x = 5;
x = 6; // FEHLER! cannot assign twice to immutable variable `x`

Das ist Absicht. Wenn der Compiler weiss, dass sich ein Wert nicht aendert, kann er staerkere Garantien geben und oft besseren Code erzeugen.

mut fuer veraenderbare Variablen

Wenn du eine Variable aendern willst, musst du das explizit sagen:

let mut x = 5;
x = 6; // OK
println!("{}", x); // 6

Dieser kleine Unterschied macht deine Absicht beim Lesen des Codes sofort klar.

Konstanten

const ist nicht dasselbe wie let. Konstanten:

  • haben einen expliziten Typ
  • sind zur Kompilierzeit bekannt
  • werden SCREAMING_SNAKE_CASE benannt
const MAX_PUNKTE: u32 = 100_000;

Shadowing

Du kannst let mehrfach mit demselben Namen verwenden. Das nennt sich Shadowing - die alte Variable wird “ueberschattet”:

let x = 5;
let x = x + 1;     // x ist jetzt 6
let x = x * 2;     // x ist jetzt 12
println!("x = {}", x); // x = 12

Das ist etwas anderes als mut! Bei Shadowing entsteht eine neue Variable - der Typ darf sich sogar aendern:

let wert = "42";               // &str
let wert: i32 = wert.parse().unwrap(); // i32

Die primitiven Datentypen

Ganzzahlen

Rust hat vorzeichenbehaftete (i) und vorzeichenlose (u) Integer in verschiedenen Groessen:

TypBereich
i8-128 bis 127
i16-32768 bis 32767
i32ca. -2 Mrd. bis 2 Mrd. (Default)
i64sehr gross
u80 bis 255
u320 bis ca. 4 Mrd.
usizeso breit wie dein System (32/64 Bit)
let alter: u32 = 28;
let temperatur: i16 = -5;
let million = 1_000_000; // Default ist i32

Fliesskommazahlen

Zwei Varianten: f32 und f64 (Default - doppelte Genauigkeit).

let pi = 3.14159;       // f64
let kleiner: f32 = 0.5; // f32

Booleans

let aktiv = true;
let fertig: bool = false;

Character

Ein einzelnes Unicode-Zeichen in einfachen Anfuehrungszeichen, 4 Bytes gross:

let buchstabe = 'R';
let emoji = '🦀';

Wichtig: Strings ("Text") sind kein char! Das lernen wir gleich.

Tupel

Feste Sammlung verschiedener Typen:

let person: (String, i32, bool) = ("Anna".to_string(), 28, true);
let name = &person.0;  // Zugriff per Index
let alter = person.1;

// Oder destrukturieren:
let (name, alter, aktiv) = person;

Arrays

Feste Groesse, alle Elemente gleicher Typ:

let zahlen: [i32; 5] = [1, 2, 3, 4, 5];
let nullen = [0; 10]; // 10 Nullen
println!("{}", zahlen[0]); // 1

Fuer eine veraenderbare Liste nimmst du stattdessen Vec<T> (lernen wir spaeter).

Strings - kurze Vorschau

In Rust gibt es zwei wichtige String-Typen:

let gruss: &str = "Hallo";                // String-Slice
let name: String = String::from("Rust");  // besitzter String
let voll = format!("{}, {}!", gruss, name); // "Hallo, Rust!"

Warum zwei Typen? Das haengt mit Ownership zusammen - dazu spaeter mehr.

Typ-Inferenz

Du musst Typen selten angeben. Der Compiler leitet sie meistens aus dem Kontext ab:

let alter = 28;        // i32 (Default)
let pi = 3.14;         // f64 (Default)
let aktiv = true;      // bool
let name = "Anna";     // &str

Explizite Typen brauchst du, wenn:

  • Der Compiler sie nicht herleiten kann (z.B. bei parse())
  • Du einen anderen Typ willst als den Default
  • Du deinen Code dokumentieren willst

Uebersicht

  • let = unveraenderbar (Default)
  • let mut = veraenderbar
  • const = zur Kompilierzeit bekannt, mit expliziter Typangabe
  • Shadowing erlaubt Mehrfach-let und Typwechsel
  • Rust hat praezise Integer-Typen (i8..i64, u8..u64)
  • Arrays haben feste Groesse, Vec ist flexibel

Im naechsten Kapitel: Kontrollstrukturen wie if, else und Schleifen.

Zurück zum Rust Kurs