Learn Rust Coding · Aula

Funções e Fluxo de Controlo

Aprenda a definir funções e a utilizar as expressões `if`/`else`, `loop`, `while` e `for` para controlar o fluxo de execução do programa.

Aula 3 de 311 etapas

Funções e Fluxo de Controlo é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 de 3. 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 3 aulas no total.

O que são funções?

Funções são blocos de código nomeados que realizam uma tarefa específica. Elas são fundamentais para organizar seu código e torná-lo reutilizável.

Reutilização de código: escreva uma lógica uma vez e use-a várias vezes.
Modularidade: divida problemas complexos em partes menores e gerenciáveis.
Legibilidade: dê nomes significativos aos blocos de código, facilitando a compreensão.

Sua primeira função no Rust

No Rust, você define uma função usando a palavra-chave fn. A função main é o ponto de entrada de todo programa Rust.

Veja como declarar e chamar uma função simples:

fn say_hello() {
    println!("Hello from a function!");
}

fn main() {
    say_hello(); // Call the function
    println!("Back in main.");
}

Funções com parâmetros

As funções podem aceitar valores de entrada chamados parâmetros. Eles permitem que sua função opere sobre dados diferentes a cada chamada.

Os parâmetros são definidos com um nome e um tipo, separados por dois-pontos.

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
    greet("Bob");
}

Funções com valores de retorno

As funções também podem retornar um valor para quem as chama. Você especifica o tipo de retorno depois de uma seta (->).

A última expressão do corpo da função é retornada implicitamente. Não é necessário ponto e vírgula na expressão de retorno!

fn add_numbers(x: i32, y: i32) -> i32 {
    x + y // No semicolon: this expression is returned
}

fn main() {
    let sum = add_numbers(5, 7);
    println!("The sum is: {}", sum);
}

Tomando decisões: `if`/`else`

A expressão if permite que seu programa execute blocos de código diferentes com base em uma condição. As condições devem ser sempre um bool (true/false).

Use if para a primeira condição.
Use else if para condições adicionais.
Use else como alternativa quando nenhuma outra condição for atendida.

No Rust, if é uma expressão, o que significa que pode retornar um valor!

Expressões if-else em ação

Veja como pode usar if e else para atribuir um valor com base em uma condição. Observe como isso se comporta como um operador ternário de outras linguagens.

fn main() {
    let number = 7;

    let message = if number < 10 {
        "Small number"
    } else {
        "Large number"
    };

    println!("The number is: {}", message);

    let other_num = 15;
    if other_num % 2 == 0 {
        println!("{} is even", other_num);
    } else {
        println!("{} is odd", other_num);
    }
}

Repetição de código: `loop`

A palavra-chave loop cria um loop infinito. Isso é útil quando precisa repetir uma ação até decidir explicitamente interrompê-la.

Use break para sair do loop. Também pode retornar um valor de uma expressão loop usando break.

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // Break and return a value
        }
    };

    println!("The result is {}", result);
}

Repetição condicional: `while`

O loop while executa um bloco de código enquanto uma condição especificada continuar sendo verdadeira. Ele é perfeito quando não sabe exatamente quantas vezes precisa repetir o loop.

fn main() {
    let mut count = 3;

    while count != 0 {
        println!("{}!", count);
        count -= 1;
    }

    println!("LIFTOFF!!!");
}

Iteração com loops `for`

O loop for é usado para iterar sobre uma coleção de itens ou um intervalo de números. É a estrutura de loop mais comum do Rust, tornando seu código seguro e conciso.

Ele é frequentemente usado com intervalos (por exemplo, 1..4 para 1, 2, 3 ou 1..=4 para 1, 2, 3, 4).
Ele funciona com qualquer tipo que implemente a característica Iterator.

fn main() {
    // Loop through a range
    for number in 1..4 { // 1, 2, 3
        println!("Number: {}", number);
    }

    // Loop through an array
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("The value is: {}", element);
    }
}

Desafio de fluxo de controle

Considere o código Rust a seguir. Qual será o valor final de result?

fn calculate_value(input: i32) -> i32 {
    if input > 10 {
        input * 2
    } else if input == 5 {
        input + 5
    } else {
        input
    }
}

fn main() {
    let result = calculate_value(5);
    // What is result?
}

Responda na aula interativa

Revisão de funções e fluxo de controle

Você dominou os blocos de construção para programas dinâmicos!

Funções: Organize e reutilize código usando fn, parâmetros e valores de retorno.
if/else: Tome decisões e execute código condicionalmente. Lembre-se de que isso é uma expressão!
loop: Crie loops infinitos, saia com break e retorne valores.
while: Repita enquanto uma condição for verdadeira.
for: Itere com segurança sobre coleções e intervalos.

Essas ferramentas são essenciais para escrever programas Rust estruturados e eficientes!

Grátis para começar

Aprenda Rust com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 39
Aulas: 144

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Funções e Fluxo de Controlo” é grátis?

Sim — o texto completo de “Funções e Fluxo de Controlo” é 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 3 aulas no total.

O que vou aprender em “Funções e Fluxo de Controlo”?

Aprenda a definir funções e a utilizar as expressões `if`/`else`, `loop`, `while` e `for` para controlar o fluxo de execução do programa. 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 3.

Quanto tempo leva a aula “Funções e Fluxo de Controlo”?

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