Funzioni di Rust

Functions are ubiquitous in the Rust language.

Through the previous chapters, we have already learned the basic form of Rust functions:

fn <function_name> ( <parameter> ) <function_body>

In Rust, the naming style of function names is lowercase letters separated by underscores:

fn main() {
　　　　println!("Hello, world!");
　　　　another_function();
}
fn another_function() {
　　　　println!("Hello, w3codebox!");
}

Risultato dell'esecuzione:

Hello, world!
Hello, w3codebox!

Note that we defined another_function after the main function in the source code. Rust does not care where you define the functions, just that you define them somewhere.

Function parameters

In Rust, when defining a function that requires parameters, you must declare the parameter names and types:

fn main() {
　　　　another_function(5, 6);
}
fn another_function(x: i32, y: i32) {
　　　　println!("Il valore di x è: {}", x);
　　　　println!("Il valore di y è: {}", y);
}

Risultato dell'esecuzione:

Il valore di x è: 5
The value of y is : 6

Statements and expressions in the function body

The body of a Rust function consists of a series of statements that can end with an expression (Expression). So far, we have only seen functions that do not end with an expression, but we have already used expressions as part of statements.

A statement is a step that performs some operations without a return value. For example:

let a = 6;

This step does not return a value, so the following statement is incorrect:

let a = (let b = 2);

The expression has calculation steps and a return value. Below is the expression (assuming the identifiers have been defined):

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

In Rust, you can write a more complex expression within a block enclosed by {}:

fn main() {
　　　　let x = 5;
　　　　let y = {
　　　　　　　　let x = 3;
　　　　　　　　x + 1
　　　　};
　　　　println!("Il valore di x è: {}", x);
　　　　println!("Il valore di y è: {}", y);
}

Risultato dell'esecuzione:

Il valore di x è: 5
Il valore di y è: 4

Evidentemente, questo programma contiene un blocco di espressione:

{
　　　　let x = 3;
　　　　x + 1
};

Inoltre, è possibile utilizzare espressioni di funzione all'interno del blocco, l'ultimo passo è l'espressione, il valore di risultato di questa espressione è il valore del blocco di espressione. Questo blocco di espressione si chiama espressione del corpo della funzione.

Attenzione: non aggiungere un punto e virgola dopo x + 1, altrimenti diventerà una singola istruzione!

Questo è un blocco di espressione legittimo per una funzione. In Rust, è possibile definire funzioni annidate:

fn main() {
　　　　fn five() -> i32 {
　　　　　　　　5
　　　　}
　　　　println!("Il valore di five() è: {}", five());
}

Valore di ritorno della funzione

Nel precedente esempio annidato è stato mostrato come dichiarare il tipo di valore di ritorno di una funzione in Rust: utilizzare -> dopo la dichiarazione dei parametri per dichiarare il tipo di valore di ritorno della funzione (non : ).

All'interno del corpo della funzione, è possibile terminare l'esecuzione della funzione e restituire un valore appropriato in qualsiasi momento utilizzando la parola chiave return. Questo è il metodo più vicino all'esperienza di molti sviluppatori:

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

Ma Rust non supporta la determinazione automatica del tipo di valore di ritorno! Se non viene specificato esplicitamente il tipo di valore di ritorno della funzione, la funzione sarà considerata "procedurale pura", non è permesso generare valori di ritorno, non può esserci un'espressione di valore di ritorno dopo return. Questo viene fatto per permettere che le funzioni pubbliche formino una dichiarazione visibile.

Attenzione:L'espressione del corpo della funzione non è equivalente al corpo della funzione, non può essere utilizzata return Parola chiave.