Entretien technique Rust

Questions théoriques fréquentes

Q: Qu'est-ce que les traits en Rust ? En Rust, les traits définissent un ensemble de méthodes qui doivent être implémentées pour qu'un type puisse être utilisé dans une certaine situation.

trait Animal {
    fn speak(&self);
}

impl Dog for Animal {
    fn speak(&self) {
        println!("Woof!");
    }
}

Q: Expliquez la différence entre Option et Result. Option est utilisée pour représenter une valeur qui peut être soit définie (Some), soit non définie (None). En revanche, Result est utilisé lorsqu'une opération peut échouer et fournit des informations sur l'erreur.

Q: Qu'est-ce que le Borrow Checker en Rust ? Le Borrow Checker est la partie du compilateur de Rust qui vérifie si les références sont utilisées correctement. Il assure que toutes les données qui sont prises comme référence n'ont pas été mutuellement modifiées ou détruites pendant leur utilisation.

Q: Expliquez la différence entre &T et &mut T. &T est une référence immuable à un type T, ce qui signifie que vous pouvez lire mais pas modifier le type. &mut T est une référence mutable, permettant de lire et de modifier le type.

Q: Qu'est-ce que la macro vec! en Rust ? La macro vec! est utilisée pour créer des instances de la collection Vec<T>, qui implémente un vecteur dynamique. Elle simplifie l'initialisation et la manipulation des tableaux en Rust.

let v = vec![1, 2, 3];

Q: Expliquez le principe du "ownership" en Rust. Le concept d'ownership est une partie clé de Rust qui gère la mémoire. Il assure que chaque valeur a un owner spécifique, et qu'il n'y a qu'un seul owner à la fois. Lorsque l'owner sort de son scope, la mémoire associée est automatiquement libérée.

Q: Qu'est-ce que Box<T> ? Box<T> est une allocation sur le tas pour une valeur de type T. Elle permet de stocker des données qui sont trop grandes pour être stockées directement sur la pile (par exemple, un objet très grand ou une fonction recursive profonde).

let b = Box::new(5);

Q: Expliquez le principe du "borrowing" en Rust. Le concept de borrowing est utilisé pour permettre aux fonctions de travailler avec des données sans prendre la possession d'elles. Cela permet aux fonctions de lire et de modifier les données, tout en maintenant la validité des autres parties qui ont besoin de ces données.

Q: Qu'est-ce que le principe du "lifetimes" en Rust ? Les lifetimes sont utilisés pour spécifier la durée pendant laquelle une référence est valide. Ils aident à éviter les erreurs liées au dangling references et garantissent que chaque référence pointe toujours vers des données valides.

Q: Expliquez le concept de "closures" en Rust. Les closures en Rust sont des fonctions anonymes qui peuvent capturer des variables du contexte surrounding. Elles sont utilisées pour créer des fonctions plus flexibles et réutilisables.

let add = |x, y| x + y;

Exercices de code classiques

1. Écrivez une fonction qui prend un vecteur d'entiers et renvoie la somme des nombres pairs.

fn sum_even_numbers(numbers: Vec<i32>) -> i32 {
    numbers.into_iter().filter(|&x| x % 2 == 0).sum()
}

2. Implémentez une fonction qui prend un string et renvoie le nombre de voyelles dans ce string.

fn count_vowels(text: &str) -> usize {
    text.chars().filter(|c| "aeiouAEIOU".contains(*c)).count()
}

3. Écrivez une fonction qui prend un vecteur d'entiers et renvoie le plus grand nombre.

fn find_max(numbers: Vec<i32>) -> Option<i32> {
    numbers.into_iter().max()
}

4. Implémentez une fonction qui prend un string et renvoie un nouveau string avec les lettres inversées.

fn reverse_string(text: &str) -> String {
    text.chars().rev().collect()
}

5. Écrivez une fonction qui prend un vecteur d'entiers et renvoie un vecteur contenant seulement les nombres impairs.

fn filter_odd_numbers(numbers: Vec<i32>) -> Vec<i32> {
    numbers.into_iter().filter(|&x| x % 2 != 0).collect()
}

Pieges courants en entretien

1. Confusion entre Box<T>, Rc<T> et Arc<T>

• Le choix entre ces trois types dépend de la situation, mais il est important de bien comprendre les différences pour ne pas faire d'erreurs.

2. Utilisation de .clone() inutilement

• Le .clone() peut être coûteux en termes de performance et doit être utilisé uniquement lorsque cela est nécessaire.

3. Utilisation incorrecte du trait Send et Sync

• Ces traits sont liés à la concurrence et doivent être bien compris pour éviter des erreurs liées aux threads.

4. Confusion entre &T, &mut T, Box<T>, etc.

• Il est important de comprendre les différences entre ces différents types de références et d'allocations de mémoire.

5. Utilisation incorrecte des lifetimes

• Les lifetimes sont cruciaux pour éviter les erreurs liées aux dangling references, mais ils peuvent être difficiles à comprendre au début.

Complexité algorithmique

Concepts avancés à connaître

1. Les macros

• Les macros en Rust permettent de générer du code dynamiquement, facilitant la création de fonctions réutilisables et efficaces.

2. La concurrence avec std::sync

• La gestion de la concurrence est un aspect important de Rust, permettant d'écrire des applications multi-threadées sûres et performantes.

3. Les traits objectifs

• Les traits objectifs en Rust permettent d'utiliser des traits comme des types abstraits, offrant une grande flexibilité dans le choix des implémentations.

4. L'assemblage manuel avec unsafe

• Rust offre un niveau élevé de sécurité par défaut, mais certaines opérations nécessitent l'utilisation du mot-clé unsafe pour accéder directement à la mémoire ou à d'autres fonctionnalités avancées.

5. Les types spéciaux comme Option, Result et Either

• Ces types permettent de gérer des cas où une opération peut échouer ou renvoyer plusieurs résultats, offrant un contrôle précis sur les erreurs et la gestion du flux de contrôle dans le code Rust.

Conseils pratiques

1. Lisez la documentation officielle

• La documentation officielle de Rust est une source précieuse pour comprendre les concepts avancés et les bonnes pratiques.

2. Pratiquez régulièrement

• Comprendre Rust nécessite beaucoup d'expériences pratiques. Essayez de résoudre des problèmes, de lire le code existant et de travailler sur des projets personnels.

3. Apprenez à utiliser les outils de débogage

• Les outils comme println! pour le suivi, assert_eq! pour les tests unitaires et la commande rustc --explain error_code peuvent vous aider à comprendre les erreurs et améliorer votre code.

4. Utilisez des exemples de code

• Les exemples de code dans la documentation officielle et sur le site web de Rust sont une excellente source pour apprendre comment utiliser différents concepts et fonctionnalités.

5. Partagez vos connaissances

• Faites un partage régulier des informations que vous avez apprises avec d'autres débutants ou experts. Cela peut aider à consolider votre propre compréhension et aider les autres à progresser plus rapidement.