Fundamentos de Programação Rust: Ligações de Variáveis e Expressões

Introdução

Neste laboratório, um programa Rust é composto principalmente de instruções que podem incluir ligações de variáveis e expressões. As instruções são designadas por um ;, enquanto as expressões são seguidas por um ; e podem ser usadas como valores em atribuições. Além disso, os blocos também são considerados expressões e podem ser atribuídos a variáveis locais, sendo a última expressão o valor atribuído. No entanto, se a última expressão dentro de um bloco terminar com um ponto e vírgula, o valor de retorno será ().

Nota: Se o laboratório não especificar um nome de ficheiro, pode usar qualquer nome de ficheiro que desejar. Por exemplo, pode usar main.rs, compilá-lo e executá-lo com rustc main.rs && ./main.

Expressões

Um programa Rust é (principalmente) composto por uma série de instruções:

fn main() {
    // instrução
    // instrução
    // instrução
}

Existem alguns tipos de instruções em Rust. As duas mais comuns são declarar uma ligação de variável e usar um ; com uma expressão:

fn main() {
    // ligação de variável
    let x = 5;

    // expressão;
    x;
    x + 1;
    15;
}

Os blocos também são expressões, pelo que podem ser usados como valores em atribuições. A última expressão no bloco será atribuída ao local onde a expressão está, como uma variável local. No entanto, se a última expressão do bloco terminar com um ponto e vírgula, o valor de retorno será ().

fn main() {
    let x = 5u32;

    let y = {
        let x_squared = x * x;
        let x_cube = x_squared * x;

        // Esta expressão será atribuída a `y`
        x_cube + x_squared + x
    };

    let z = {
        // O ponto e vírgula suprime esta expressão e `()` é atribuído a `z`
        2 * x;
    };

    println!("x é {:?}", x);
    println!("y é {:?}", y);
    println!("z é {:?}", z);
}

Resumo

Parabéns! Concluiu o laboratório de Expressões. Pode praticar mais laboratórios no LabEx para melhorar as suas competências.