Code-Bibliothek — Capypad · Code Zeile für Zeile lesen

Rust · MittelSnippet

Einfache Lifetime-Annotationen

Lifetimes stellen sicher, dass Referenzen so lange gültig bleiben, wie sie benötigt werden. Die Annotation '<'a>' teilt dem Compiler mit, dass das Struct nicht länger leben darf als die enthaltene Referenz.

snippet.rs

rust

1

2

3

4

5

6

7

8

struct Excerpt<'a> {
    part: &'a str,
}
 
fn main() {
    let text = String::from("Rust is fast.");
    let first_word = Excerpt { part: &text[0..4] };
}

Memory ManagementSyntax

Rust · MittelSnippet

Generische Schranken mit Traits

Generische Schranken ermöglichen es, einen generischen Typ so einzuschränken, dass er bestimmte Verhaltensweisen (Traits) implementieren muss. Dies stellt sicher, dass die Funktion die benötigten Methoden sicher aufrufen kann.

snippet.rs

rust

1

2

3

4

5

6

7

trait Summary {
    fn summarize(&self) -> String;
}
 
fn notify<T: Summary>(item: &T) {
    println!("Breaking news: {}", item.summarize());
}

SyntaxFunktionen

Rust · MittelSnippet

Funktionale Iterator-Adapter

Iteratoren in Rust sind 'lazy' (träge) und mächtig. 'filter' und 'map' ermöglichen Datentransformationen im funktionalen Stil ohne unnötige Zwischenspeicherungen.

snippet.rs

rust

1

2

3

4

5

let numbers = vec![1, 2, 3, 4, 5];
let doubled_evens: Vec<i32> = numbers.iter()
    .filter(|&x| x % 2 == 0)
    .map(|x| x * 2)
    .collect();

PerformanceBest Practices

Rust · MittelSnippet

Fehlerfortpflanzung mit dem ?-Operator

Der '?' Operator ist eine prägnante Art, Fehler zu behandeln. Wenn ein Result ein 'Err' ist, kehrt die Funktion vorzeitig mit diesem Fehler zurück; andernfalls wird der 'Ok'-Wert entpackt.

snippet.rs

rust

1

2

3

4

5

6

7

8

9

use std::fs::File;
use std::io::{self, Read};
 
fn read_username() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

FehlerbehandlungKontrollstrukturen

Rust · MittelSnippet

Enums mit Daten und Pattern Matching

Rust-Enums sind algebraische Datentypen. Sie können in jeder Variante verschiedene Datentypen speichern, die mit 'match' elegant extrahiert werden können.

snippet.rs

rust

1

2

3

4

5

6

7

8

9

10

11

12

13

enum WebEvent {
    PageLoad,
    KeyPress(char),
    Click { x: i64, y: i64 },
}
 
fn inspect(event: WebEvent) {
    match event {
        WebEvent::PageLoad => println!("page loaded"),
        WebEvent::KeyPress(c) => println!("pressed '{}'", c),
        WebEvent::Click { x, y } => println!("clicked at {}, {}", x, y),
    }
}

SyntaxDatentypen

Rust · MittelSnippet

Interne Veränderbarkeit mit RefCell

RefCell<T> bietet 'Interne Veränderbarkeit', ein Muster, das es ermöglicht, Daten zu verändern, selbst wenn man eine unveränderliche Referenz auf diese Daten hat. Die Borrowing-Regeln werden zur Laufzeit statt zur Kompilierzeit erzwungen.

snippet.rs

rust

1

2

3

4

5

6

7

8

use std::cell::RefCell;
 
let value = RefCell::new(5);
{
    let mut borrowed_value = value.borrow_mut();
    *borrowed_value += 10;
}
println!("Value: {:?}", value.borrow());

Memory ManagementBest Practices

Rust · MittelSnippet

Thread-sicherer geteilter Zustand mit Arc und Mutex

Arc (Atomic Reference Counted) ermöglicht es mehreren Threads, Eigentümer derselben Daten zu sein, während Mutex (Mutual Exclusion) sicherstellt, dass jeweils nur ein Thread die Daten verändern kann.

snippet.rs

rust

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

use std::sync::{Arc, Mutex};
use std::thread;
 
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
 
for _ in 0..10 {
    let counter = Arc::clone(&counter);
    let handle = thread::spawn(move || {
        let mut num = counter.lock().unwrap();
        *num += 1;
    });
    handles.push(handle);
}
 
for handle in handles { handle.join().unwrap(); }

Memory ManagementFunktionen

Rust · MittelSnippet

Dereferenzierung von Raw Pointers in Unsafe Rust

Raw Pointers (*const T und *mut T) ermöglichen es, die Ownership- und Borrowing-Regeln von Rust zu umgehen. Das Dereferenzieren gilt als unsicher, da der Compiler nicht garantieren kann, dass der Pointer gültig ist oder die Speichersicherheit nicht verletzt.

snippet.rs

rust

1

2

3

4

5

6

7

8

9

let mut num = 5;
let r1 = &num as *const i32;
let r2 = &mut num as *mut i32;
 
unsafe {
    println!("r1 is: {}", *r1);
    *r2 = 10;
    println!("num is now: {}", num);
}

Memory ManagementSyntax