SwiftHTML & CSSSolidityDesenvolvimento de JogosSolana/Rust
12.11.2024

Lição: 004: Sintaxe Básica do Rust e Controle de Fluxo

Nesta aula, vamos cobrir a sintaxe básica da linguagem de programação Rust. Também exploraremos estruturas de controle de fluxo, como condicionais e laços. Ao final desta aula, você deve ter uma compreensão sólida de como escrever programas simples em Rust com esses conceitos fundamentais.

Sintaxe Básica

A sintaxe do Rust foi projetada para ser clara e concisa. Vamos começar examinando a estrutura de um programa simples em Rust.

fn main() {
    println!("Olá, mundo!");
}

Explicação

  • fn main(): Aqui, fn indica que estamos definindo uma função. main é uma função especial que serve como o ponto de entrada do programa.
  • println!: Esta é uma macro que imprime texto no console. O ponto de exclamação (!) indica que se trata de uma macro, e não de uma função comum.
  • "Olá, mundo!": Esta é uma string literal que será impressa no console quando o programa for executado.

Variáveis e Tipos de Dados

Em Rust, as variáveis são imutáveis por padrão. Você pode declarar uma variável mutável usando a palavra-chave mut.

fn main() {
    let x = 5; // variável imutável
    let mut y = 10; // variável mutável

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

    y += 5; // modificando a variável mutável
    println!("y atualizado: {}", y);
}

Tipos de Dados

Rust possui um sistema de tipos estáticos e forte. Os tipos de dados comuns incluem:

  • Tipos escalares: inteiros, números de ponto flutuante, booleanos e caracteres.
  • Tipos compostos: tuplas e arrays.

Exemplo de Tipos de Dados

fn main() {
    let inteiro: i32 = 42;
    let ponto_flutuante: f64 = 3.14;
    let booleano: bool = true;
    let caractere: char = 'A';

    let tupla: (i32, f64, char) = (inteiro, ponto_flutuante, caractere);
    let array: [i32; 3] = [1, 2, 3];

    println!("Tupla: {:?}, Array: {:?}", tupla, array);
}

Controle de Fluxo

O controle de fluxo é essencial para escrever programas que podem tomar decisões e repetir tarefas. Rust fornece várias construções para esse propósito, incluindo declarações if, laços e expressões match.

1. Expressão if

fn main() {
    let numero = 10;

    if numero < 5 {
        println!("Número é menor que 5");
    } else if numero == 10 {
        println!("Número é igual a 10");
    } else {
        println!("Número é maior que 5 e não é igual a 10");
    }
}

2. Laçamentos com loop, while e for

  • loop: Isso cria um laço infinito até ser explicitamente interrompido.
fn main() {
    let mut contagem = 0;

    loop {
        contagem += 1;
        if contagem == 5 {
            break; // sair do laço
        }
    }

    println!("Contagem atingida: {}", contagem);
}
  • while: Laço enquanto uma condição for verdadeira.
fn main() {
    let mut contagem = 0;

    while contagem < 5 {
        contagem += 1;
    }

    println!("Contagem atingida: {}", contagem);
}
  • for: Itera sobre um intervalo ou coleção.
fn main() {
    for numero in 1..6 { // intervalo de 1 a 5
        println!("Número: {}", numero);
    }

    let array = [10, 20, 30];

    for elemento in &array {
        println!("Elemento: {}", elemento);
    }
}

3. Expressão match

A expressão match permite a correspondência de padrões, que pode ser uma ferramenta muito poderosa em Rust.

fn main() {
    let numero = 2;

    match numero {
        1 => println!("Um"),
        2 => println!("Dois"),
        3 => println!("Três"),
        _ => println!("Não é um, dois ou três"), // correspondência curinga
    }
}

Conclusão

Nesta aula, você aprendeu sobre a sintaxe básica do Rust, como declarar variáveis, os diferentes tipos de dados disponíveis e as construções de controle de fluxo, incluindo condicionais, laços e correspondência de padrões. Esses são conceitos fundamentais que são amplamente utilizados na programação em Rust. Pratique escrevendo seus próprios programas em Rust para solidificar sua compreensão!

Did you like this article? Rate it from 1 to 5:

Thank you for voting!