Clean Code in Rust: Prinzipien und Beispiele für Anfänger

Clean Code in Rust: Prinzipien und Beispiele für Anfänger

Rust ist eine leistungsstarke Systemprogrammiersprache, die für ihre Leistung und Speichersicherheit bekannt ist. Wie in jeder anderen Sprache ist das Schreiben von sauberem Code (Clean Code) jedoch eine entscheidende Fähigkeit. Sauberer Code ist leichter zu lesen, zu warten und zu erweitern. Für Anfänger in Rust hilft die Beherrschung der Clean-Code-Prinzipien von Anfang an, typische Fehler zu vermeiden und Ihren Code elegant und zuverlässig zu gestalten. In diesem Artikel werden wir die grundlegenden Prinzipien von sauberem Code in Rust anhand konkreter Beispiele erläutern.

1. Benennung von Variablen und Funktionen

Ein guter Name sollte die Absicht des Programmierers erklären. In Rust ist es üblich, snake_case für Variablen, Funktionen und Module sowie CamelCase für Typen und Traits zu verwenden.

Schlechtes Beispiel:

fn c(a: i32, b: i32) -> i32 {\n    let x = a + b;\n    x\n}

Gutes Beispiel:

fn calculate_sum(first_number: i32, second_number: i32) -> i32 {\n    let result = first_number + second_number;\n    result\n}

Verwenden Sie aussagekräftige Namen: user_name statt un, process_data statt pd. Vermeiden Sie Abkürzungen, es sei denn, sie sind allgemein üblich (z. B. idx für Index).

2. Kleine Funktionen und Einzelverantwortung

Das Prinzip der Einzelverantwortung (Single Responsibility Principle) besagt: Jede Funktion sollte nur eine Sache tun. Wenn eine Funktion mehrere Aktionen ausführt, ist sie schwer zu testen und zu ändern.

Schlechtes Beispiel (Funktion macht zu viel):

fn process_user(user_id: u32) {\n    // Benutzer aus der Datenbank abrufen\n    // Daten validieren\n    // E-Mail senden\n    // Loggen\n    println!("Processing user {}", user_id);\n}

Gutes Beispiel (Aufteilung in kleine Funktionen):

fn get_user(user_id: u32) -> User {\n    // Logik zum Abrufen des Benutzers\n    User { id: user_id }\n}\n\nfn validate_user(user: &User) -> bool {\n    // Validierungslogik\n    user.id > 0\n}\n\nfn send_email(user: &User) {\n    // Logik zum Senden der E-Mail\n    println!("Email sent to user {}", user.id);\n}\n\nfn process_user(user_id: u32) {\n    let user = get_user(user_id);\n    if validate_user(&user) {\n        send_email(&user);\n    }\n}

Versuchen Sie, dass eine Funktion in 10-20 Zeilen passt. Wenn sie länger ist, teilen Sie sie auf.

3. Fehlerbehandlung: Verwenden Sie Result und Option

Rust fördert die explizite Fehlerbehandlung durch die Typen Result<T, E> und Option<T>. Vermeiden Sie die Verwendung von .unwrap() oder .expect() im Produktionscode – dies führt bei einem Fehler zu einer Panik.

Schlechtes Beispiel (gefährliches Extrahieren):

fn read_file(path: &str) -> String {\n    let content = std::fs::read_to_string(path).unwrap(); // Kann abstürzen!\n    content\n}

Gutes Beispiel (Fehlerbehandlung):

use std::fs;\n\nfn read_file(path: &str) -> Result<String, std::io::Error> {\n    let content = fs::read_to_string(path)?; // ?-Operator zum Weiterleiten des Fehlers\n    Ok(content)\n}\n\nfn main() {\n    match read_file("data.txt") {\n        Ok(data) => println!("File content: {}", data),\n        Err(e) => eprintln!("Error reading file: {}", e),\n    }\n}

Verwenden Sie den ?-Operator für Kürze, behandeln Sie Fehler jedoch immer auf der obersten Ebene. Für eigene Fehler erstellen Sie Aufzählungen mit dem Trait std::error::Error.

4. Kommentare und Dokumentation

Sauberer Code sollte selbstdokumentierend sein. Kommentare erklären das Warum, nicht das Was. Verwenden Sie für die Dokumentation öffentlicher APIs /// (Doc-Kommentare).

Schlechtes Beispiel (nutzloser Kommentar):

// Zähler um 1 erhöhen\ncounter += 1;

                
                

                    

                        Blogs                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Bereitstellung von Rust auf Kubernetes: Ein praktischer Leitfaden für Einsteiger
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Was ist eine Rune in Go? Vergleich der Ansätze und praktische Beispiele
                                
                            
                                            
                

                
                

                    

                        Buchempfehlungen                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
GraphQL in C++: Vollständiger Leitfaden zur Erstellung moderner APIs
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Programmieren in Rust
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Swift Cookbook
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
RxSwift: Reaktive Programmierung mit Swift
                                
                            
                                            
                
            
    

  
Lesen Sie auch
  

                
                  
                 Nullable in TypeScript: Wie deklariere ich einen Typ, der null sein kann?
      
                
                  
                 gRPC in Go: Wann man es einsetzt und wie man sich nicht ins Bein schießt
      
                
                  
                 Dateien in Python kopieren und verschieben: shutil & os
      
                
                  
                 Warteschlangen und Hintergrundaufgaben in TypeScript: So bringen Sie Ihre Produktion nicht zum Absturz
      
                
                  
                 Code-Review in Swift: Was zu prüfen ist und wie man Feedback gibt