Test de Rust: 24 preguntas para comprobar lo que sabes

¿Cuánto Rust sabes de verdad? Estas 24 preguntas repasan las 10 lecciones de nuestro curso de Rust: propiedad y préstamos, tipos y conversiones, structs y enums, pattern matching, colecciones e iteradores, errores con Result y el operador ?, traits y genéricos, módulos y concurrencia. Elige una respuesta en cada pregunta y pulsa Corregir al final: verás tu nota, los aciertos por lección y la explicación de cada respuesta.

No hace falta registrarse y nada se envía a ningún sitio: el test se corrige en tu propio navegador. Todas las respuestas con código se comprobaron compilando y ejecutando el código con Rust 1.99.

Pregunta 1Lección 1: Instalación y primer programa

¿Qué es Cargo?

El compilador de RustEl gestor de paquetes y sistema de construcción de RustEl instalador que descarga Rust y lo mantiene al díaUn editor de código para Rust

Cargo crea proyectos, descarga dependencias, compila, ejecuta y prueba. El compilador es rustc, y el instalador, rustup. Ver la lección 1.

Pregunta 2Lección 1: Instalación y primer programa

¿Por qué println! lleva un signo de exclamación?

Porque imprime con salto de líneaPorque puede provocar un pánicoPorque escribe en la salida de erroresPorque es una macro, no una función

El ! marca una macro: código que se expande al compilar. Por eso println! admite un número variable de argumentos y comprueba el formato antes de ejecutar. Ver la lección 1.

Pregunta 3Lección 2: Propiedad y préstamos

¿Qué ocurre al compilar este programa?

fn main() {
    let a = String::from("hola");
    let b = a;
    println!("{a}");
}

Imprime holaImprime una cadena vacíaNo compila: el valor se movió de a a bCompila, pero da un pánico al ejecutarse

Al asignar un String a otra variable, el valor cambia de dueño y a deja de ser válida. El compilador lo rechaza con el error E0382: borrow of moved value: `a`. Ver la lección 2.

Pregunta 4Lección 2: Propiedad y préstamos

¿Cuál es la regla de los préstamos en Rust?

Puede haber muchos préstamos de lectura o uno solo de escritura, pero no las dos cosas a la vezSolo se puede prestar un valor una vez en todo el programaPuede haber tantos préstamos de escritura como se quiera si están en hilos distintosUn préstamo siempre copia el valor

Pregunta 5Lección 2: Propiedad y préstamos

¿Qué imprime este programa?

fn longitud(s: &str) -> usize {
    s.len()
}

fn main() {
    let texto = String::from("hola mundo");
    let n = longitud(&texto);
    println!("{texto} {n}");
}

hola mundo 10No compila: texto se movió a la función10hola mundo 2

Con &texto la función recibe un préstamo, no la propiedad, así que texto sigue siendo válida después de la llamada. Ver la lección 2.

Pregunta 6Lección 3: Tipos, variables y funciones

¿Qué ocurre al compilar este programa?

fn main() {
    let x = 5;
    x = 6;
    println!("{x}");
}

Imprime 6Imprime 5No compila: x no es mutableImprime 11

Las variables no se pueden reasignar salvo que se declaren con let mut. El error es E0384: cannot assign twice to immutable variable. Ver la lección 3.

Pregunta 7Lección 3: Tipos, variables y funciones

¿Qué imprime este programa?

fn main() {
    let grande: u32 = 300;
    let t = grande as u8;
    println!("{t}");
}

255300Da un pánico por desbordamiento44

Un u8 solo llega a 255, y as descarta en silencio los bits que no caben: queda 44. Si no sabes si el valor cabe, usa u8::try_from, que devuelve un Result. Ver la lección 3.

Pregunta 8Lección 3: Tipos, variables y funciones

¿Por qué no compila esta función?

fn doble(x: i32) -> i32 {
    x * 2;
}

Porque falta la palabra returnPorque el punto y coma convierte la expresión en una instrucción y la función devuelve ()Porque x debería ser mutPorque no se puede multiplicar un i32 por un literal

La última expresión sin punto y coma es el valor del bloque. Con el punto y coma no devuelve nada, y el compilador protesta con E0308: mismatched types, se esperaba i32 y se encontró (). Ver la lección 3.

Pregunta 9Lección 4: Structs y enums

¿Qué imprime este programa?

#[derive(Debug, Clone, Copy, PartialEq)]
struct Punto {
    x: i32,
    y: i32,
}

fn main() {
    let a = Punto { x: 1, y: 2 };
    let b = a;
    println!("{}", a == b);
}

No compila: a se movió a bfalsePunto { x: 1, y: 2 }true

Como Punto deriva Copy, let b = a; hace una copia y a sigue siendo válida. Sin Copy, esa línea movería el valor y no compilaría. Ver la lección 4.

Pregunta 10Lección 4: Structs y enums

En un bloque impl, ¿qué recibe un método declarado con &mut self?

Una copia del valorUn préstamo que permite modificar el valor en su sitioEl valor entero, en propiedad, que deja de existir al terminarNada: es un constructor

&self presta para leer, &mut self presta para modificar y self se queda con el valor. Los constructores, como nuevo, no reciben self. Ver la lección 4.

Pregunta 11Lección 5: Pattern matching

¿Qué imprime este programa?

fn main() {
    let esperado = 5;
    let numero = 7;
    match numero {
        esperado => println!("coincide"),
        _ => println!("no coincide"),
    }
}

no coincideNo compilacoincideNo imprime nada

Un nombre en minúsculas dentro de un patrón no compara: crea una variable nueva que encaja con cualquier valor. El compilador avisa con unreachable pattern. Para comparar, usa una guarda: n if n == esperado. Ver la lección 5.

Pregunta 12Lección 5: Pattern matching

¿Qué pasa si a un match sobre un enum le falta una de sus variantes?

No compila: el match tiene que cubrir todos los casosSe ejecuta la primera ramaDa un pánico si llega la variante que faltaNo hace nada con esa variante

Un match tiene que ser exhaustivo. Si falta una variante, el error es E0004: non-exhaustive patterns, y el mensaje dice cuál falta. Ver la lección 5.

Pregunta 13Lección 6: Colecciones e iteradores

¿Qué imprime este programa?

fn main() {
    let v = vec![1, 2, 3];
    println!("{:?}", v.get(9));
}

Da un pánico: index out of bounds0NoneNo compila

get devuelve un Option: None si el índice no existe. Con v[9], en cambio, el programa se detendría con index out of bounds. Ver la lección 6.

Pregunta 14Lección 6: Colecciones e iteradores

¿Qué imprime este programa?

fn main() {
    let v = vec![1, 2, 3];
    let r: Vec<i32> = v.iter().map(|n| n * 10).filter(|n| *n > 10).collect();
    println!("{r:?}");
}

[10, 20, 30][20, 30][2, 3][]

Primero se multiplica cada elemento por 10 y luego se quedan los mayores que 10. Los adaptadores no hacen nada hasta que collect pide el resultado. Ver la lección 6.

Pregunta 15Lección 6: Colecciones e iteradores

¿Qué ocurre al compilar este programa?

fn main() {
    let v = vec![1, 2, 3];
    for n in v {
        print!("{n} ");
    }
    println!("{v:?}");
}

No compila: el for se quedó con el vectorImprime 1 2 3 [1, 2, 3]Imprime 1 2 3 []Da un pánico en el segundo println!

for n in v consume el vector, así que después ya no existe (error E0382). Para recorrerlo y seguir usándolo, for n in &v. Ver la lección 6.

Pregunta 16Lección 7: Manejo de errores

Dentro de una función que devuelve Result, ¿qué hace el operador ? cuando la operación da Err?

Detiene el programa con un pánicoIgnora el error y continúa con un valor por defectoConvierte el error en None y sigueSale de la función y devuelve ese error a quien la llamó

Si es Ok, saca el valor y sigue; si es Err, abandona la función ahí mismo devolviendo el error. Sustituye al match de propagación escrito a mano. Ver la lección 7.

Pregunta 17Lección 7: Manejo de errores

¿Qué ocurre al compilar este programa?

fn main() {
    let n: i32 = "42".parse()?;
    println!("{n}");
}

Imprime 42Da un pánicoImprime 0No compila: ? solo se puede usar en una función que devuelva Result u Option

Este main devuelve (), y ? necesita poder devolver el error. El compilador lo rechaza con E0277. Basta con declarar fn main() -> Result<(), Box<dyn Error>>. Ver la lección 7.

Pregunta 18Lección 7: Manejo de errores

¿Qué imprime este programa?

fn main() {
    let p: u16 = "abc".parse().unwrap_or(8080);
    println!("{p}");
}

Da un pánico08080No compila

"abc" no es un número, así que parse da Err y unwrap_or devuelve el valor por defecto, 8080. Ver la lección 7.

Pregunta 19Lección 8: Traits y genéricos

¿Por qué no compila esta función?

fn mayor<T>(lista: &[T]) -> &T {
    let mut m = &lista[0];
    for x in lista {
        if x > m {
            m = x;
        }
    }
    m
}

Porque las funciones genéricas no pueden devolver referenciasPorque falta el límite T: PartialOrd: no todos los tipos se pueden comparar con >Porque m no puede ser mutPorque hay que escribir return m;

Rust comprueba el genérico al compilar la función: sin un límite que garantice que T se puede comparar, el > no se acepta (E0369). Con fn mayor<T: PartialOrd> compila y sirve para números y para textos. Ver la lección 8.

Pregunta 20Lección 8: Traits y genéricos

Quieres guardar en un mismo vector un Circulo y un Cuadrado, dos tipos distintos que implementan el trait Figura. ¿Qué tipo usas?

Vec<Box<dyn Figura>>Vec<impl Figura>Vec<dyn Figura>Vec<Figura>

Los elementos de un Vec tienen que medir lo mismo, y cada figura ocupa distinto. Box guarda el valor aparte y dyn decide el método al ejecutar. Vec<impl Figura> no está permitido en una variable, y Vec<dyn Figura> no compila porque su tamaño no se conoce. Ver la lección 8.

Pregunta 21Lección 9: Módulos y crates

¿Qué ocurre al compilar este programa?

mod tienda {
    pub struct Articulo {
        pub nombre: String,
        precio: f64,
    }
}

fn main() {
    let a = tienda::Articulo { nombre: String::from("tuerca"), precio: 0.5 };
}

Compila: el struct es pubNo compila: el campo precio es privado aunque el struct sea públicoCompila, pero precio vale 0No compila porque falta use tienda;

Marcar un struct como pub no hace públicos sus campos: cada uno necesita su propio pub. El error es E0451: field `precio` of struct `Articulo` is private. Ver la lección 9.

Pregunta 22Lección 9: Módulos y crates

¿Para qué sirve cargo check?

Para ejecutar las pruebasPara buscar vulnerabilidades en las dependenciasPara formatear el códigoPara comprobar que el código compila sin generar el binario, mucho más rápido

Hace toda la comprobación de tipos y préstamos sin generar código máquina, por eso es la orden que se usa mientras se escribe. Las pruebas son cargo test, y el formato, cargo fmt. Ver la lección 9.

Pregunta 23Lección 10: Concurrencia sin miedo

Este programa no compila. ¿Qué hay que añadir para que funcione?

use std::thread;

fn main() {
    let v = vec![1, 2, 3];
    let h = thread::spawn(|| {
        println!("{v:?}");
    });
    h.join().unwrap();
}

move antes de la clausura: thread::spawn(move || …)unsafe antes de thread::spawnmut en let vUn &: println!("{:?}", &v)

Nada garantiza que el hilo termine antes que main, así que no puede llevarse un préstamo de v (error E0373). Con move el hilo se queda con la propiedad del vector. Ver la lección 10.

Pregunta 24Lección 10: Concurrencia sin miedo

Varios hilos tienen que sumar en el mismo contador. ¿Qué tipo se usa para compartirlo?

Rc<RefCell<i32>>Box<i32>Arc<Mutex<i32>>&mut i32

Arc permite que varios hilos sean dueños del mismo valor, y Mutex deja tocarlo a uno cada vez. Rc no sirve entre hilos: no es Send y el compilador lo rechaza (E0277). Ver la lección 10.

Las preguntas siguen el orden del curso. Si fallas alguna, el enlace de su explicación te lleva a la lección donde se explica con ejemplos. Imagen para redes: código en un monitor, foto de Markus Spiske, Wikimedia Commons, CC0.