Préparez des réponses claires et étayées par des preuves pour le travail exigé par ce poste. La banque de questions est gratuite ; l'entretien personnalisé AI utilise votre CV et le poste visé.
L'auto-entraînement ne nécessite aucun compte. Les entretiens AI, les relances et les retours nécessitent Pro ou Max.
Banque de questions de démarrage
Huit questions pour lesquelles il vaut la peine de se préparer
Il s'agit de questions d'entraînement publiques, et non de questions divulguées par un employeur.
01
Que se passe-t-il lorsqu'un String est déplacé dans une fonction ? Quand préféreriez-vous passer &str, &String ou String à la place ?
02
Pourquoi un emprunt immuable peut-il entrer en conflit avec un emprunt mutable ? Montrez comment vous modifieriez la portée plutôt que de cloner chaque valeur.
03
Une fonction renvoie une référence choisie parmi deux entrées. Que décrit son annotation de durée de vie, et que ne fait-elle pas ?
04
Quand renverriez-vous Result plutôt que d'appeler unwrap ? Comment ajouteriez-vous du contexte sans masquer l'erreur d'origine ?
05
Plusieurs threads de travail doivent mettre à jour un compteur partagé. Comparez un mutex, un compteur atomique et le passage de messages pour cette charge de travail.
06
Pourquoi Rc<T> diffère-t-il de Arc<T> lors du partage de la propriété entre threads ? Arc<T> suffit-il à lui seul à rendre la valeur interne sûre à modifier ?
07
Un service asynchrone ralentit pendant un parsing gourmand en CPU. Que mesureriez-vous et comment sépareriez-vous ce travail de l'attente d'E/S ?
08
Vous relisez un petit bloc unsafe. Quels invariants doivent être documentés, et comment réduiriez-vous la frontière et testeriez-vous ses appelants ?
Guide de rôle approfondi
Scénarios et points de contrôle des réponses
Une bonne réponse d'entretien Rust explique ce que le compilateur protège, ce que le programme doit encore garantir et pourquoi une conception convient à la charge de travail. Travaillez ces questions d'entraînement originales à l'aide d'un petit exemple ; reliez ensuite le raisonnement à un projet réel que vous pouvez présenter.
Scénario 1
Vous devez ajouter un élément à un Vec alors qu'une autre partie de la fonction lit encore l'un de ses éléments. Comment résolvez-vous l'erreur d'emprunt ?
Identifiez quelle référence reste active et si une lecture ultérieure en a vraiment besoin.
Essayez une portée d'emprunt plus petite, calculez d'abord un résultat possédé ou stockez un index et recherchez à nouveau après la mutation. Expliquez laquelle convient à l'exigence réelle.
Expliquez qu'un push peut réallouer le buffer. Montrez un petit exemple qui compile et discutez du coût si vous choisissez de cloner.
Scénario 2
Votre cache thread-safe utilise Arc<Mutex<Cache>>. Les requêtes deviennent lentes sous charge, mais le code est sûr du point de vue mémoire. Qu'investigueriez-vous ?
Séparez la propriété partagée de l'accès synchronisé : Arc gère la propriété ; le mutex protège l'accès au cache.
Mesurez le temps d'attente du verrou et le temps passé dans la section critique, y compris tout travail lent effectué en tenant le guard.
Comparez une section critique plus courte, le sharding ou le passage de messages. Discutez de la contention, de la cohérence et des tests ; la sûreté mémoire seule ne garantit ni un bon débit ni l'absence d'interblocage.
Scénario 3
Un parser renvoie soit une valeur empruntée à son entrée, soit une erreur détaillée. Comment concevriez-vous le API ?
Expliquez qui possède l'entrée et pendant combien de temps l'appelant a besoin du résultat. Dessinez la relation avant d'ajouter des paramètres de durée de vie.
Choisissez Result pour un échec de parsing attendu et décrivez les informations qu'une erreur devrait porter sans divulguer d'entrée sensible.
Comparez un résultat emprunté avec un résultat possédé. Expliquez les coûts d'allocation, l'utilisabilité de API et les tests pour des entrées valides, invalides et limites.
Erreur courante : Ne répondez pas à chaque erreur du borrow checker par un clone et n'affirmez pas que Rust empêche tous les bugs. Expliquez d'abord la relation de propriété, puis les risques restants tels que l'interblocage, les erreurs de logique ou le travail bloquant lent.