Compreendendo as funções no Rust

As funções são construções de programação essenciais, pois estabelecem uma base para a reutilização de código e facilitam a programação modular. As funções são blocos independentes de código que executam tarefas específicas. Eles podem receber entrada, na forma de argumentos, e retornar um valor.

Rust fornece funções para organização de código, encapsulamento e reutilização de código.

Definindo funções em Rust

As funções de ferrugem são muito parecidas funções em qualquer outra linguagem de programação, embora existam pequenas diferenças que você precisa entender.

Você definirá funções para seus programas Rust com o fn palavra-chave seguida pelo nome da função, argumentos opcionais e um retorno opcional tipo de dados.

// função que não recebe argumentos nem retorna um valor
fn function_name() {
// corpo da função aqui
}

Aqui está uma função Rust simples que não aceita nenhum argumento nem retorna nenhum valor.

fn a_function(){
 seja x = 3;
println!("{}", x)
}

uma função é uma função Rust simples que imprime a variável x.

Assinaturas de função de ferrugem

As assinaturas de função são uma maneira de nomear funções e descrever seus argumentos e tipos de retorno, sem incluir um corpo de função. As assinaturas de função são úteis para documentar APIs de bibliotecas Rust.

Aqui está um exemplo de assinatura de função Rust:

fn nome()
fn cumprimentar (nome: &str)

O nome função é uma assinatura de função mínima, enquanto o saudar assinatura especifica que a função recebe um único argumento, nome, do tipo string (&str).

Declarando funções com argumentos e valores de retorno

As funções Rust podem receber muitos argumentos e o limite não é definido explicitamente. Funções com argumentos geralmente são mais flexíveis, pois podem receber valores de outras funções e partes do código.

Aqui está o modelo típico de uma função Rust que recebe argumentos:

fn nome_da_função (arg: tipo, arg2: tipo) {
// corpo da função aqui
}

O tipo de argumento da função pode ser um tipo interno do Rust ou um tipo personalizado do seu programa.

Aqui está um exemplo de uma função simples que recebe dois números inteiros como argumentos:

fn add_numbers (x: i32, y: i32) {
println!("{}", x + y);
}

O add_numbers A função recebe dois inteiros de 32 bits e imprime a soma dos inteiros.

As funções Rust podem retornar vários valores; você terá que especificar o(s) tipo(s) de retorno e retornar os valores do tipo da função.

fn nome_da_função (arg: tipo, arg2: tipo) -> (tipo, tipo) {
// corpo da função aqui
retornar arg, arg2
}

Aqui está uma função que recebe uma string e um inteiro de 32 bits como argumento e retorna os argumentos como uma tupla.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
retornar (s, n);
}

O string_and_integer A função recebe uma string e um inteiro de 32 bits, retornando-os como uma tupla. Você só pode retornar um único valor de uma função Rust.

Você pode deixar de fora retornar palavra-chave ao retornar a expressão final de uma função, para tornar o código mais conciso.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
retornar (s, n);
}
// as funções são equivalentes
fn str_and_int (s: String, n: i32) -> (String, i32) {
 (s, n)
}

Essas duas funções têm o mesmo comportamento, pois ambas recebem uma string e um inteiro e retornam esses argumentos como uma tupla.

Chamando funções Rust

Você pode chamar uma função de outra escrevendo seu nome seguido pelos valores que deseja passar para ela entre parênteses:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn principal() {
 deixe resultado = add_numbers (3, 5);
println!("O resultado é {}", resultado); // Output: O resultado é 8
}

O principal chamadas de função add_numbers, passando-lhe dois inteiros. Atribui o resultado da função a uma variável, resultado.

Você pode declarar funções para estruturas de ferrugem

Você pode declarar funções dentro de estruturas Rust. Eles se tornam métodos para a estrutura que pode acessá-la e modificá-la.

Rust não é puramente orientado a objetos, mas fornece structs para agrupar dados relacionados. Você pode trabalhar para implementar conceitos OOP em Rust usando structs com métodos.