Learn Rust Coding · Aula

Vinculação com @

Capture e teste

Vinculação com @ é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 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.

O operador de atribuição @

O operador @ permite testar um valor em relação a um padrão e atribuir esse valor a um nome ao mesmo tempo. Você obtém tanto a verificação quanto o valor.

O problema que ele resolve

Com um padrão de intervalo, você sabe que um valor está dentro do intervalo, mas perde acesso ao valor específico. @ captura esse valor enquanto ainda testa o intervalo.

Atribuição básica com @

Aqui fazemos a correspondência de um número em um intervalo e mantemos seu valor exato por meio de id.

fn main() {
    let n = 5;
    match n {
        id @ 1..=5 => println!("got {id} in range"),
        _ => println!("out of range"),
    }
}

Sem @

Compare: um braço simples de intervalo faz a correspondência, mas não pode dar um nome ao valor; portanto, você não pode mostrar qual número correspondeu.

fn main() {
    let n = 5;
    match n {
        1..=5 => println!("in range (value unknown here)"),
        _ => println!("out of range"),
    }
}

@ com dados de enumeração

Atribua um campo ao mesmo tempo que o restringe. Aqui capturamos o id somente se ele estiver dentro de um intervalo válido.

enum Message {
    Hello { id: i32 },
}

fn main() {
    let msg = Message::Hello { id: 7 };
    match msg {
        Message::Hello { id: id @ 3..=10 } => {
            println!("valid id {id}");
        }
        Message::Hello { id } => {
            println!("other id {id}");
        }
    }
}

Atribuindo o valor inteiro

@ também pode atribuir um valor estruturado inteiro enquanto um padrão aninhado verifica suas partes.

fn main() {
    let point = (3, 4);
    match point {
        p @ (x, _) if x > 0 => println!("{:?} has positive x", p),
        p => println!("{:?}", p),
    }
}

Combinando com |

Você pode fazer atribuições em padrões alternativos. O nome deve aparecer em cada ramo alternativo.

fn main() {
    let code = 404;
    match code {
        c @ (400 | 404 | 500) => println!("error code {c}"),
        c => println!("code {c}"),
    }
}

@ em if let

As atribuições com @ também funcionam em if let.

fn main() {
    let value = Some(50);
    if let Some(n @ 1..=100) = value {
        println!("in range: {n}");
    }
}

Quando usar @

Use @ quando precisar de ambos:

Restringir um valor com um intervalo ou subpadrão
Usar esse valor exato no corpo do braço

Sem essas duas necessidades, uma atribuição ou um padrão simples é mais adequado.

Legibilidade

A forma é lida como name @ pattern: atribua name se ele corresponder a pattern. Use nomes descritivos para deixar a intenção clara.

Agrupamento com @

Um uso comum é classificar um valor em grupos rotulados mantendo o número original para relatórios.

fn classify(temp: i32) -> String {
    match temp {
        t @ ..=0 => format!("freezing ({t})"),
        t @ 1..=20 => format!("cool ({t})"),
        t @ 21..=30 => format!("warm ({t})"),
        t => format!("hot ({t})"),
    }
}

fn main() {
    println!("{}", classify(25));
}

Verificação rápida

O que o operador @ faz em um padrão como id @ 1..=5?

Recapitulação

Você aprendeu o operador de atribuição @:

Ele atribui um valor a um nome enquanto o testa em relação a um padrão
Resolve o problema de perder o valor em padrões de intervalo
Funciona com dados de enumeração, tuplas, alternativas com | e if let
Use-o quando precisar tanto da restrição quanto do valor

Perguntas Frequentes

A aula “Vinculação com @” é grátis?

Sim — o texto completo de “Vinculação com @” é 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 “Vinculação com @”?

Capture e teste 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 3 de 4.

Quanto tempo leva a aula “Vinculação com @”?

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