Learn Rust Coding · Aula

Expressões e instruções

A última expressão

Expressões e instruções é 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.

Instruções versus expressões

O Rust distingue dois tipos de código:

Instruções executam uma ação e não retornam nenhum valor.
Expressões são avaliadas como um valor.

Essa distinção define como as funções retornam valores.

fn main() {
    let x = 5;      // a let statement
    let y = x + 1;  // x + 1 is an expression
    println!("{}", y);
}

let é uma instrução

Uma vinculação let é uma instrução. Ela não retorna um valor, portanto você não pode escrever let a = (let b = 6);.

fn main() {
    let a = 6;
    // let c = (let d = 6); // error: let is not an expression
    println!("{}", a);
}

Expressões são avaliadas como valores

Aritmética, chamadas de função e literais são expressões porque produzem um valor.

5
2 + 3
square(4)

fn main() {
    let v = 2 + 3 * 4;
    println!("{}", v);
}

Blocos são expressões

Um bloco { ... } é uma expressão por si só. Seu valor é a última expressão interna, se ela não tiver ponto e vírgula ao final.

fn main() {
    let y = {
        let x = 3;
        x + 1
    };
    println!("y is {}", y);
}

O ponto e vírgula é importante

Adicionar um ponto e vírgula transforma uma expressão em uma instrução, descartando seu valor.

x + 1 — expressão que produz um valor.
x + 1; — instrução que produz ().

fn main() {
    let y = {
        let x = 3;
        x + 1   // no semicolon: this is the block's value
    };
    println!("{}", y);
}

A última expressão é retornada

Em uma função, a expressão final sem ponto e vírgula torna-se o valor de retorno. Esse é o estilo idiomático do Rust.

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

fn five() -> i32 {
    5
}

O ponto e vírgula interrompe os retornos

Se você adicionar acidentalmente um ponto e vírgula à última linha, a função retornará () em vez do seu valor — um erro comum entre iniciantes.

fn main() {
    println!("{}", plus_one(10));
}

fn plus_one(n: i32) -> i32 {
    n + 1   // correct: no semicolon
}

if como expressão

Como if é uma expressão, você pode atribuir seu resultado a uma variável. Os dois ramos devem produzir o mesmo tipo.

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("number is {}", number);
}

loop como expressão

Um loop pode retornar um valor por meio de break. O valor depois de break torna-se o resultado do loop.

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("result {}", result);
}

match como expressão

Um match também é uma expressão. Cada ramo produz um valor, e o valor do ramo correspondente é o resultado.

fn main() {
    let n = 2;
    let label = match n {
        1 => "one",
        2 => "two",
        _ => "many",
    };
    println!("{}", label);
}

Juntando tudo

Tratar blocos e fluxo de controle como expressões torna o Rust conciso: você calcula e retorna em uma única etapa fluida.

fn main() {
    let score = 85;
    let grade = if score >= 90 { 'A' } else if score >= 80 { 'B' } else { 'C' };
    println!("grade {}", grade);
}

Verificação rápida

O que adicionar um ponto e vírgula faz com uma expressão?

Recapitulação

Expressões e instruções no Rust:

Instruções (como let) executam um trabalho, mas não retornam nenhum valor.
Expressões são avaliadas como um valor.
Blocos, if, match e loop são expressões.
A última expressão sem ponto e vírgula é o valor de retorno.

fn main() {
    let x = { let a = 2; a * a };
    let y = if x > 3 { "big" } else { "small" };
    println!("{} {}", x, y);
}

Perguntas Frequentes

A aula “Expressões e instruções” é grátis?

Sim — o texto completo de “Expressões e instruções” é 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 “Expressões e instruções”?

A última expressão 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 “Expressões e instruções”?

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