Cookbooks
Rust
Kapitel 5. Gute Programmierpraktiken
Refactoring

Rust:
Refactoring

Wie:

Lassen Sie uns ein einfaches Stück Rust-Code refaktorisieren, um es idiomatischer und wartbarer zu machen. Wir beginnen mit einer Funktion, die die Summe eines Vektors von Ganzzahlen berechnet:

fn sum(vec: &Vec<i32>) -> i32 {
    let mut sum = 0;
    for i in vec {
        sum += i;
    }
    sum
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    println!("Die Summe ist {}", sum(&numbers));
}

Ausgabe:

Die Summe ist 15

Jetzt wollen wir dies so refaktorisieren, dass wir idiomatischeres Rust durch die Nutzung von Iteratoren und der fold-Methode verwenden:

fn sum(vec: &[i32]) -> i32 {
    vec.iter().fold(0, |acc, &x| acc + x)
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    println!("Die Summe ist {}", sum(&numbers));
}

Keine Änderung in der Ausgabe – es ist immer noch 15 –, aber die refaktorisierte Version ist sauberer und nutzt die Stärken von Rust, wie Ausleihen und Iterator-Methoden.

Tiefere Einblicke

Refactoring hat seine Wurzeln in der Smalltalk-Community und wurde in der Java-Welt durch Martin Fowlers Buch „Refactoring: Improving the Design of Existing Code” popularisiert. Seine Prinzipien sind universell und gelten auch für Rust, wo Sicherheit und Parallelität von größter Bedeutung sind. Rust fördert das Schreiben von robustem Code, indem es Probleme bereits zur Kompilierzeit aufdeckt, sodass der Rust-Compiler beim Refactoring als Sicherheitsnetz fungiert.

Alternativen zum manuellen Refactoring umfassen die Verwendung von automatisierten Werkzeugen, wie ‚rustfmt‘ für die Codeformatierung und ‚clippy‘ für das Linting, die idiomatischere Schreibweisen des Codes vorschlagen können. Tiefgreifendes Refactoring erfordert jedoch oft ein durchdachtes Verständnis des Code-Designs, was diese Werkzeuge nicht vollständig automatisieren können.

Beim Refactoring in Rust kann es darum gehen, die Nutzung von Typen zu verbessern, Lebenszeiten effektiv zu nutzen, unnötige Allokationen zu reduzieren oder Parallelitätsmuster wie Arc<Mutex<T>> bei Bedarf zu verwenden. Es ist auch üblich, von unwrap() zu ausdrucksstärkerer Fehlerbehandlung mit Result<T, E> zu wechseln.

Siehe auch

Um tiefer in das Refactoring in Rust einzutauchen:

Code in Funktionen organisieren