Rust bringt eine umfangreiche Sammlung von Primitivtypen (Primitives) mit, unterteilt in zwei große Gruppen: Skalartypen und Verbundtypen.
(1) Skalartypen (Scalar Types)
Sie repräsentieren einen einzelnen eigenständigen Wert, es gibt insgesamt 6 Arten:
- Ganzzahl mit Vorzeichen :
i8,i16,i32,i64,i128,isize(Größe angepasst an Systemzeigergröße) - Ganzzahl ohne Vorzeichen :
u8,u16,u32,u64,u128,usize(Größe angepasst an Systemzeigergröße) - Gleitkommatypen :
f32,f64 - Zeichentyp char : Speichert Unicode-Skalarwerte (z.B.
'a','α','∞'), jedes Zeichen belegt 4 Byte - Bool-Typ bool : nur zwei Werte möglich
true,false - Einheitstyp () : sein einziger Wert ist das leere Tupel
(). Obwohl es wie ein Tupel aussieht, enthält es nur einen einzigen Wert und zählt daher nicht zu den Verbundtypen.
(2) Verbundtypen (Compound Types) (wird am Ende gelernt)
Bestehen aus mehreren kombinierten Werten:
- Array : Beispiel
[1, 2, 3] - Tupel : Beispiel
(1, true)
1) Möglichkeiten zur Typannotierung von Variablen
Jeder Variable kann manuell ein Typ zugewiesen werden. Numerische Typen unterstützen zusätzlich Typ-Suffixe; ohne Annotation wird ein Standardtyp verwendet:
- Standard für Ganzzahlen:
i32 - Standard für Gleitkommazahlen:
f64
Rust kann zudem anhand des Code-Kontexts den Typ automatisch ableiten.
2) Variablentypen
1. Explizite Typangabe
Gib direkt nach dem Variablennamen mit : Typ den Typ an, funktioniert für alle Variablen.
fn main() {
let isOpen: bool = true;
let price: f64 = 1.0;
}Code-Sprache: JavaScript (javascript)Im obigen Beispiel sind isOpen und price Variablen; der Teil : Typname hinter dem Namen gibt explizit den Variablentyp an.
2. Numerische Suffix-Typangabe
Hänge ein Typ-Suffix an einen Zahlenwert, um seinen Typ festzulegen – funktioniert nur bei Zahlen.
fn main() {
let an_integer = 5i32;
}Code-Sprache: JavaScript (javascript)Hier wird der Typ nicht über : festgelegt, sondern durch das Suffix i32 an der zugewiesenen Zahl als 32-Bit-Ganzzahl markiert.
3. Standardtyp-Regeln
Ohne jegliche Annotation oder Suffix nutzt der Compiler einen Standardtyp:
- Ganzzahlliteral → Standard
i32 - Gleitkommaliteral → Standard
f64
fn main() {
let default_float = 3.0; // automatisch f64
let default_integer = 7; // automatisch i32
}Code-Sprache: JavaScript (javascript)4. Kontextbasierte Typableitung
Der Compiler kann den echten Typ der Variable anhand des nachfolgenden Codes automatisch ermitteln, ohne manuelle Angabe.
fn main() {
let mut inferred_type = 12;
inferred_type = 4294967296i64; // aus dieser Zeile wird der Typ i64 abgeleitet
}Code-Sprache: JavaScript (javascript)Veränderliche Variablen & Variableneigenschaften
1 Veränderliche Variable
Mit dem Schlüsselwort mut markierte Variable, deren Wert verändert werden kann.
fn main() {
let mut mutable = 12;
mutable = 21; // erlaubt, Wertänderung
}Code-Sprache: JavaScript (javascript)2 Typ unveränderlich
Sobald der Typ einer Variable feststeht, lässt er sich während der gesamten Ausführung nicht mehr ändern; die Zuweisung eines Werts anderen Typs führt sofort zu einem Kompilierfehler.
fn main() {
let mut mutable = 12;
mutable = 21; // erlaubt, Wertänderung
mutable = true; // Fehler: ursprünglicher Typ i32, Zuweisung von bool nicht zulässig
}Code-Sprache: JavaScript (javascript)C:\Users\Jack\Desktop\rustdemo>rustc hello.rs
error[E0308]: mismatched types
--> hello.rs:5:12
|
3 | let mut mutable = 12;
| -- expected due to this value
4 | mutable = 21; // erlaubt, Wertänderung
5 | mutable = true; // Fehler: ursprünglicher Typ i32, Zuweisung von bool nicht zulässig
| ^^^^ expected integer, found `bool`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0308`.Code-Sprache: JavaScript (javascript)Hinweis
In Rust sind Variablenwerte standardmäßig unveränderlich. Wenn der Wert veränderbar sein soll, brauchst du das Schlüsselwort mut – das unterscheidet sich von anderen Programmiersprachen.
Der folgende Code ist in anderen Sprachen üblich, erzeugt aber in Rust einen Fehler
fn main() {
let mutable:i32 = 12;
mutable = 21; // erlaubt, Wertänderung
}Code-Sprache: JavaScript (javascript)Kompilierfehler
C:\Users\Jack\Desktop\rustdemo>rustc hello.rs
error[E0384]: cannot assign twice to immutable variable `mutable`
--> hello.rs:4:2
|
3 | let mutable:i32 = 12;
| ------- first assignment to `mutable`
4 | mutable = 21; // erlaubt, Wertänderung
| ^^^^^^^^^^^^ cannot assign twice to immutable variable
|
help: consider making this binding mutable
|
3 | let mut mutable:i32 = 12;
| +++
warning: variable `mutable` is assigned to, but never used
--> hello.rs:3:6
|
3 | let mutable:i32 = 12;
| ^^^^^^^
|
= note: consider using `_mutable` instead
= note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
warning: value assigned to `mutable` is never read
--> hello.rs:4:2
|
4 | mutable = 21; // erlaubt, Wertänderung
| ^^^^^^^^^^^^
|
= help: maybe it is overwritten before being read?
= note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
error: aborting due to 1 previous error; 2 warnings emitted
For more information about this error, try `rustc --explain E0384`.Code-Sprache: JavaScript (javascript)3 Variablen-Schatten (Shadowing)
Wenn du mit let erneut eine Variable gleichen Namens deklarierst, schattet die neue die alte Variable. Es sind zwei unabhängige Variablen mit ggf. unterschiedlichen Typen.
fn main() {
let mutable = 12;
let mutable = true; // schattet die obige i32-Variable, neue Variable hat Typ bool
}Code-Sprache: JavaScript (javascript)Verbundtypen: Array & Tupel
1. Array
- Syntax:
[Elementtyp; Länge], Typ und Länge fest, alle Elemente müssen denselben Typ haben.
let my_array: [i32; 5] = [1, 2, 3, 4, 5];Code-Sprache: JavaScript (javascript)2. Tupel
- Eingeklammert mit
(), kann mehrere Werte unterschiedlicher Typen speichern.
let my_tuple = (5u32, 1u8, true, -5.04f32);Code-Sprache: JavaScript (javascript)