Learn Rust Coding · Aula

Regras de omissão

Quando os lifetimes são inferidos

Regras de omissão é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 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.

Tempos de vida que você não escreve

Muitas funções recebem e retornam referências sem nenhuma anotação de tempo de vida, mas ainda assim são compiladas. Isso acontece por causa da elisão de tempos de vida: o compilador infere os tempos de vida óbvios para você.

A elisão é apenas um atalho

A elisão não remove os tempos de vida; o compilador ainda os preenche nos bastidores usando algumas regras determinísticas. Quando as regras abrangem o seu caso, você pode omitir as anotações.

Uma função com tempo de vida omitido

Esta função não tem tempos de vida explícitos, mas o compilador entende que a referência retornada toma dados emprestados da entrada. As regras tornam isso inequívoco.

fn first_word(s: &str) -> &str {
    s.split(' ').next().unwrap_or("")
}

fn main() {
    let phrase = String::from("rust is fun");
    println!("{}", first_word(&phrase));
}

Regra 1: cada entrada recebe seu próprio tempo de vida

A primeira regra: cada tempo de vida omitido nos parâmetros recebe um tempo de vida distinto. Dois parâmetros de referência recebem dois tempos de vida separados.

Regra 2: uma entrada, uma saída

A segunda regra: se houver exatamente um tempo de vida de entrada, ele será atribuído a todos os tempos de vida de saída. Isso abrange funções como first_word, que recebem e retornam uma referência.

fn trim_start(s: &str) -> &str {
    s.trim_start()
}

fn main() {
    println!("[{}]", trim_start("   hi"));
}

Regra 3: métodos e &self

A terceira regra: se um método tiver &self ou &mut self, o tempo de vida de self é atribuído a todos os tempos de vida de saída. Por isso, os métodos raramente precisam de anotações.

struct Holder { value: String }

impl Holder {
    fn get(&self) -> &str {
        &self.value
    }
}

fn main() {
    let h = Holder { value: String::from("stored") };
    println!("{}", h.get());
}

Quando a Elisão Falha

Se, depois de aplicar as três regras, algum tempo de vida de saída ainda for desconhecido, o compilador solicita que o anote explicitamente. A função longest é o caso clássico: duas entradas e uma saída ambígua.

A Função longest Novamente

Duas entradas que são referências e uma saída que é uma referência: a regra 2 não se aplica (há mais de uma entrada) e não existe self. Portanto, você precisa fazer a anotação.

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

Várias Entradas, Saída Derivada de self

Um método com vários parâmetros ainda obtém o tempo de vida da saída a partir de self pela regra 3, mesmo que existam outros parâmetros que sejam referências.

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 Que as Regras Existem

Essas três regras abrangem a grande maioria do código real, portanto a maior parte das funções não precisa de nenhuma sintaxe de tempo de vida. Você só escreve anotações quando a intenção é realmente ambígua.

Uma Lista de Verificação Rápida

Para decidir se a elisão se aplica, pergunte:

Existe exatamente uma referência de entrada? A saída toma emprestado dela.
Existe um &self? A saída toma emprestado de self.
Caso contrário, faça a anotação explicitamente.

Verificação Rápida

Teste sua compreensão das regras de elisão.

Recapitulação

Você aprendeu quando os tempos de vida são inferidos:

Regra 1: cada referência de entrada recebe seu próprio tempo de vida
Regra 2: um tempo de vida de entrada é associado a todas as saídas
Regra 3: &self fornece o tempo de vida da saída nos métodos
Se as saídas continuarem ambíguas, você faz a anotação explicitamente

Perguntas Frequentes

A aula “Regras de omissão” é grátis?

Sim — o texto completo de “Regras de omissão” é 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 “Regras de omissão”?

Quando os lifetimes são inferidos 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 4 de 4.

Quanto tempo leva a aula “Regras de omissão”?

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