Reglas de elisión
Cuándo se infieren los lifetimes
Reglas de elisión es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 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.
Tiempos de vida que no tiene que escribir
Muchas funciones reciben y devuelven referencias sin ninguna anotación de tiempo de vida y, aun así, se compilan. Esto se debe a la elisión de tiempos de vida: el compilador infiere los tiempos de vida evidentes por usted.
La elisión es solo un atajo
La elisión no elimina los tiempos de vida; el compilador sigue completándolos internamente mediante unas reglas deterministas. Cuando esas reglas cubren su caso, puede omitir las anotaciones.
Una función con elisión
Esta función no tiene tiempos de vida explícitos, pero el compilador entiende que la referencia devuelta toma prestados datos de la entrada. Las reglas hacen que no haya ambigüedad.
fn first_word(s: &str) -> &str {
s.split(' ').next().unwrap_or("")
}
fn main() {
let phrase = String::from("rust is fun");
println!("{}", first_word(&phrase));
}Regla 1: cada entrada obtiene el suyo
La primera regla establece que cada tiempo de vida elidido en los parámetros recibe un tiempo distinto. Dos parámetros de referencia reciben dos tiempos de vida separados.
Regla 2: una entrada, una salida
La segunda regla establece que, si hay exactamente un tiempo de vida de entrada, este se asigna a todos los tiempos de vida de salida. Esto cubre funciones como first_word, que reciben y devuelven una referencia.
fn trim_start(s: &str) -> &str {
s.trim_start()
}
fn main() {
println!("[{}]", trim_start(" hi"));
}Regla 3: métodos y &self
La tercera regla establece que, si un método tiene &self o &mut self, el tiempo de vida de self se asigna a todos los tiempos de vida de salida. Por eso los métodos rara vez necesitan anotaciones.
struct Holder { value: String }
impl Holder {
fn get(&self) -> &str {
&self.value
}
}
fn main() {
let h = Holder { value: String::from("stored") };
println!("{}", h.get());
}Cuándo falla la elisión
Si, después de aplicar las tres reglas, algún tiempo de vida de salida sigue siendo desconocido, el compilador le pide que lo anote explícitamente. La función longest es el caso clásico: dos entradas y una salida ambigua.
La función longest de nuevo
Hay dos entradas de referencia y una salida de referencia: la regla 2 no se aplica, porque hay más de una entrada, y no existe self. Por tanto, debe añadir una anotación.
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() { x } else { y }
}
fn main() {
println!("{}", longest("abcd", "ab"));
}Varias entradas y una salida desde self
Un método con varios parámetros sigue obteniendo el tiempo de vida de salida de self mediante la regla 3, aunque existan otros parámetros de referencia.
struct Doc { body: String }
impl Doc {
fn announce(&self, _note: &str) -> &str {
&self.body
}
}
fn main() {
let d = Doc { body: String::from("content") };
println!("{}", d.announce("ping"));
}Por qué existen las reglas
Estas tres reglas cubren la inmensa mayoría del código real, por lo que la mayoría de las funciones no necesitan ninguna sintaxis de tiempos de vida. Solo debe escribir anotaciones cuando la intención sea realmente ambigua.
Una lista de comprobación rápida
Para decidir si se aplica la elisión, pregúntese:
- ¿Hay exactamente una referencia de entrada? La salida toma prestado su tiempo de vida.
- ¿Existe un
&self? La salida toma prestado el tiempo de vida de self. - En cualquier otro caso, anótelo explícitamente.
Comprobación rápida
Compruebe cuánto entiende las reglas de elisión.
Recapitulación
Ha aprendido cuándo se infieren los tiempos de vida:
- Regla 1: cada referencia de entrada obtiene su propio tiempo de vida
- Regla 2: un tiempo de vida de entrada se asigna a todas las salidas
- Regla 3:
&selfproporciona el tiempo de vida de salida en los métodos - Si las salidas siguen siendo ambiguas, debe anotarlas explícitamente
Preguntas frecuentes
¿La lección «Reglas de elisión» es gratis?
Sí — el texto completo de «Reglas de elisión» 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 «Reglas de elisión»?
Cuándo se infieren los 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 4 de 4.
¿Cuánto tiempo toma la lección «Reglas de elisión»?
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.