Conceptos de Lifetime en el Programa de Rust

Introducción

En este laboratorio, exploraremos el concepto de lifetimes en Rust y cómo el compilador los utiliza para garantizar la validez de los préstamos en el código. Los lifetimes son una construcción del compilador que determinan la duración de una variable, desde su creación hasta su destrucción. Si bien los lifetimes y los ámbitos están relacionados, no son lo mismo. Cuando se presta una variable utilizando el operador &, el préstamo tiene un lifetime que se determina por su declaración y es válido siempre y cuando termine antes de que el prestamista sea destruido. Sin embargo, el ámbito del préstamo se determina por donde se utiliza la referencia. El código de ejemplo proporcionado demuestra cómo se utilizan los lifetimes y los ámbitos en la práctica, con cada variable teniendo su propio lifetime y ámbito.

Nota: Si el laboratorio no especifica un nombre de archivo, puede utilizar cualquier nombre de archivo que desee. Por ejemplo, puede utilizar main.rs, compilar y ejecutarlo con rustc main.rs &&./main.

Skills Graph

Lifetimes

Un lifetime es una construcción del compilador (o más específicamente, su borrow checker) que se utiliza para garantizar que todos los préstamos son válidos. Específicamente, el lifetime de una variable comienza cuando se crea y termina cuando se destruye. Si bien los lifetimes y los ámbitos a menudo se mencionan juntos, no son lo mismo.

Tomemos, por ejemplo, el caso en el que prestamos una variable a través de &. El préstamo tiene un lifetime que se determina por donde se declara. Como resultado, el préstamo es válido siempre y cuando termine antes de que el prestamista sea destruido. Sin embargo, el ámbito del préstamo se determina por donde se utiliza la referencia.

En el siguiente ejemplo y en el resto de esta sección, veremos cómo los lifetimes se relacionan con los ámbitos, así como cómo difieren los dos.

// Los lifetimes se anotan a continuación con líneas que indican la creación
// y la destrucción de cada variable.
// `i` tiene el lifetime más largo porque su ámbito encierra por completo
// tanto `borrow1` como `borrow2`. La duración de `borrow1` en comparación
// con `borrow2` es irrelevante ya que son disjuntos.
fn main() {
    let i = 3; // El lifetime para `i` comienza. ────────────────┐
    //                                                     │
    { //                                                   │
        let borrow1 = &i; // El lifetime de `borrow1` comienza. ──┐│
        //                                                ││
        println!("borrow1: {}", borrow1); //              ││
    } // El lifetime de `borrow1` termina. ─────────────────────────┘│
    //                                                     │
    //                                                     │
    { //                                                   │
        let borrow2 = &i; // El lifetime de `borrow2` comienza. ──┐│
        //                                                ││
        println!("borrow2: {}", borrow2); //              ││
    } // El lifetime de `borrow2` termina. ─────────────────────────┘│
    //                                                     │
}   // El lifetime termina. ─────────────────────────────────────┘

Tenga en cuenta que no se le asignan nombres o tipos para etiquetar los lifetimes. Esto restringe cómo se podrán utilizar los lifetimes, como veremos.

Resumen

¡Felicidades! Has completado el laboratorio de Lifetimes. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.