Learn Rust Coding · Lección

Anotaciones de lifetime

Nombrar lifetimes

Anotaciones de lifetime es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

Asignar un nombre a un tiempo de vida

Una anotación de tiempo de vida es un nombre que comienza con un apóstrofo, como 'a. No cambia cuánto vive nada; describe las relaciones entre los tiempos de vida de las referencias.

Dónde van las anotaciones

Declare los parámetros de tiempo de vida entre corchetes angulares después del nombre de la función y utilícelos después en los tipos de referencia, igual que los parámetros de tipo genérico.

Sintaxis: fn name<'a>(x: &'a T) -> &'a T.

La función longest clásica

Una función que devuelve una de dos referencias necesita una anotación. 'a indica que el resultado vive tanto como la más corta de las dos entradas.

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

fn main() {
    let a = String::from("long string");
    let b = String::from("short");
    println!("{}", longest(&a, &b));
}

Qué significa 'a aquí

La anotación indica al compilador que la referencia devuelta solo es válida mientras ambas entradas sean válidas. Después, el compilador comprueba cada lugar donde se llama a la función según este contrato.

Por qué es necesaria

Sin la anotación, el compilador no puede saber si el valor devuelto toma prestado de x o de y. El nombre del tiempo de vida los relaciona para que el comprobador de préstamos pueda razonar sobre el resultado.

Tiempos de vida distintos

Cuando las referencias no están relacionadas, asígneles nombres de tiempo de vida distintos. Aquí solo se devuelve x, por lo que solo su tiempo de vida importa para el resultado.

fn first<'a, 'b>(x: &'a str, _y: &'b str) -> &'a str {
    x
}

fn main() {
    let a = String::from("keep me");
    let b = String::from("ignore");
    println!("{}", first(&a, &b));
}

Los tiempos de vida no prolongan la vida

Las anotaciones nunca hacen que los datos vivan más tiempo. Solo expresan restricciones que el compilador debe verificar. Si un valor deja de existir demasiado pronto, el código no se compilará, independientemente de las anotaciones.

Una llamada válida

Siempre que ambas entradas vivan más que el uso del resultado, la llamada se acepta. Aquí ambas cadenas viven hasta la instrucción de impresión, por lo que todo funciona correctamente.

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

fn main() {
    let a = String::from("abcdef");
    let result;
    {
        let b = String::from("xy");
        result = longest(&a, &b);
        println!("chosen: {}", result);
    }
}

Tiempos de vida con genéricos

Los parámetros de tiempo de vida y de tipo pueden aparecer juntos. Los tiempos de vida se escriben primero dentro de los corchetes angulares.

use std::fmt::Display;

fn announce<'a, T: Display>(text: &'a str, value: T) -> &'a str {
    println!("value is {}", value);
    text
}

fn main() {
    let msg = String::from("hello");
    println!("{}", announce(&msg, 42));
}

El tiempo de vida 'static

'static es un tiempo de vida especial que significa que la referencia puede vivir durante todo el programa. Los literales de cadena lo tienen porque están incorporados en el binario.

fn motto() -> &'static str {
    "fearless concurrency"
}

fn main() {
    println!("{}", motto());
}

Leer anotaciones

Lea &'a str como una referencia a una cadena válida durante el tiempo de vida 'a. Cuando dos parámetros comparten 'a, el compilador vincula sus tiempos de vida al que sea más corto en cada llamada.

Comprobación rápida

Compruebe cuánto entiende las anotaciones de tiempo de vida.

Resumen

Ha aprendido a asignar nombres a los tiempos de vida:

Los tiempos de vida utilizan nombres como 'a, declarados entre corchetes angulares
Los nombres compartidos expresan que las referencias están relacionadas, por ejemplo, que el resultado está vinculado a las entradas
Las anotaciones describen los tiempos de vida, pero nunca los prolongan
'static significa que algo es válido durante todo el programa

Preguntas frecuentes

¿La lección «Anotaciones de lifetime» es gratis?

Sí — el texto completo de «Anotaciones de lifetime» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Anotaciones de lifetime»?

Nombrar lifetimes Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Anotaciones de lifetime»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding