Rust im Jahr 2025: Vollständiger Leitfaden für Anfänger von Null an

Einleitung: Warum Rust die Wahl des Jahres 2025 ist

Im Jahr 2025 erobert Rust weiterhin selbstbewusst die Herzen von Entwicklern weltweit. Laut der jährlichen Stack Overflow Umfrage wurde Rust bereits zum achten Mal in Folge als die beliebteste Programmiersprache ausgezeichnet. Seine Hauptvorteile sind Speichersicherheit ohne Garbage Collector und Spitzenleistung, vergleichbar mit C und C++. Wenn Sie mit Python vertraut sind, aber lernen möchten, schnelle und zuverlässige Systemanwendungen, WebAssembly oder sogar Betriebssysteme zu schreiben — Rust wird Ihr idealer nächster Schritt sein.

In diesem Artikel werden wir uns ansehen, wo man 2025 mit dem Lernen von Rust beginnen kann: wie man die Toolchain installiert, sein erstes Programm schreibt und die wichtigsten Konzepte versteht. Los geht's!

1. Installation von Rust und Kennenlernen von Cargo

Als Erstes müssen Sie den rustc Compiler und den Cargo Paketmanager installieren. Im Jahr 2025 ist der Prozess denkbar einfach.

Installation über rustup

Der offizielle und empfohlene Weg ist die Verwendung des rustup Dienstprogramms. Öffnen Sie ein Terminal und führen Sie den Befehl aus:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Das Skript bietet Standardeinstellungen an — drücken Sie einfach die Eingabetaste. Nach der Installation starten Sie Ihr Terminal neu oder führen Sie Folgendes aus:

source $HOME/.cargo/env

Überprüfen Sie, ob alles funktioniert:

rustc --versioncargo --version

Erstes Programm: "Hallo, Welt!"

Lassen Sie uns ein neues Projekt mit Cargo erstellen:

cargo new hello_rustcd hello_rust

Cargo erstellt die Verzeichnisstruktur. Öffnen Sie die Datei src/main.rs — sie enthält bereits eine Vorlage:

fn main() {    println!("Hello, world!");}

Erstellen und führen Sie das Programm mit einem einzigen Befehl aus:

cargo run

Sie werden die begehrte Begrüßung sehen. Herzlichen Glückwunsch, Sie haben Ihr erstes Rust-Programm geschrieben!

2. Grundlagen der Rust-Syntax: Variablen, Typen und Funktionen

Rust ist eine Sprache mit starker statischer Typisierung, aber der Compiler leitet Typen oft selbstständig ab. Lassen Sie uns die grundlegenden Konstrukte durchgehen.

Variablen und Unveränderlichkeit

Standardmäßig sind alle Variablen in Rust unveränderlich. Dies ist eines der Hauptmerkmale der Sprache und gewährleistet Sicherheit.

fn main() {    let x = 5;          // unveränderliche Variable    // x = 6;           // Fehler! Kann nicht geändert werden    let mut y = 10;     // veränderliche Variable (mut)    y += 5;             // Jetzt ist y = 15    println!("x = {}, y = {}", x, y);}

Datentypen

Rust unterstützt bekannte Typen: ganze Zahlen (i32, u64), Gleitkommazahlen (f64), boolesche Werte (bool), Zeichen (char) und Zeichenketten (String, &str).

fn main() {    let a: i32 = -42;          // vorzeichenbehaftete ganze Zahl    let b: u8 = 255;           // vorzeichenlose 8-Bit    let c: f64 = 3.1415;       // doppelte Genauigkeit    let is_rust_cool = true;   // bool    let letter = 'R';          // char (4 Bytes, Unicode)    let greeting = String::from("Hello, Rust!");    println!("{} {} {} {} {} {}", a, b, c, is_rust_cool, letter, greeting);}

Funktionen

Funktionen werden mit dem Schlüsselwort fn deklariert. Der Rückgabetyp wird nach dem Pfeil -> angegeben.

fn add(x: i32, y: i32) -> i32 {    x + y   // der letzte Ausdruck ist der Rückgabewert (kein Semikolon)}

fn main() {    let sum = add(10, 20);    println!("10 + 20 = {}", sum);}

3. Schlüsselkonzept: Ownership und Borrowing

Das komplexeste, aber auch wichtigste Thema in Rust ist das Ownership-System. Es ist das, was Speichersicherheit ohne Garbage Collector garantiert.