Rust Grundlagen anhand von 24 minimalen Beispielen

Rust ist eine Systemprogrammiersprache, die für ihre Sicherheit, Leistung und Parallelität bekannt ist und über einen reichen und einzigartigen Satz von Sprachkonstrukten verfügt. Dieser Artikel führt in die Kernfunktionen von Rust anhand von 24 prägnanten Codebeispielen ein.

Pattern Matching

Rusts match-Ausdruck implementiert Pattern Matching, mit dem Sie überprüfen können, ob ein Wert zu einer Reihe von Mustern passt.

let number = Some(42);
match number {
    Some(x) => println!("Die Zahl ist {}", x),
    None => println!("Es gibt keine Zahl"),
}

Dieser Code demonstriert, wie der match-Ausdruck verwendet wird, um verschiedene Fälle des Option-Typs zu behandeln.

Ownership und Lebenszeiten

Mit Lebensdauerparametern stellt Rust sicher, dass Referenzen gültig bleiben und vermeidet hängende Zeiger.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

Diese Funktion nimmt zwei String-Slices entgegen und gibt die längere zurück. Die Lebensdauer 'a garantiert, dass die zurückgegebene Referenz gültig ist.

Generics

Generics ermöglichen es, Funktionen und Strukturen zu definieren, ohne genaue Typen anzugeben.

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    list.iter().cloned().max_by(|a, b| a.partial_cmp(b).unwrap()).unwrap()
}

Diese generische Funktion largest findet den Maximalwert in einer Liste beliebigen Typs, der die Traits PartialOrd und Copy implementiert.

Traits

Traits ähneln Schnittstellen und definieren eine Reihe von Methoden, die implementiert werden können.

trait Summary {
    fn summarize(&self) -> String;
}

Der Summary-Trait kann von jedem Typ implementiert werden, um eine textuelle Zusammenfassung des Objekts bereitzustellen.

Type Casting

Rust bietet verschiedene Möglichkeiten zur Durchführung von Typkonvertierungen.

let decimal: f64 = 6.0;
let integer: i32 = decimal as i32; // Explizite Typkonvertierung

Dieser Code zeigt, wie ein Wert vom Typ f64 explizit in i32 konvertiert wird.

Error Handling

Rust verwendet den Typ Result, um potenzielle Fehler zu behandeln.

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Kann nicht durch Null teilen".to_string())
    } else {
        Ok(a / b)
    }
}

Diese divide-Funktion gibt einen Fehler zurück, wenn der Divisor Null ist.

Iteratoren

Iteratoren sind eine leistungsstarke Abstraktion in Rust zur Verarbeitung von Sequenzen.

let a = [1, 2, 3];
let mut iter = a.iter();
while let Some(&item) = iter.next() {
    println!("{}", item);
}

Dieser Code durchläuft ein Array mit einem Iterator.

Closures

Closures sind anonyme Funktionen in Rust.

let list = vec![1, 2, 3];
let even_numbers: Vec<i32> = list.into_iter().filter(|&x| x % 2 == 0).collect();

Hier wird ein Closure verwendet, um gerade Zahlen aus einem Vec herauszufiltern.

Async Programming

Asynchroner Code ermöglicht es einem Programm, andere Aufgaben auszuführen, während auf I/O-Operationen gewartet wird.

async fn fetch_data() -> Result<(), Error> {
    // Code zum asynchronen Abrufen von Daten
    Ok(())
}

Diese fetch_data-Funktion ist asynchron und kann innerhalb einer asynchronen Laufzeitumgebung aufgerufen werden.

Smart Pointers

Smart Pointers sind Zeiger mit zusätzlichen Fähigkeiten und dynamischem Verhalten.

use std::rc::Rc;
let a = Rc::new(5);
let b = Rc::clone(&a);

Hier ist Rc<T> ein referenzzählender Smart Pointer, der mehreren Eigentümern derselben Daten ermöglicht.

Threads

Rusts std::thread-Modul bietet Funktionen zum Erstellen und Verwalten von Threads.

use std::thread;
let handle = thread::spawn(|| {
    println!("Hallo von einem Thread!");
});
handle.join().unwrap();

Dieser Code erzeugt einen neuen Thread und gibt eine Nachricht darin aus.

Channels

Channels sind ein Mechanismus in Rust für die Kommunikation zwischen Threads.

use std::sync::mpsc;
let (tx, rx) = mpsc::channel();
tx.send("Hallo").unwrap();
let message = rx.recv().unwrap();

Hier wird ein Channel erstellt, um Nachrichten zwischen Threads zu übergeben.

Atomic Types

Atomic Types bieten Thread-sicheren, gemeinsam genutzten Zustand.

use std::sync::atomic::{AtomicUsize, Ordering};
let count = AtomicUsize::new(0);

AtomicUsize ist eine vorzeichenlose Ganzzahl, die sicher in Multi-Thread-Kontexten verwendet werden kann.

Conditional Compilation

Die bedingte Kompilierung ermöglicht es, unterschiedlichen Code in Abhängigkeit von der Plattform oder Konfiguration zu kompilieren.

#[cfg(target_os = "windows")]
fn is_windows() -> bool {
    true
}

Dieses Attribut-Makro aktiviert die Funktion is_windows nur, wenn das Zielbetriebssystem Windows ist.

Macros

Makros sind ein leistungsstarkes Feature in Rust, das es Code ermöglicht, Code zu generieren.

#[macro_use]
extern crate serde_derive;

Hier vereinfacht das serde_derive-Makro das Schreiben von Serialisierungs- und Deserialisierungscode.

Modules and Packages

Das Modulsystem ermöglicht die Organisation von Code in einer hierarchischen Struktur.

mod my_module {
    pub fn do_something() {
        // ...
    }
}

my_module ist ein Modul innerhalb der aktuellen Datei und enthält eine Funktion do_something, auf die von außen zugegriffen werden kann.

Feature Gates

Feature Gates sind eine Möglichkeit zu verhindern, dass bestimmte Funktionen missbraucht werden.

#![feature(untagged_unions)]

Dieses Attribut-Makro aktiviert das experimentelle Feature untagged_unions, das in Rust noch nicht stabil ist.

Memory Allocation

Rust ermöglicht die Anpassung von Speicherallokatoren.

use std::alloc::{GlobalAlloc, Layout};
struct MyAllocator;
unsafe impl GlobalAlloc for MyAllocator {
    unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
        // ...
    }
}

Hier wird ein benutzerdefinierter globaler Allokator MyAllocator definiert.

Raw Pointers

Raw Pointers bieten Low-Level-Speicherkontrolle.

let mut v = vec![1, 2, 3];
let ptr: *mut i32 = v.as_mut_ptr();

Dieser Code ruft einen Raw Pointer zu einem Vec ab, der eine direkte Manipulation seiner internen Integer ermöglicht.

Unions

Unions ermöglichen es verschiedenen Datentypen, Speicher zu teilen.

union MyUnion {
    i: i32,
    f: f32,
}

MyUnion kann entweder ein i32 oder ein f32 speichern, aber immer nur eines zur Zeit.

Enums

Enums in Rust werden verwendet, um einen Typ darzustellen, der eine von mehreren Varianten sein kann.

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

Das Message-Enum kann Quit, ein Move mit Koordinaten oder ein Write mit einem String sein.

Destructuring

Destructuring ermöglicht das Extrahieren von Werten aus Strukturen oder Tupeln.

let (x, y, z) = (1, 2, 3);

Dies destrukturiert das Tupel, um gleichzeitig drei Variablen zu erstellen.

Lifetime Elision

Rusts Compiler kann Lebensdauern in bestimmten Fällen automatisch ableiten.

fn borrow<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
    if *x > *y { x } else { y }
}

In dieser Funktion kann der Compiler die Lebensdauerparameter automatisch ableiten.

Inline Assembly

Inline Assembly ermöglicht das Einbetten von Assembly-Anweisungen in Rust-Code.

// Erfordert eine bestimmte Architektur und Umgebungskonfiguration
unsafe {
    asm!("nop", options(nomem, nostack));
}

Dieser Code verwendet das asm!-Makro, um eine nop-Anweisung (keine Operation) einzufügen.

---

Wir sind Leapcell, Ihre erste Wahl für das Hosten von Rust-Projekten.

Leapcell ist die Serverless-Plattform der nächsten Generation für Webhosting, asynchrone Aufgaben und Redis:

Multi-Language Support

• Entwickeln Sie mit Node.js, Python, Go oder Rust.

Stellen Sie unbegrenzt Projekte kostenlos bereit

• Zahlen Sie nur für die Nutzung – keine Anfragen, keine Gebühren.

Unschlagbare Kosteneffizienz

• Pay-as-you-go ohne Leerlaufgebühren.
• Beispiel: 25 $ unterstützen 6,94 Millionen Anfragen bei einer durchschnittlichen Antwortzeit von 60 ms.

Optimierte Entwicklererfahrung

• Intuitive Benutzeroberfläche für mühelose Einrichtung.
• Vollautomatische CI/CD-Pipelines und GitOps-Integration.
• Echtzeit-Metriken und -Protokollierung für verwertbare Erkenntnisse.

Mühelose Skalierbarkeit und hohe Leistung

• Automatische Skalierung zur einfachen Bewältigung hoher Parallelität.
• Kein betrieblicher Aufwand – konzentrieren Sie sich einfach auf den Aufbau.

Erfahren Sie mehr in der Dokumentation!

Folgen Sie uns auf X: @LeapcellHQ