Code propre en Rust : principes et exemples pratiques

Clean Code en Rust : principes et exemples pratiques

Dans le monde du développement logiciel, écrire du code fonctionnel n'est que la moitié du travail. La véritable maîtrise réside dans la capacité à créer un code facile à lire, à maintenir et à étendre. Pour le langage Rust, connu pour sa sécurité mémoire et ses performances, les principes du Clean Code revêtent une importance particulière. Dans cet article, nous analyserons les principes clés pour écrire du code propre en Rust et les illustrerons avec des exemples pratiques.

Pourquoi le Clean Code est-il important pour Rust ?

Rust est un langage puissant avec un système unique de possession (ownership) et d'emprunt (borrowing). Malgré sa rigueur, il est facile de créer un code confus difficile à maintenir. Le Clean Code aide à :

• Réduire le nombre d'erreurs à la compilation et à l'exécution.
• Simplifier le travail d'équipe et les revues de code.
• Améliorer la productivité du développement grâce à la lisibilité.
• Rendre le code auto-documenté.

Principe 1 : Nommer les variables et les fonctions

Un bon nom est la base d'un code propre. En Rust, où les types sont stricts, c'est particulièrement important. Évitez les variables à une seule lettre (sauf pour les indices de boucle) et utilisez le snake_case pour les variables et les fonctions.

Mauvais exemple :

fn c(a: &[i32]) -> i32 {    let mut s = 0;    for i in a {        s += i;    }    s}

Bon exemple (Clean Code) :

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

Recommandations :

• Utilisez des verbes pour les fonctions : process_data(), validate_input().
• Utilisez des noms pour les variables : user_count, error_message.
• Évitez les abréviations : calc → calculate, tmp → temporary_value.

Principe 2 : Petites fonctions et responsabilité unique

Chaque fonction doit faire une seule chose. En Rust, cela aide particulièrement lors du travail avec les fermetures (closures) et les itérateurs.

Mauvais exemple (la fonction fait trop de choses) :

fn process_user_data(users: &[User]) -> Vec<String> {    let mut result = Vec::new();    for user in users {        if user.age > 18 {            let name = user.name.to_uppercase();            result.push(format!("Adult: {}", name));        } else {            result.push(format!("Minor: {}", user.name));        }    }    result}

Bon exemple (division en petites fonctions) :

fn classify_user(user: &User) -> &str {    if user.age > 18 { "Adult" } else { "Minor" }}

fn format_user_name(user: &User) -> String {    let classification = classify_user(user);    format!("{}: {}", classification, user.name)}

fn process_user_data(users: &[User]) -> Vec<String> {    users.iter().map(format_user_name).collect()}

Remarquez : dans le second exemple, nous avons utilisé des itérateurs, ce qui rend le code plus idiomatique pour Rust.

Principe 3 : Gestion des erreurs avec Option/Result

Rust propose les puissants types Option et Result pour la gestion des erreurs. Un code propre exige un traitement explicite de tous les cas possibles.

Mauvais exemple (ignorer les erreurs) :

fn divide(a: f64, b: f64) -> f64 {    if b == 0.0 {        panic!("Division by zero!");    }    a / b}

Bon exemple (gestion propre des erreurs) :

fn divide(a: f64, b: f64) -> Result<f64, String> {    if b == 0.0 {        Err("Division by zero