12.11.2024

Lição: 005: Funções e Módulos em Rust

Nesta aula, iremos explorar funções e módulos em Rust. As funções nos permitem encapsular lógica que pode ser reutilizada, enquanto os módulos ajudam a organizar nosso código de maneira eficaz. Ao final desta aula, você terá uma compreensão sólida de como definir e usar funções e módulos em Rust.

Funções em Rust

As funções em Rust são definidas usando a palavra-chave fn, seguida pelo nome da função, parâmetros e um tipo de retorno. Vamos ver um exemplo simples.

Definindo uma Função

Aqui está como definir uma função simples que soma dois inteiros:

fn adicionar(x: i32, y: i32) -> i32 {
    x + y
}

Parâmetros e Tipos de Retorno da Função

• x: i32 e y: i32 são parâmetros da função com tipos especificados.
• -> i32 indica que a função retorna um valor do tipo i32.

Chamando uma Função

Você pode chamar a função que acabamos de definir da seguinte forma:

fn main() {
    let soma = adicionar(5, 3);
    println!("A soma é: {}", soma);
}

Quando você executar este programa, ele produzirá a seguinte saída:

A soma é: 8

Função sem Valor de Retorno

Nem todas as funções precisam retornar um valor. Aqui está uma função que simplesmente imprime uma mensagem:

fn cumprimentar(nome: &str) {
    println!("Olá, {}!", nome);
}

fn main() {
    cumprimentar("Alice");
}

Isso resultará na saída:

Olá, Alice!

Funções com Múltiplos Retornos

As funções podem ter múltiplas instruções de retorno. No entanto, você só pode retornar um valor de um único ponto de saída se usar return. Aqui está um exemplo:

fn verificar_par_impar(num: i32) -> &'static str {
    if num % 2 == 0 {
        return "Par";
    }
    "Ímpar"
}

fn main() {
    let numero = 7;
    println!("{} é {}", numero, verificar_par_impar(numero));
}

Esse programa verifica se um número é par ou ímpar:

7 é Ímpar

Módulos em Rust

Os módulos em Rust são usados para organizar o código em namespaces. Você pode criar um módulo usando a palavra-chave mod. Vamos ver como criar um módulo simples.

Definindo um Módulo

Aqui está um exemplo que mostra como definir e usar um módulo em Rust:

mod matematica {
    pub fn adicionar(x: i32, y: i32) -> i32 {
        x + y
    }

    pub fn multiplicar(x: i32, y: i32) -> i32 {
        x * y
    }
}

fn main() {
    let soma = matematica::adicionar(5, 3);
    let produto = matematica::multiplicar(4, 2);
    println!("A soma é: {}", soma);
    println!("O produto é: {}", produto);
}

Acessando Funções do Módulo

Para acessar funções de um módulo, use a sintaxe ::, como demonstrado acima. Certifique-se de usar a palavra-chave pub para funções que você deseja expor fora do módulo.

Módulos Aninhados

Você também pode criar módulos aninhados. Aqui está um exemplo de módulos aninhados:

mod matematica {
    pub mod aritmetica {
        pub fn subtrair(x: i32, y: i32) -> i32 {
            x - y
        }
    }
}

fn main() {
    let diferenca = matematica::aritmetica::subtrair(10, 4);
    println!("A diferença é: {}", diferenca);
}

Isso produzirá a saída:

A diferença é: 6

Conclusão

Nesta aula, cobrimos o básico sobre funções e módulos em Rust. Você aprendeu como definir e usar funções, lidar com tipos de retorno e organizar seu código com módulos. As funções permitem a reutilização do código, enquanto os módulos oferecem uma maneira de separar e organizar o código de forma eficaz. À medida que você continua sua jornada com Rust, dominar esses conceitos ajudará você a escrever código mais limpo e mais manutenível.

Navigation