Por que usar lifetimes
Prevenção de referências pendentes
Por que usar lifetimes é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 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.
As referências devem permanecer válidas
Uma referência toma dados emprestados, mas não é proprietária deles. Rust precisa garantir que os dados permaneçam vivos pelo menos tanto quanto a referência. Tempos de vida são a forma como o compilador acompanha isso.
Sua função é evitar referências pendentes.
O que é uma referência pendente?
Uma referência pendente aponta para uma memória que foi liberada. Em linguagens sem verificações, usar uma causa falhas ou problemas de segurança. Rust se recusa a compilar esse código.
O verificador de empréstimos em ação
Este código criaria uma referência para um valor que sai do escopo. Rust o rejeita em tempo de compilação. Os tempos de vida são a regra usada para decidir isso.
fn main() {
let r;
{
let x = 5;
r = &x;
println!("inside: {}", r);
}
// using r here would be a dangling reference
println!("done");
}Os escopos definem os tempos de vida
O tempo de vida de um valor é o intervalo em que ele é válido, geralmente seu escopo. Uma referência não pode viver mais que o valor para o qual aponta.
Aqui, tanto x quanto a referência vivem no mesmo escopo, então está tudo certo.
fn main() {
let x = 5;
let r = &x;
println!("x is {}, r is {}", x, r);
}Retornando referências
Uma função que retorna uma referência deve retornar uma que continue válida para quem a chama. Você não pode retornar uma referência para uma variável local, pois ela deixa de existir quando a função termina.
Retornando um empréstimo de uma entrada
O que você pode fazer é retornar uma referência que tome emprestado de uma entrada. O resultado será válido enquanto essa entrada for válida. É exatamente isso que as anotações de tempo de vida descrevem.
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &b) in bytes.iter().enumerate() {
if b == b' ' {
return &s[..i];
}
}
s
}
fn main() {
let sentence = String::from("hello world");
println!("{}", first_word(&sentence));
}Os tempos de vida existem apenas em tempo de compilação
Os tempos de vida são um conceito puramente de tempo de compilação. Eles não acrescentam nenhum custo em tempo de execução e existem apenas para permitir que o verificador de empréstimos confirme a segurança da memória.
Propriedade e tempos de vida juntos
A propriedade decide quem libera um valor; os tempos de vida decidem por quanto tempo os empréstimos dele podem existir. Juntos, eles permitem que Rust garanta segurança sem um coletor de lixo.
fn main() {
let data = vec![1, 2, 3];
let view = &data[0..2];
println!("{:?}", view);
// data still owns the vector; view just borrows part of it
println!("{:?}", data);
}Por que os nomes aparecem nas assinaturas
Quando uma função recebe várias referências, às vezes o compilador não consegue determinar como os tempos de vida delas se relacionam. Nesse caso, você adiciona anotações de tempo de vida para esclarecer essas relações.
A próxima lição aborda essa sintaxe.
A vantagem
Graças aos tempos de vida, uma categoria inteira de erros — uso após liberação, ponteiros pendentes e invalidação de iteradores — simplesmente não pode ser compilada. Você obtém a velocidade de C com segurança de memória.
Modelo mental
Pense em um tempo de vida como um rótulo para a duração em que os dados permanecem vivos. Uma referência carrega a restrição: só sou válida enquanto minha fonte estiver viva. O verificador de empréstimos impõe essa regra.
Verificação rápida
Teste sua compreensão de por que os tempos de vida existem.
Recapitulação
Você aprendeu por que os tempos de vida existem:
- As referências não podem viver mais que os dados que tomam emprestados
- Os tempos de vida evitam referências pendentes em tempo de compilação
- Eles existem apenas em tempo de compilação, sem custo em tempo de execução
- Eles trabalham junto com a propriedade para garantir segurança de memória sem um coletor de lixo
Perguntas Frequentes
A aula “Por que usar lifetimes” é grátis?
Sim — o texto completo de “Por que usar lifetimes” é 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 “Por que usar lifetimes”?
Prevenção de referências pendentes 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 1 de 4.
Quanto tempo leva a aula “Por que usar lifetimes”?
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
- Por que usar lifetimes
- Anotações de lifetime
- Lifetimes em structs
- Regras de omissão