Learn Rust Coding · Aula

Anotações de lifetime

Nomeação de lifetimes

Anotações de lifetime é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Dando nome a um tempo de vida

Uma anotação de tempo de vida é um nome que começa com um apóstrofo, como 'a. Ela não altera por quanto tempo algo vive; ela descreve relações entre os tempos de vida das referências.

Onde colocar as anotações

Você declara os parâmetros de tempo de vida entre sinais de menor e maior depois do nome da função e então os usa nos tipos de referência, assim como faz com os parâmetros de tipo genérico.

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

A função longest clássica

Uma função que retorna uma de duas referências precisa de uma anotação. 'a diz que o resultado vive tanto quanto a mais curta das duas 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));
}

O que 'a significa aqui

A anotação informa ao compilador: a referência retornada só é válida enquanto ambas as entradas forem válidas. O compilador então verifica cada ponto de chamada em relação a esse contrato.

Por que isso é necessário

Sem a anotação, o compilador não consegue saber se o retorno toma emprestado de x ou de y. O nome do tempo de vida os vincula para que o verificador de empréstimos possa raciocinar sobre o resultado.

Tempos de vida diferentes

Quando as referências não estão relacionadas, dê a elas nomes de tempos de vida diferentes. Aqui, apenas x é retornado, então somente o tempo de vida dele importa para o 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));
}

Os tempos de vida não prolongam a vida

As anotações nunca fazem os dados viverem mais. Elas apenas declaram restrições que o compilador deve verificar. Se um valor deixar de existir cedo demais, o código não será compilado, independentemente das anotações.

Uma chamada válida

Desde que ambas as entradas continuem vivas além do uso do resultado, a chamada será aceita. Aqui, as duas strings permanecem vivas até a impressão, então está tudo certo.

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);
    }
}

Tempos de vida com genéricos

Parâmetros de tempo de vida e de tipo podem aparecer juntos. Os tempos de vida são listados primeiro entre os sinais de menor e maior.

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));
}

O tempo de vida 'static

'static é um tempo de vida especial que significa que a referência pode viver durante todo o programa. Literais de string têm esse tempo de vida porque são incorporados ao binário.

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

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

Lendo as anotações

Leia &'a str como uma referência de string válida durante o tempo de vida 'a. Quando dois parâmetros compartilham 'a, o compilador vincula seus tempos de vida ao que for mais curto em cada chamada.

Verificação rápida

Teste sua compreensão das anotações de tempo de vida.

Recapitulação

Você aprendeu a dar nomes aos tempos de vida:

Os tempos de vida usam nomes como 'a, declarados entre sinais de menor e maior
Nomes compartilhados expressam que as referências estão relacionadas (por exemplo, o resultado está vinculado às entradas)
As anotações descrevem os tempos de vida, mas nunca os prolongam
'static significa válido durante todo o programa

Perguntas Frequentes

A aula “Anotações de lifetime” é grátis?

Sim — o texto completo de “Anotações de lifetime” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Anotações de lifetime”?

Nomeação de lifetimes Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Anotações de lifetime”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding