Skalare Typen
Integer, Gleitkommazahlen, bool, char
Skalare Typen ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 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.
Was sind skalare Typen?
Ein skalarer Typ repräsentiert einen einzelnen Wert. Rust verfügt über vier grundlegende skalare Typen:
- Ganzzahlen
- Gleitkommazahlen
- Boolesche Werte
- Zeichen
fn main() {
let i = 10; // integer
let f = 2.5; // float
let b = true; // bool
let c = 'R'; // char
println!("{} {} {} {}", i, f, b, c);
}Ganzzahltypen
Ganzzahlen gibt es als vorzeichenbehaftete (i) und vorzeichenlose (u) Varianten mit fester Größe: i8, i16, i32, i64, i128 sowie die entsprechenden Varianten für u.
Der Standardtyp für Ganzzahlen ist i32.
fn main() {
let small: i8 = -120;
let big: u64 = 18_000_000_000;
println!("{} {}", small, big);
}Vorzeichenbehaftet vs. vorzeichenlos
Vorzeichenbehaftete Ganzzahlen können negativ sein, vorzeichenlose nicht.
i8reicht von -128 bis 127.u8reicht von 0 bis 255.
Verwenden Sie einen vorzeichenlosen Typ, wenn ein Wert niemals negativ sein kann, etwa bei einer Anzahl.
fn main() {
let temperature: i32 = -15;
let people: u32 = 250;
println!("temp {} people {}", temperature, people);
}Ganzzahlliterale
Sie können Ganzzahlen in verschiedenen Zahlensystemen schreiben und Unterstriche zur besseren Lesbarkeit verwenden.
- Dezimal:
1_000_000 - Hexadezimal:
0xff - Oktal:
0o77 - Binär:
0b1010
fn main() {
let dec = 1_000;
let hex = 0xff;
let bin = 0b1010;
println!("{} {} {}", dec, hex, bin);
}Gleitkommatypen
Rust hat zwei Gleitkommatypen: f32 und f64. Der Standard ist f64, da dieser Typ eine höhere Genauigkeit bietet.
Gleitkommazahlen folgen dem Standard IEEE-754.
fn main() {
let pi: f64 = 3.141592;
let e: f32 = 2.718;
println!("pi {} e {}", pi, e);
}Numerische Operationen
Rust unterstützt die üblichen mathematischen Operatoren: +, -, *, / und % (Rest).
Bei der Ganzzahldivision wird in Richtung null abgeschnitten.
fn main() {
let sum = 5 + 10;
let quotient = 7 / 2; // 3 (integer)
let remainder = 7 % 2; // 1
let float_div = 7.0 / 2.0; // 3.5
println!("{} {} {} {}", sum, quotient, remainder, float_div);
}Der boolesche Typ
Der Typ bool hat genau zwei Werte: true und false.
Boolesche Werte entstehen durch Vergleiche und werden in if-Bedingungen verwendet.
fn main() {
let is_active = true;
let is_bigger = 10 > 3;
println!("{} {}", is_active, is_bigger);
}Der Zeichentyp
Ein char repräsentiert einen einzelnen Unicode-Skalarwert und wird mit einfachen Anführungszeichen geschrieben.
Ein Rust-char belegt 4 Byte und kann weit mehr als ASCII enthalten — einschließlich Emojis und Buchstaben mit Akzenten.
fn main() {
let letter = 'A';
let symbol = '@';
let heart = '\u{2764}';
println!("{} {} {}", letter, symbol, heart);
}char vs. String
Einfache Anführungszeichen ergeben ein char, doppelte Anführungszeichen einen String-Slice (&str).
'a'ist ein einzelnes Zeichen."a"ist eine Zeichenkette mit einem Zeichen.
fn main() {
let c = 'x';
let s = "x";
println!("char {} string {}", c, s);
}Typkonvertierung mit as
Rust konvertiert numerische Typen nicht automatisch. Verwenden Sie das Schlüsselwort as für explizite Casts.
Vorsicht: Beim Cast in einen kleineren Typ können Daten verloren gehen.
fn main() {
let x: i32 = 65;
let y: f64 = x as f64;
let c = x as u8 as char;
println!("{} {} {}", x, y, c);
}Skalare Typen kombinieren
Programme kombinieren ständig skalare Typen. Hier werden Ganzzahlen, Gleitkommazahlen und boolesche Werte miteinander verbunden, um eine Entscheidung zu treffen.
fn main() {
let price: f64 = 19.99;
let quantity: u32 = 3;
let total = price * quantity as f64;
let is_expensive = total > 50.0;
println!("total {} expensive {}", total, is_expensive);
}Kurztest
Testen Sie Ihr Wissen über skalare Literale in Rust.
Zusammenfassung
Die vier skalaren Typen von Rust:
- Ganzzahlen — vorzeichenbehaftet (i32) und vorzeichenlos (u32), in verschiedenen Größen.
- Gleitkommazahlen — f32 und f64, standardmäßig f64.
- bool — true oder false.
- char — ein einzelner Unicode-Wert in einfachen Anführungszeichen.
Verwenden Sie as für explizite numerische Konvertierungen.
fn main() {
let count: u32 = 42;
let ratio: f64 = count as f64 / 7.0;
let ok: bool = ratio > 5.0;
let grade: char = 'B';
println!("{} {} {} {}", count, ratio, ok, grade);
}Häufig gestellte Fragen
Ist die Lektion „Skalare Typen“ kostenlos?
Ja — der vollständige Text von „Skalare Typen“ 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 „Skalare Typen“?
Integer, Gleitkommazahlen, bool, char 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 2 von 4.
Wie lange dauert die Lektion „Skalare Typen“?
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
- let und Mutabilität
- Skalare Typen
- Zusammengesetzte Typen
- Shadowing