Funções de ferrugem

Este guia explorará como criar e usar funções na linguagem de programação de ferrugem. As funções são uma característica universal na maioria das linguagens de programação e fundamental para qualquer desenvolvedor saber.

O que é uma função?

Antes de entrar nos detalhes da criação e uso de uma função, vamos quebrar o que é uma função e por que usá -la.

Uma função nada mais é do que um ou mais bloco de código agrupado e executa uma única entidade. As funções são uma característica pesada na maioria das linguagens de programação, pois elas nos permitem organizar e exportar código para outras partes do programa em um padrão legível.

Até agora, você já se deparou com a função principal na linguagem ferrugem. A função principal é um tipo especial de função que serve como ponto de entrada para um programa de ferrugem.

Com isso fora do caminho, vamos discutir como criar e usar funções na ferrugem.

Funções de ferrugem

A seguir estão as etapas a serem tomadas ao definir uma função na ferrugem.

1. Começamos com a palavra -chave fn.
2. Em seguida, definimos o nome da função.
3. Um par de parênteses e passa uma lista de parâmetros.
4. Defina um corpo de função usando o aparelho de abertura e fechamento.
5. Finalmente, um valor de retorno (se disponível).

Podemos expressar o código acima na sintaxe mostrada abaixo:

fnfunction_name (parâmetros)
// Corpo de função

O tipo mais básico de função é aquele que não aceita nenhum parâmetros nem contém um valor de retorno. Podemos definir uma função como mostrado no exemplo abaixo:

fn Say_hello ()
println!("Olá Mundo");

O acima ilustra o conceito mais básico de uma definição de função. Começamos com a palavra -chave fn seguida pelo nome da função, em nosso caso, Say_Hello (). Em seguida, abrimos o corpo da função dentro de um par de aparelhos encaracolados.

O corpo da função não contém nada além da lógica do que a função faz. Ocasionalmente, uma função chama outras funções e as usará.

Chamando uma função

Depois de declararmos uma função, podemos usá -la para executar as ações definidas. Nós nos referimos ao processo de usar uma função como uma chamada de função ou invocar uma função.

Em Rust, chamamos uma função fornecendo seu nome e um par de parênteses. Isso diz ao compilador que desejamos executar as instruções definidas nessa função.

Em nosso exemplo, podemos chamar nossa função dentro da função principal, como mostrado no exemplo abaixo:

fn main ()
//! Chame a função
diga olá();

/// Declaração da função
fn Say_hello ()
println!("Olá Mundo");

Parâmetros de função

Uma das principais razões para o uso de funções é passar os parâmetros. Um parâmetro é um tipo especial de variável que podemos passar para a função e permitir a modificação da lógica que a função usa.

Você pode ouvir frequentemente o parâmetro de palavra e o argumento dos termos usados ​​de forma intercambiável. Embora eles tenham uma diferença, realmente não é nada para impedi -lo de construir ferramentas com ferrugem.

Para definir um conjunto de parâmetros de função, começamos definindo o nome do parâmetro seguido de seu tipo dentro dos parênteses da função.

A sintaxe é como mostrado:

fn function_name (parâmetro1: data_type)
// Corpo de função

NOTA você deve executar a anotação do tipo para um parâmetro de função.

Vamos fazer a função Say_Hello que definimos anteriormente e melhorá -la para que ele diga olá ao usuário específico.

Nós podemos fazer:

fn SAY_HELLO (Nome: & str)
println!("Olá, ", nome);

No exemplo acima, definimos um parâmetro para a função Say_Hello do tipo & str. Agora podemos passar um nome para a função e isso nos cumprimentará com o nome fornecido.

Para passar no parâmetro durante a chamada de função, podemos fazer:

fn main ()
Say_hello ("Sarah!");

fn SAY_HELLO (Nome: & str)
println!("Olá, ", nome);

Declaração e expressão de função

Como mencionado, um corpo de função compreende declarações de código que executam uma ação. Usamos uma macro definida para imprimir algo na tela em nosso exemplo. No entanto, podemos criar lógica personalizada para nossas funções.

Por exemplo, pegue a função abaixo que leva dois números inteiros e devolva o máximo dos dois:

fnmaximum (x: i32, y: i32)
Seja mut max = 0;
Se x> y
max = x;;
outro
max = y;

println!("Valor máximo é: ", max);

Podemos então chamar a função e passar os dois valores inteiros, como mostrado abaixo:

fn main ()
máximo (100, 50);

Executar o código acima deve imprimir:

O valor máximo é: 100

Valores de retorno da função

Uma função também pode retornar um valor com base na lógica e ações que executa. Podemos então usar o valor retornado da função para executar outras operações. Embora não nomeemos o valor de retorno em uma função, precisamos dizer ao compilador que esperamos que a função retorne um valor de um tipo específico.

Fazemos isso usando a seta -> notação.

Tome a função máxima () que definimos anteriormente. Em vez de imprimir o valor máximo, podemos fazer com que a função retorne o valor máximo, e podemos usá -lo para agir em outras partes do programa.

Para definir um tipo de retorno de função, podemos usar a sintaxe como:

fn function_name (parâmetro: type) -> return_type
// Corpo de função

Considere o exemplo abaixo que redefine a função máxima para incluir um valor de retorno:

fn máximo (x: i32, y: i32) -> i32
// lógica

Nesse caso, esperamos que a função retorne um tipo i32.

Depois de definirmos um tipo de retorno de função, precisamos garantir que a função realmente retorne algo.

Podemos fazer isso usando a palavra -chave de retorno. Por exemplo, para retornar o valor máximo da função acima, podemos fazer:

fnmaximum (x: i32, y: i32) -> i32
Seja mut max = 0;
Se x> y
max = x;;
outro
max = y;

retornar max;

A função deve retornar o valor da variável máxima.

Outro formato que podemos usar para retornar um valor de uma função é especificar o valor de retorno sem terminador semi-colon.

Um exemplo é como mostrado:

fnmain ()
Say_hello ("Sarah!");
máximo (100, 50);

fnsay_hello (nome: & str)
println!("Olá, ", nome);

fnmaximum (x: i32, y: i32) -> i32
letmut max = 0;
Se x> y
max = x;;
outro
max = y;

// sem palavra-chave de retorno ou semi-colon
máx

O exemplo acima deve se comportar de maneira semelhante à palavra -chave de retorno.

Podemos então usar o valor retornado da função para executar uma ação. Por exemplo:

fn main ()
println!("Produto: ", máximo (100, 10) * 2);

Aqui, pegamos o valor retornado da função máxima e a multiplificamos por 2.

Para encerrar

Para este tutorial, exploramos o conceito de funções, como definir uma função, parâmetros de função, valores de retorno da função e mais. As funções são um conceito importante na programação e elas nos permitem organizar e reutilizar o código sem repetição.

Esperamos que você tenha gostado do tutorial.

Adeus por agora!