Rust-Tutorial: Lernen Sie die Programmiersprache Rust kennen

Rust ist eine Programmiersprache von Mozilla. Mit Rust lassen sich u. a. Kommandozeilen-Tools, Web-Applikationen und Netzwerkprogramme schreiben. Ferner eignet sich die Sprache für hardwarenahe Programmierung. Unter Rust-Programmierern erfreut sich die Sprache ausgesprochener Beliebtheit.

In diesem Rust-Tutorial zeigen wir Ihnen die wichtigsten Features der Sprache. Dabei gehen wir auf Gemeinsamkeiten und Unterschiede zu anderen, verbreiteten Sprachen ein. Wir leiten Sie durch die Rust-Installation, und Sie lernen, Rust-Code auf Ihrem eigenen System zu schreiben und zu kompilieren.

Die Programmiersprache Rust im Überblick

Bei Rust handelt es sich um eine kompilierte Sprache. Diese Eigenschaft resultiert in hoher Performanz; gleichzeitig bietet die Sprache ausgereifte Abstraktionen, die dem Programmierer die Arbeit erleichtern. Ein besonderer Fokus von Rust liegt auf der Speichersicherheit. Damit hat die Sprache einen besonderen Vorteil im Vergleich zu älteren Sprachen wie C und C++.

Rust auf dem eigenen System nutzen

Da Rust eine freie und quelloffene Software (FOSS) ist, kann ein jeder die Rust-Toolchain herunterladen und auf dem eigenen System nutzen. Anders als Python oder JavaScript ist Rust keine interpretierte Sprache. Statt einem Interpreter kommt, wie bei C, C++ und Java, ein Compiler zum Einsatz. In der Praxis bedeutet dies, dass zum Ausführen von Code zwei Schritte gehören:

Den Quelltext kompilieren. Dies erzeugt eine ausführbare Binärdatei.
Die resultierende Binärdatei ausführen.

Beide Schritte werden im einfachsten Fall über die Kommandozeile gesteuert.

Mit Rust können neben ausführbaren Binärdateien auch Bibliotheken erzeugt werden. Handelt es sich beim kompilierten Code um ein direkt ausführbares Programm, muss im Quelltext eine main()-Funktion definiert werden. Wie in C / C++ dient diese als Einstiegspunkt in die Code-Ausführung.

Rust für das Tutorial auf dem lokalen System installieren

Um Rust nutzen zu können, benötigen Sie zunächst eine lokale Installation. Unter macOS nutzen Sie dabei den Homebrew Paketmanager. Homebrew funktioniert auch unter Linux. Öffnen Sie eine Kommandozeile (‚Terminal.App‘ auf dem Mac), kopieren Sie die folgende Codezeile in das Terminal und führen Sie diese aus:

cd "$HOME/Desktop/"
mkdir rust-tutorial && cd rust-tutorial

cat << EOF > ./rust-tutorial.rs
fn main() {
    println!("Hello, World!");
}
EOF

# Rust-Quelltext kompilieren
rustc rust-tutorial.rs
# resultierende Binärdatei ausführen
./rust-tutorial

// Hier steht ein Kommentar
// Ein Kommentar,
// der sich über
// mehrere Zeilen
// erstreckt.

// Variable ‚alter‘ deklarieren und Wert auf ‚42‘ setzen
let alter = 42;
// Wert der Variable ‚alter‘ kann nicht verändert werden
alter = 49; // Kompilier-Fehler
// mit erneutem ‚let‘ kann die Variable überschrieben werden
let alter = 49;

let mut gewicht = 78;
gewicht = 75;

const VERSION: &amp;str = &quot;1.46.0&quot;;

// Konstante definieren
const MAX_NUM: u8 = 255;
MAX_NUM = 0; // Kompilier-Fehler, da der Wert einer Konstante nicht veränderbar ist
const MAX_NUM = 0; // Kompilier-Fehler, da Konstante nicht neu deklariert werden kann

let name = String::from("Peter Mustermann");
let _name = name;
println!("{}, world!", name); // Kompilier-Fehler, da der Wert von ‚name‘ an ‚_name‘ weitergereicht wurde

let name = String::from("Peter Mustermann");

// wird der Typ des ‚name‘-Parameters als ‚String‘ statt ‚&String‘ definiert
// kann die Variable ‚name‘ nach dem Funktionsaufruf nicht mehr verwendet werden
fn hallo(name: &String) {
  println!("Hallo, {}", name);
}

// das Funktions-Argument muss ebenfalls mit ‚&‘
// als Referenz gekennzeichnet werden
hallo(&name);

// diese Zeile führt ohne Nutzung der Referenz zum Kompilier-Fehler
println!("Hallo, {}", name);

// Liste mit Namen
let namen = ["Jim", "Jack", "John"];
// ‚for‘-Schleife mit Iterator in die Liste
for name in namen.iter() {
    println!("Hallo, {}", name);
}

// die Zahlen ‚1‘ bis ‚10‘ ausgeben
// ‚for‘-Schleife mit ‚range‘-Iterator
// Achtung: Die Range enthält nicht die Endzahl!
for zahl in 1..11 {
  println!("Zahl: {}", zahl);
}
// alternative (inklusive) Range-Schreibweise
for zahl in 1..=10 {
  println!("Zahl: {}", zahl);
}

// die Zahlen ‚1‘ bis ‚10‘ via ‚while‘-Schleife ausgeben
let mut zahl = 1;
while (zahl <= 10) {
  println!(Zahl: {}, zahl);
  zahl += 1;
}

// Endlosschleife mit ‚while‘
while true {
  // …
}
// Endlosschleife mit ‚loop‘
loop {
  // …
}

const limit: u8 = 42;
let zahl = 43;
if zahl < limit {
  println!("Unter dem Limit.");
}
else if zahl == limit {
  println!("Genau am Limit…");
}
else {
  println!("Über dem Limit!");
}

fn prozedur() {
  println!("Diese Prozedur liefert keinen Wert zurück.");
}
// eine Zahl negieren
// Rückgabetyp nach dem ‚->‘-Operator
fn negiert(ganzzahl: i8) -> i8 {
  return ganzzahl * -1;
}

// ‚struct‘-Definition
struct Rechteck {
    breite: u32,
    hoehe: u32,
}
// ‚struct‘-Implementierung
impl Rechteck {
    fn flaeche(&self) -> u32 {
        return self.breite * self.hoehe;
    }
}
let rechteck = Rechteck {
    breite: 30,
    hoehe: 50,
};
println!("Die Fläche des Rechtecks beträgt {}.", rechteck.flaeche());

Datentyp	Erklärung	Typ-Annotation
Integer	ganze Zahl	i8, u8, etc.
Floating point	Gleitkommazahl	f64, f32
Boolean	Wahrheitswert	bool
Character	einzelner Unicode-Buchstabe	char
String	Unicode-Zeichenkette	str

// hier erkennt der Compiler den Typ der Variable automatisch
let cents = 42;

// Typ-Annotation: positive Zahl (‚u8‘ = "unsigned, 8 bits")
let alter: u8 = -15; // Kompilier-Fehler, da negativer Wert gegeben

// Gleitkommazahl
let winkel = 38.5;
// equivalent zu
let winkel: f64 = 38.5;

// Wahrheitswert
let nutzer_angemeldet = true;
// equivalent zu
let nutzer_angemeldet: bool = true;

// Buchstabe, benötigt einzelne Anführungszeichen
let buchstabe = 'a';

// statische Zeichenkette, benötigt doppelte Anführungszeichen
let name = "Walther";
// mit explizitem Typ
let name: &'static str = "Walther";
// alternativ als dynamischer ‚String‘ mit ‚String::from()‘
let name: String = String::from("Walther");

Datentyp	Erklärung	Typ der Elemente	Literal-Syntax
Array	Liste mehrerer Werte	selber Typ	[a1, a2, a3]
Tuple	Anordnung mehrerer Werte	jeglicher Typ	(t1, t2)
Struct	Gruppierung mehrerer benannter Werte	jeglicher Typ	–
Enum	Aufzählung	jeglicher Typ	–

struct Person = {
  vorname: String,
  nachname: String,
  alter: u8,
}

let spieler = Person {
  vorname: String::from("Peter"),
  nachname: String::from("Mustermann"),
  alter: 42,
};
// auf Feld einer ‚struct‘-Instanz zugreifen
println!("Alter des Spielers ist: {}", spieler.alter);

enum KartenFarbe {
  Kreuz,
  Pik,
  Herz,
  Karo,
}
// die Farbe einer konkreten Spielkarte
let farbe = KartenFarbe::Kreuz;

// das zu einer Kartenfarbe gehörige Symbol ermitteln
fn karten_symbol(farbe: KartenFarbe) -> &'static str {
  match farbe {
    KartenFarbe::Kreuz => "♣︎",
    KartenFarbe::Pik => "♠︎",
    KartenFarbe::Herz => "♥︎",
    KartenFarbe::Karo => "♦︎",
  }
}
println!("Symbol: {}", karten_symbol(KartenFarbe::Kreuz)); // gibt Symbol ♣︎ aus

// Spielkarte als Tupel definieren
let spielkarte: (KartenFarbe, u8) = (KartenFarbe::Herz, 7);

// die Werte eines Tupels mehreren Variablen zuweisen
let (farbe, wert) = spielkarte;

// sollten wir nur den Wert benötigen
let (_, wert) = spielkarte;

let name = ("Peter", "Mustermann");
let vorname = name.0;
let nachname = name.1;

Datentyp	Erklärung
Vector	dynamische Liste mehrerer Werte desselben Typs
String	dynamische Folge von Unicode-Buchstaben
HashMap	dynamische Zuordnung von Schlüssel-Wert-Paaren

// Vektor mit ‚mut‘ als veränderbar deklarieren
let mut namen = Vec::new();
// dem Vektor Werte hinzufügen
namen.push("Jim");
namen.push("Jack");
namen.push("John");

Die Programmiersprache Rust im Überblick

Rust auf dem eigenen System nutzen

Rust für das Tutorial auf dem lokalen System installieren

Rust-Code kompilieren

Rust-Pakete mit Cargo verwalten

Rust-Grundlagen lernen

Anweisungen und Blöcke

Kommentare in Rust

Variablen und Konstanten

Konzept des Besitztums in Rust

Kontrollstrukturen

Schleifen

Verzweigungen

Funktionen, Prozeduren und Methoden

Datentypen und Datenstrukturen

Elementare Datentypen

Zusammengesetzte Datentypen

Höhere Programmierkonstrukte in Rust lernen

Dynamische Datenstrukturen

Objektorientierte Programmierung (OOP) in Rust

Meta-Programmierung

Kommentar verfassen Kommentieren abbrechen