Q1. ¿Qué tipo de conversión conserva el valor matemático en todos los casos?

• i64 como i32
• usize como u64
• i32 como i64
• f64 como f32

Q2. ¿Qué representan las barras verticales aquí?

str::thread::spawn(|| {
    println!("LinkedIn");
});

• un cierre
• un hilo
• un futuro
• un bloque

referencia

Q3. ¿Cuál opción no es un tipo de dato escalar?

• entero
• flotante
• booleano
• tupla

Q4. _ no puede ser desestructurado.

• Rasgos
• Tuplas
• Enumeraciones
• Estructuras

referencia

Q5. ¿Qué comando de cargo verifica un programa en busca de errores sin crear un ejecutable binario?

• cargo --version
• cargo init
• cargo build
• cargo check

Q6. El término box y frases relacionadas como boxear un valor se usan a menudo al relacionarse con el diseño de memoria. ¿A qué se refiere box?

• Está creando un puntero en el montón que apunta a un valor en la pila.
• Está creando un puntero en la pila que apunta a un valor en el montón.
• Está creando una guarda de memoria alrededor de valores para evitar accesos ilegales.
• Es una abstracción que se refiere a la propiedad. Los valores "boxeados" están claramente etiquetados.

Q7. ¿Cuál es una forma alternativa de escribir slice que produzca el mismo resultado?

...
let s = String::form("hello");
let slice = &s[0..2];

• let slice = &s[len + 2];
• let slice = &s[len - 2];
• let slice = &s.copy(0..2);
• let slice = &s[..2];

Q8. Usar el operador ? al final de una expresión es equivalente a _.

• un patrón de coincidencia que se ramifica en Verdadero o Falso
• llamar a ok_error()
• llamar a panic!()
• un patrón de coincidencia que puede resultar en una devolución temprana

Q9. ¿Cuál es la sintaxis válida para definir una matriz de valores i32?

• Array<i32>::with_capacity(10)
• [i32]
• Array<i32>::new(10)
• [i32; 10]

Q10. ¿Qué sintaxis se requiere para tomar una referencia mutable a T, cuando se usa dentro de un argumento de función?

fn increment(i: T) {
    // cuerpo omitido
}

• *mut T
• mut ref T
• mut &T
• &mut T

Q11. Los punteros inteligentes Rc y Arc proporcionan conteo de referencias. ¿Cuál es la API para incrementar un conteo de referencia?

• .add()
• .incr()
• .clone()
• .incremento()

referencia

Q12. ¿Qué sucede cuando ocurre un error que está siendo manejado por el operador de interrogación (?)?

• El error se informa y la ejecución continúa.
• Se genera una excepción. El o los efectos de la excepción están definidos por la macro error!.
• El programa entra en pánico inmediatamente.
• Rust intenta convertir el error al tipo de error de la función local y devolverlo como Result::Err. Si eso falla, el programa entra en pánico.

Q13. ¿Qué sintaxis de comentario no es legal?

• /*
• #
• //!
• //

Q14. En los patrones de coincidencia, los valores se ignoran con _.

• .ignorar()
• un guion bajo (_)
• ..
• saltar

Q15. Definir un _ requiere un parámetro de duración.

• función que termina la duración de uno de sus argumentos
• estructura que contiene una referencia a un valor
• función con un argumento genérico
• estructura que contiene una referencia a un valor encajado

Referencia del libro Rust

Q16. ¿Qué ejemplo utiliza correctamente la API de entrada de std::collections::HashMap para poblar conteos?

use std::collections::HashMap;
fn main() {
    let mut counts = HashMap::new();
    let text = "LinkedIn Learning";
    for c in text.chars() {
        // Completa este bloque
    }
    println!("{:?}", counts);
}

• ­

for c in text.chars() {
    if let Some(count) = &mut counts.get(&c) {
        counts.insert(c, *count + 1);
    } else {
        counts.insert(c, 1);
    };
}

• ­

for c in text.chars() {
    let count = counts.entry(c).or_insert(0);
    *count += 1;
}

• ­

for c in text.chars() {
    let count = counts.entry(c);
    *count += 1;
}

• ­

for c in text.chars() {
    counts.entry(c).or_insert(0).map(|x| x + 1);
}

referencia

Q17. ¿Qué fragmento no incurre en asignaciones de memoria al escribir en un "archivo" (representado por un Vec<u8>)?

rust
use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut v = Vec::<u8>::new();

    let a = "LinkedIn";
    let b = 123;
    let c = '🧀';

    // reemplaza esta línea

    println!("{:?}", v);

    Ok(())
}

• :

write!(&mut v, "{}{}{}", a, b, c)?;

• :

v.write(a)?;
v.write(b)?;
v.write(c)?;

• :

v.write(a, b, c)?;

• :

v.write_all(a.as_bytes())?;
v.write_all(&b.to_string().as_bytes())?;
c.encode_utf8(&mut v);

1. Respondido en el foro de usuarios de Rust
2. referencia

Q18. ¿Compila la función main? Si es así, ¿por qué? Si no, ¿qué necesitas cambiar?

fn main() {
    let Some(x) = some_option_value;
}

• El código no compila. Las declaraciones let requieren un patrón refutable. Agrega if antes de let.
• El código compila. Las declaraciones let a veces requieren un patrón refutable.
• El código no compila. Las declaraciones let requieren un patrón irrefutable. Agrega if antes de let.
• El código compila. Las declaraciones let no requieren un patrón refutable.

Q19. ¿Cuál afirmación sobre las duraciones es falsa?

• Las duraciones se especificaban de manera redundante en versiones anteriores de Rust.
• Las duraciones se especifican cuando una estructura tiene una referencia a un valor.
• Las duraciones se especifican cuando ciertos valores deben sobrevivir a otros.
• Las duraciones siempre son inferidas por el compilador.

Q20. Cuando se usa como tipo de retorno, ¿qué tipo de Rust desempeña un papel similar a None de Python, null de JavaScript o el tipo void en C/C++?

• !
• None
• Null
• ()