Lição 6 de 18 · 15 min
Funções
Como declarar funções com fn, passar parâmetros com tipo, devolver valores e entender a diferença entre expressão e instrução.
Ao terminar, você vai saber:
- Declarar e chamar funções com fn
- Passar parâmetros sempre com o tipo escrito
- Devolver valores com -> e com a última expressão
- Diferenciar expressão de instrução
- Escrever comentários de linha e de documentação
Você já conhece uma função: a main, por onde todo programa começa. Agora é hora de criar as suas. Função é um pedaço de código com nome, que você pode chamar quantas vezes quiser. Ela evita repetição e deixa o programa mais fácil de ler.
Declarando uma função
Use a palavra fn, o nome, parênteses e chaves:
fn main() {
dar_bom_dia();
dar_bom_dia();
}
fn dar_bom_dia() {
println!("Bom dia! Já tomou café?");
}
Alguns detalhes:
- O nome segue o padrão snake_case: letras minúsculas e palavras separadas por
_. O compilador avisa se você fugir disso. - A ordem não importa:
dar_bom_diaestá declarada depois damaine funciona do mesmo jeito.
Parâmetros
Parâmetros são os valores que a função recebe. No Rust, cada parâmetro precisa ter o tipo escrito. Aqui não tem inferência, e isso é de propósito: a assinatura da função vira uma documentação confiável.
fn main() {
cumprimentar("Paulo", 34);
cumprimentar("Aline", 22);
}
fn cumprimentar(nome: &str, idade: u32) {
println!("Olá, {nome}! Você tem {idade} anos.");
}
Os parâmetros são separados por vírgula, cada um no formato nome: tipo. O &str é o tipo de um texto que a função só vai ler. Você vai entender o & direitinho no módulo de ownership.
Devolvendo um valor
Para a função devolver algo, escreva -> e o tipo do retorno:
fn main() {
let total = somar(15, 27);
println!("Total: {total}");
}
fn somar(a: i32, b: i32) -> i32 {
a + b
}
Repare: não tem return e não tem ponto e vírgula depois de a + b. No Rust, o valor da última expressão do corpo é o retorno da função. Para entender isso, precisamos falar de expressões e instruções.
Expressão e instrução
Essa é uma das ideias mais importantes do Rust.
- Instrução (statement) faz alguma coisa e não produz valor. Exemplo:
let x = 5;. - Expressão (expression) produz um valor. Exemplos:
5,a + b,somar(1, 2).
O ponto e vírgula transforma uma expressão em instrução: ele “joga fora” o valor. Por isso:
a + bno fim da função: é expressão, o valor é devolvido.a + b;no fim da função: vira instrução, nada é devolvido.
Um bloco entre chaves também é uma expressão. O valor dele é o da última linha sem ponto e vírgula:
fn main() {
let preco_final = {
let preco = 100;
let desconto = 15;
preco - desconto // sem ponto e vírgula: é o valor do bloco
};
println!("Preço final: {preco_final}");
}
O erro mais comum
Todo mundo esquece disso no começo e coloca ponto e vírgula onde não devia:
fn dobro(numero: i32) -> i32 {
numero * 2;
}
fn main() {
println!("{}", dobro(4));
}
error[E0308]: mismatched types
|
1 | fn dobro(numero: i32) -> i32 {
| ----- ^^^ expected `i32`, found `()`
| |
| implicitly returns `()` as its body has no tail or `return` expression
2 | numero * 2;
| - help: remove this semicolon to return this value
Lendo com calma: a função promete devolver i32, mas o corpo devolve (). Esse () (lê-se “unit”) é o tipo de “nada”, o valor de quem não devolve nada. E o compilador aponta exatamente o culpado: “remove this semicolon to return this value”, ou seja, tire o ponto e vírgula.
E o return?
O return existe, sim. Ele serve para sair da função antes do fim:
fn main() {
println!("{}", calcular_frete(250.0));
println!("{}", calcular_frete(80.0));
}
fn calcular_frete(valor_da_compra: f64) -> f64 {
if valor_da_compra >= 200.0 {
return 0.0; // frete grátis, sai daqui mesmo
}
valor_da_compra * 0.1
}
O estilo do Rust é: return para sair mais cedo, última expressão para o caso normal.
Devolvendo mais de um valor
Uma função devolve um valor só, mas esse valor pode ser uma tupla:
fn main() {
let (quociente, resto) = dividir(17, 5);
println!("17 dividido por 5 dá {quociente} e sobra {resto}.");
}
fn dividir(dividendo: u32, divisor: u32) -> (u32, u32) {
(dividendo / divisor, dividendo % divisor)
}
Comentários
Você já viu os comentários de linha, com //. Tudo depois deles até o fim da linha é ignorado pelo compilador.
fn main() {
// Comentário numa linha só
let juros = 0.02; // também pode ficar no fim da linha
/* Comentário de bloco:
pode ocupar várias linhas,
mas é pouco usado no dia a dia */
println!("{juros}");
}
Existe ainda o comentário de documentação, com ///. Ele fica em cima de uma função e explica o que ela faz. Ferramentas como o cargo doc e o rust-analyzer usam esse texto para gerar documentação e mostrar dicas no editor.
/// Calcula a média de duas notas.
///
/// Recebe as duas notas e devolve a média com casas decimais.
fn media(nota1: f64, nota2: f64) -> f64 {
(nota1 + nota2) / 2.0
}
fn main() {
println!("Média: {}", media(7.0, 8.5));
}
Uma dica: comente o porquê, não o o quê. // soma 1 em cima de contador += 1 não ajuda ninguém. // conta o próprio usuário na lista ajuda.
Funções e macros
Por fim, uma diferença que confunde no começo: println! não é função, é macro. Macros têm ! no nome e podem fazer coisas que funções não podem, como receber um número variável de argumentos. Por enquanto, basta saber diferenciar pelo !.
Resumo
- Funções são declaradas com
fne nomes em snake_case. - Todo parâmetro tem o tipo escrito; o retorno vem depois de
->. - A última expressão sem ponto e vírgula é o valor devolvido.
- Expressão produz valor; o ponto e vírgula a transforma em instrução.
returnserve para sair mais cedo.//comenta uma linha;///documenta uma função.
Desafio
Escreva uma função imc que recebe peso (em quilos) e altura (em metros) como f64 e devolve o índice de massa corporal (peso dividido pela altura ao quadrado). Escreva outra função, classificar, que recebe o IMC e devolve um &str: "abaixo do peso" se for menor que 18.5, "peso normal" se for menor que 25, e "acima do peso" nos outros casos. Use return para sair mais cedo e a última expressão para o caso final.
Ver uma resposta
/// Calcula o índice de massa corporal.
fn imc(peso: f64, altura: f64) -> f64 {
peso / (altura * altura)
}
/// Diz em que faixa o IMC está.
fn classificar(valor: f64) -> &'static str {
if valor < 18.5 {
return "abaixo do peso";
}
if valor < 25.0 {
return "peso normal";
}
"acima do peso"
}
fn main() {
let valor = imc(70.0, 1.75);
println!("IMC: {valor:.1}, {}", classificar(valor));
}
O &'static str é um texto fixo, escrito direto no código, que vale durante o programa inteiro. Esse 'static é um tipo de lifetime, assunto para mais adiante. Por enquanto, leia como “texto fixo”.