Funções no Rust

As funções são comuns no idioma Rust.

Através dos capítulos anteriores, já podemos entender a forma básica das funções no Rust:

fn <nome_da_função> ( <parâmetro> ) <corpo_da_função>

No Rust, o estilo de nomeação dos nomes das funções é letras minúsculas separadas por traços:

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

Resultado da Execução:

Olá, mundo!
Olá, w3codebox!

Observe que definimos another_function após a função main no código-fonte. Rust não se importa onde você define as funções, desde que você as defina em algum lugar.

Parâmetros da função

Em Rust, para que uma função tenha parâmetros, é necessário declarar o nome e o tipo dos parâmetros:

fn　main()　{
　　　　another_function(5,　6;
}
fn another_function(x: i32, y: i32) {
　　　　println!("O valor de x é: {}",　x);
　　　　println!("O valor de y é: {}",　y);
}

Resultado da Execução:

O valor de x é:　5
O valor de y é:　6

Declarações e expressões do corpo da função

O corpo da função Rust é composto por uma série de declarações (Statement) que podem terminar com uma expressão (Expression). Até agora, apenas vimos funções que não terminam com uma expressão, mas já usamos expressões como parte de declarações.

A declaração é uma etapa que executa algumas operações sem valor de retorno. Por exemplo:

let a =　6;

Esta etapa não tem valor de retorno, portanto, a seguinte declaração está incorreta:

let a = (let b =　2;

A expressão tem etapas de cálculo e valor de retorno. A seguir está a expressão (supondo que os identificadores que aparecem já tenham sido definidos):

a　=　7
b　+　2
c　*　(a　+　b)

No Rust, é possível escrever uma expressão mais complexa dentro de um bloco delimitado por {}:

fn　main()　{
　　　　let　x　=　5;
　　　　let　y　=
　　　　　　　　let　x　=　3;
　　　　　　　　x　+　1
　　　　};
　　　　println!("O valor de x é: {}",　x);
　　　　println!("O valor de y é: {}",　y);
}

Resultado da Execução:

O valor de x é:　5
O valor de y é:　4

Claramente, este programa contém um bloco de expressão:

{
　　　　let　x　=　3;
　　　　x　+　1
};

Além disso, no bloco, é possível usar expressões de função, a última etapa é a expressão, o valor da expressão é o valor do bloco de expressão inteiro. Este bloco de expressão é chamado de expressão do corpo da função.

Atenção: x + 1 Não há ponto e vírgula no final, senão ele se tornará uma sentença!

Este bloco de expressão é um corpo de função válido. Além disso, no Rust, a definição de função pode ser aninhada:

fn　main()　{
　　　　fn　five()　->　i32　{
　　　　　　　　5
　　　　}
　　　　println!("O valor de five() é: {}",　five());
}

Retorno da Função

No exemplo anterior de nested, já foi mostrado como declarar o tipo de valor de retorno da função no Rust: após a declaração dos parâmetros, usando -> para declarar o tipo de valor de retorno da função (não : ).

No corpo da função, é possível encerrar a execução da função com a palavra-chave return e retornar um valor adequado a qualquer momento. Isso é o mais próximo da prática de muitos desenvolvedores:

fn　add(a:　i32,　b:　i32)　->　i32　{
　　　　return　a　+　b;
}

Mas o Rust não suporta a inferência automática do tipo de valor de retorno! Se o tipo de valor de retorno da função não for declarado explicitamente, a função será considerada "procedural pura", não permitindo a geração de valores de retorno, não há expressão de valor de retorno após o return. O objetivo disso é permitir que as funções públicas formem relatórios visíveis.

Atenção:A expressão do corpo da função não é equivalente ao corpo da função, ela não pode usar return Palavras-chave.