Cómo aprobar una entrevista de Rust: las mejores preguntas

Cómo pasar una entrevista de Rust: preguntas principales

Rust es uno de los lenguajes de programación más demandados en 2025. Combina el rendimiento de C/C++ con la seguridad de memoria, lo que lo convierte en una opción ideal para programación de sistemas, web assembly y proyectos blockchain. Sin embargo, la entrevista de Rust a menudo asusta a los candidatos debido al estricto sistema de ownership, borrowing y lifetimes. En este artículo, analizaremos las 10 preguntas principales que seguramente te harán y mostraremos las respuestas correctas con ejemplos de código.

1. ¿Qué es ownership y cómo funciona?

Ownership es la base de Rust. Cada valor en Rust tiene exactamente un propietario. Cuando el propietario sale del ámbito, el valor se elimina automáticamente.

fn main() {    let s = String::from("hello"); // s es el propietario del string    let t = s;                     // la propiedad se mueve a t    // println!("{}", s);          // ERROR: s ya no posee el valor    println!("{}", t);             // OK}

Qué preguntan en la entrevista: explica la diferencia entre move y copy. Los tipos que implementan el trait Copy (por ejemplo, i32, bool) se copian, no se mueven.

2. ¿Cómo funciona borrowing?

Borrowing permite usar un valor temporalmente sin transferir la propiedad. Hay dos tipos de borrowing: inmutable (&T) y mutable (&mut T).

fn main() {    let mut s = String::from("hello");    let r1 = &s;      // borrowing inmutable    let r2 = &s;      // se pueden tener múltiples inmutables    // let r3 = &mut s; // ERROR: no se puede tener mutable e inmutable simultáneamente    println!("{} {}", r1, r2);    let r3 = &mut s;  // OK: después de que r1 y r2 salen del ámbito    r3.push_str(" world");    println!("{}", r3);}

Regla clave: en cualquier momento, puede haber un solo borrowing mutable o cualquier cantidad de borrowings inmutables.

3. ¿Qué son los lifetimes?

Los lifetimes son anotaciones que el compilador de Rust necesita para verificar que las referencias no se vuelvan colgantes. Se usan más comúnmente en funciones que devuelven referencias.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {    if x.len() > y.len() { x } else { y }}

fn main() {    let s1 = String::from("larga");    let s2 = "corta";    let result = longest(&s1, s2);    println!("El string más largo: {}", result);}

Truco: en la mayoría de los casos, el compilador infiere el lifetime por sí mismo (elision). Las anotaciones solo son necesarias para casos complejos.

4. ¿Qué son los traits y cómo se usan?

Los traits son el equivalente de las interfaces en otros lenguajes. Definen un comportamiento común para diferentes tipos.

trait Summary {    fn summarize(&self) -> String;}

struct Article {    title: String,    content: String,}

impl Summary for Article {    fn summarize(&self) -> String {        format!("{}: {}...", self.title, &self.content[..20])    }}

fn main() {    let article = Article {        title: String::from("Rust"),        content: String::from("Rust es un lenguaje seguro y rápido"),    };    println!("{}", article.summarize());}

Importante: los traits pueden tener implementaciones por defecto y pueden ser parametrizados (traits genéricos).

5. ¿Cuál es la diferencia entre String y &str?

Esta es una de las preguntas más frecuentes. String es un string mutable, owned, almacenado en el heap. &str es un borrowing inmutable de un string slice, que puede referenciar a un String, un literal de string o una parte de un string.

fn main() {    let s1 = String::from("hello");  // String    let s2: &st