Comprensione delle funzioni in Rust

Le funzioni sono costrutti di programmazione essenziali poiché gettano le basi per la riusabilità del codice e facilitano la programmazione modulare. Le funzioni sono blocchi di codice autonomi che eseguono attività specifiche. Possono ricevere input, sotto forma di argomenti, e restituire un valore.

Rust fornisce funzioni per l'organizzazione del codice, l'incapsulamento e la riusabilità del codice.

Definizione di funzioni in Rust

Le funzioni di Rust sono molto simili funzioni in qualsiasi altro linguaggio di programmazione, anche se ci sono piccole differenze che devi capire.

Definirai le funzioni per i tuoi programmi Rust con il file fn parola chiave seguita dal nome della funzione, argomenti facoltativi e un ritorno facoltativo tipo di dati.

// funzione che non accetta argomenti né restituisce un valore
fn nome_funzione() {
// corpo della funzione qui
}

Ecco una semplice funzione Rust che non accetta argomenti né restituisce alcun valore.

fn a_funzione(){
 sia x = 3;
println!("{}", X)
}

una funzione è una semplice funzione di Rust che stampa la variabile X.

Firme della funzione Rust

Le firme delle funzioni sono un modo per denominare le funzioni e descriverne gli argomenti e i tipi restituiti, senza includere un corpo della funzione. Le firme delle funzioni sono utili per documentare le API delle librerie Rust.

Ecco un esempio di firma della funzione Rust:

nome fn()
fn saluto (nome: &str)

IL nome function è una firma di funzione minima, mentre il salutare signature specifica che la funzione accetta un singolo argomento, nome, di tipo stringa (&str).

Dichiarazione di funzioni con argomenti e valori restituiti

Le funzioni di Rust possono accettare molti argomenti e il limite non è definito in modo esplicito. Le funzioni con argomenti sono generalmente più flessibili poiché possono accettare valori da altre funzioni e parti di codice.

Ecco il modello tipico di una funzione Rust che accetta argomenti:

fn nome_funzione (arg: tipo, arg2: tipo) {
// corpo della funzione qui
}

Il tipo di argomento della funzione può essere un tipo incorporato in Rust o un tipo personalizzato dal tuo programma.

Ecco un esempio di una semplice funzione che accetta due numeri interi come argomenti:

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

IL add_numbers La funzione accetta due numeri interi a 32 bit e stampa la somma dei numeri interi.

Le funzioni Rust possono restituire più valori; dovrai specificare i tipi restituiti e restituire i valori del tipo dalla funzione.

fn nome_funzione (arg: tipo, arg2: tipo) -> (tipo, tipo) {
// corpo della funzione qui
ritorno arg, arg2
}

Ecco una funzione che accetta una stringa e un numero intero a 32 bit come argomento e restituisce gli argomenti come tupla.

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

IL string_and_integer La funzione accetta una stringa e un numero intero a 32 bit, restituendoli come tupla. Puoi restituire solo un singolo valore da una funzione Rust.

Puoi tralasciare il ritorno parola chiave quando si restituisce l'espressione finale da una funzione, per rendere il codice più conciso.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
ritorno (s, n);
}
// le funzioni sono equivalenti
fn str_and_int (s: Stringa, n: i32) -> (Stringa, i32) {
 (s, n)
}

Queste due funzioni hanno lo stesso comportamento poiché entrambe accettano una stringa e un numero intero e restituiscono tali argomenti come una tupla.

Chiamare le funzioni Rust

Puoi chiamare una funzione da un'altra scrivendo il suo nome seguito dai valori che vuoi passarle tra parentesi:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + a
}
fn main() {
 lascia risultato = aggiungi_numeri(3, 5);
println!("Il risultato è {}", risultato); // Output: il risultato è 8
}

IL principale chiamate di funzione add_numbers, passandogli due numeri interi. Assegna il risultato della funzione a una variabile, risultato.

È possibile dichiarare funzioni per le strutture Rust

Puoi dichiarare le funzioni all'interno delle strutture di Rust. Questi diventano metodi per la struttura che può accedervi e modificarla.

Rust non è puramente orientato agli oggetti, ma fornisce strutture per raggruppare i dati correlati. Puoi lavorare per implementare i concetti OOP in Rust usando struct con metodi.