capypad
0 Tage Serie
Neues Quiz
Code-Bibliothek

Code, der lesenswert ist.

Sorgfältig kuratierte Snippets — TypeScript, Python, Rust, Go und mehr. Jedes mit einer Zeile-für-Zeile-Erklärung, damit du Code so liest, wie die Leute ihn geschrieben haben.

3498 Snippets · 10 Sprachen
▶ Lernen starten
Rust · AnfängerSnippet

Arbeiten mit Arrays fester Größe

Arrays in Rust haben eine feste Länge und müssen Elemente desselben Typs enthalten. Sie sind nützlich, wenn Daten auf dem Stack statt auf dem Heap gespeichert werden sollen.

snippet.rs
rust
1
2
3
4
5
6
fn main() {
    let a: [i32; 3] = [10, 20, 30];
    let first = a[0];
    let length = a.len();
    println!("First: {first}, Length: {length}");
}
Arrays & ListenDatentypen
Rust · AnfängerSnippet

Grundlegende Funktionen definieren

Funktionen werden mit 'fn' deklariert. Parameter müssen explizite Typangaben haben, und der Rückgabetyp wird nach einem Pfeil '->' angegeben. Der letzte Ausdruck in einer Funktion ist ihr Rückgabewert.

snippet.rs
rust
1
2
3
4
5
6
7
8
fn add(a: i32, b: i32) -> i32 {
    a + b
}
 
fn main() {
    let sum = add(5, 10);
    println!("The sum is: {sum}");
}
FunktionenSyntax
Rust · AnfängerSnippet

Variablen und Unveränderlichkeit

In Rust sind Variablen standardmäßig unveränderlich, was bedeutet, dass ihr Wert nach der Zuweisung nicht mehr geändert werden kann. Um eine Variable aktualisierbar zu machen, muss explizit das Schlüsselwort 'mut' verwendet werden.

snippet.rs
rust
1
2
3
4
5
6
7
fn main() {
    let x = 5;
    // x = 6; // This would cause a compile error
    let mut y = 10;
    y = 11; // This is allowed
    println!("x: {x}, y: {y}");
}
SyntaxDatentypen
Rust · AnfängerSnippet

Kontrollfluss mit If-Ausdrücken

In Rust ist 'if' ein Ausdruck, nicht nur eine Anweisung. Das bedeutet, dass es einen Wert zurückgibt, der einer Variablen zugewiesen werden kann, vorausgesetzt, alle Zweige geben den gleichen Typ zurück.

snippet.rs
rust
1
2
3
4
5
6
7
8
9
fn main() {
    let number = 7;
    let condition = if number < 10 {
        true
    } else {
        false
    };
    println!("Condition is {condition}");
}
KontrollstrukturenSyntax
Rust · AnfängerSnippet

Einfache Fehlerbehandlung mit Option

Rust verwendet das Option-Enum, um einen möglicherweise fehlenden Wert darzustellen, anstatt Null zu verwenden. 'match' wird verwendet, um sowohl das Vorhandensein (Some) als auch das Fehlen (None) des Wertes sicher zu handhaben.

snippet.rs
rust
1
2
3
4
5
6
7
8
9
fn main() {
    let some_value = Some(5);
    let no_value: Option<i32> = None;
 
    match some_value {
        Some(val) => println!("Value: {val}"),
        None => println!("No value found"),
    }
}
FehlerbehandlungDatentypen
Rust · AnfängerSnippet

Pattern Matching mit dem match-Operator

Der match-Operator ermöglicht es Ihnen, einen Wert mit einer Reihe von Mustern zu vergleichen und Code basierend auf dem passenden Muster auszuführen.

snippet.rs
rust
1
2
3
4
5
6
7
8
let coin_value = 5;
 
match coin_value {
    1 => println!("Penny"),
    5 => println!("Nickel"),
    10 => println!("Dime"),
    _ => println!("Unknown coin"),
}
KontrollstrukturenSyntax
Rust · AnfängerSnippet

Definieren und Instanziieren von Structs

Structs ermöglichen es Ihnen, benutzerdefinierte Datentypen zu erstellen, indem Sie verwandte Werte gruppieren. Jedes Feld hat einen Namen und einen Typ.

snippet.rs
rust
1
2
3
4
5
6
7
8
9
10
11
12
13
struct User {
    username: String,
    email: String,
    active: bool,
}
 
fn main() {
    let user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someuser123"),
        active: true,
    };
}
SyntaxDatentypen
Rust · AnfängerSnippet

Einfache Enums definieren

Enums (Aufzählungen) ermöglichen es Ihnen, einen Typ zu definieren, indem Sie seine möglichen Varianten aufzählen. Varianten können auch Daten enthalten.

snippet.rs
rust
1
2
3
4
5
6
7
8
enum WebEvent {
    PageLoad,
    PageUnload,
    KeyPress(char),
}
 
let load = WebEvent::PageLoad;
let press = WebEvent::KeyPress('x');
SyntaxDatentypen