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

Clean Code auf Rust: Prinzipien und Beispiele

Das Schreiben von sauberem Code ist nicht nur das Befolgen von Modetrends, sondern eine grundlegende Fähigkeit, die einen Profi von einem Amateur unterscheidet. In der Welt der Systemprogrammierung, in der Rust immer beliebter wird, wird die Fähigkeit, verständlichen, wartbaren und sicheren Code zu schreiben, entscheidend wichtig. In diesem Artikel werden wir die wichtigsten Prinzipien von Clean Code in Bezug auf Rust durchgehen und sie mit praktischen Beispielen untermauern.

1. Benennung: Sagt, was die Variable tut

Die richtige Benennung ist die Grundlage für lesbaren Code. In Rust, wo starke Typisierung und Ownership bereits viele Informationen liefern, machen gute Namen den Code selbstdokumentierend.

Schlechtes Beispiel:

fn calc(x: &[i32]) -> i32 {    let mut r = 0;    for i in x {        r += i;    }    r}

Gutes Beispiel (Clean Code):

fn calculate_sum(numbers: &[i32]) -> i32 {    let mut total = 0;    for number in numbers {        total += number;    }    total}

Verwenden Sie Verben für Funktionen (calculate, fetch, validate) und Substantive für Variablen (total, user_name, config). Vermeiden Sie Abkürzungen wie tmp, res oder val – sie sagen nichts über den Zweck aus.

2. Funktionen: Klein und mit einer einzigen Verantwortung

Das Prinzip der einzigen Verantwortung (Single Responsibility) gilt nicht nur für Klassen, sondern auch für Funktionen. Jede Funktion sollte genau eine Sache tun und diese gut machen.

Schlechtes Beispiel (Funktion macht zu viel):

fn process_user_data(user: &User) -> Result<(), String> {    // Validierung    if user.name.is_empty() {        return Err("Name is empty".to_string());    }    // Logging    println!("Processing user: {}", user.name);    // Speichern in der DB    save_to_database(user)?;    // E-Mail senden    send_welcome_email(user.email)?;    Ok(())}

Gutes Beispiel (Aufteilung in kleine Funktionen):

fn process_user_data(user: &User) -> Result<(), AppError> {    validate_user(user)?;    log_user_processing(user);    save_user_to_db(user)?;    send_welcome_email(&user.email)?;    Ok(())}

fn validate_user(user: &User) -> Result<(), AppError> {    if user.name.is_empty() {        return Err(AppError::Validation("Name is required".into()));    }    Ok(())}

fn log_user_processing(user: &User) {    println!("Processing user: {}", user.name);}

Beachten Sie: Jede Funktion hat jetzt eine klare Verantwortung, und der Code ist einfacher zu testen und zu ändern.

3. Fehlerbehandlung: Verwenden Sie Result und eigene Fehlertypen

In Rust gibt es keine Exceptions, und das ist großartig. Clean Code auf Rust bedeutet explizite Arbeit mit Fehlern über die Typen Result<T, E> und Option<T>. Vermeiden Sie Panics (unwrap(), expect()) im Production-Code.

Schlechtes Beispiel (Panic bei Fehler):

fn read_config(path: &str) -> Config {    let content = std::fs::read_to_string(path).unwrap();    serde_json::from_str(&content).unwrap()}

Gutes Beispiel (saubere Fehlerbehandlung):

#[derive(Debug, thiserror::Error)]pub enum ConfigError {    #[error("Failed to read file: {0}")]    IoError(#[from] std::io::Error),    #[error("Failed to parse config: {0}")]    ParseError(#[from] serde_json::Error),}

fn read_config(path: &str) -> Result<Config, ConfigError> {    let content = std::fs::read_to_string(path)?;    let config: Config = serde_json::fr