Funzioni di ruggine

Questa guida esplorerà come creare e utilizzare le funzioni nel linguaggio di programmazione ruggine. Le funzioni sono una caratteristica universale nella maggior parte dei linguaggi di programmazione e fondamentali da sapere per qualsiasi sviluppatore.

Cos'è una funzione?

Prima di entrare nei dettagli della creazione e dell'utilizzo di una funzione, rompela cos'è una funzione e perché usarla.

Una funzione non è altro che uno o più blocco di codice che viene raggruppato ed esegue una singola entità. Le funzioni sono una caratteristica pesante nella maggior parte dei linguaggi di programmazione in quanto ci consentono di organizzare ed esportare il codice in altre parti del programma in uno schema leggibile.

Ormai ti sei imbattuto nella funzione principale nel linguaggio della ruggine. La funzione principale è un tipo speciale di funzione che funge da punto di ingresso per un programma di ruggine.

A parte questo, discutiamo di come creare e utilizzare le funzioni in ruggine.

Funzioni di ruggine

I seguenti sono i passaggi da intraprendere quando si definiscono una funzione in ruggine.

1. Iniziamo con la parola chiave FN.
2. Successivamente, impostiamo il nome della funzione.
3. Una coppia di parentesi e passa un elenco di parametri.
4. Definire un corpo di funzione usando le parentesi graffe di apertura e chiusura.
5. Infine, un valore di ritorno (se disponibile).

Possiamo esprimere il codice sopra nella sintassi mostrato di seguito:

fnfunction_name (parametri)
// Function Body

Il tipo di funzione più elementare è quello che non accetta alcun parametro né contiene un valore di ritorno. Possiamo definire tale funzione come mostrato nell'esempio seguente:

fn say_hello ()
println!("Ciao mondo");

Quanto sopra illustra il concetto più semplice di una definizione di funzione. Iniziamo con la parola chiave FN seguita dal nome della funzione, nel nostro caso, Say_Hello (). Apriamo quindi il corpo della funzione all'interno di una coppia di bretelle.

Il corpo della funzione non contiene altro che la logica di ciò che fa la funzione. Occasionalmente, una funzione chiamerà altre funzioni e le userà.

Chiamare una funzione

Una volta dichiarata una funzione, possiamo usarla per eseguire le azioni definite. Ci riferiamo al processo di utilizzo di una funzione come chiamata di funzione o invocando una funzione.

In Rust, chiamiamo una funzione fornendo il suo nome e una coppia di parentesi. Questo dice al compilatore che desideriamo eseguire le istruzioni definite in quella funzione.

Nel nostro esempio, possiamo chiamare la nostra funzione all'interno della funzione principale come mostrato nell'esempio seguente:

fn main ()
//! Chiama la funzione
di Ciao();

/// Dichiarazione della funzione
fn say_hello ()
println!("Ciao mondo");

Parametri della funzione

Uno dei motivi principali per l'utilizzo delle funzioni è passare i parametri. Un parametro è un tipo speciale di variabile che possiamo passare alla funzione e consentire la modifica della logica utilizzata dalla funzione.

Puoi spesso sentire i termini Parametro e argomento usati in modo intercambiabile. Anche se hanno una differenza, non è davvero nulla per impedirti di costruire strumenti con ruggine.

Per definire un set di parametri della funzione, iniziamo definendo il nome del parametro seguito dal suo tipo all'interno della funzione tra parentesi.

La sintassi è come mostrata:

FN Function_Name (Parameter1: Data_Type)
// Function Body

Nota È necessario eseguire l'annotazione del tipo per un parametro di funzione.

Prendiamo la funzione Say_Hello che abbiamo definito in precedenza e migliorala in modo che saluti l'utente specifico.

Possiamo fare:

fn say_hello (nome: & str)
println!("Ciao, ", nome);

Nell'esempio sopra, definiamo un parametro per la funzione Say_Hello di Type & STR. Ora possiamo passare un nome alla funzione e ci salverà con il nome fornito.

Per passare il parametro durante la chiamata di funzione, possiamo fare:

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

fn say_hello (nome: & str)
println!("Ciao, ", nome);

Dichiarazione ed espressione della funzione

Come accennato, un corpo di funzione comprende dichiarazioni di codice che eseguono un'azione. Abbiamo usato una macro definita per stampare qualcosa sullo schermo nel nostro esempio. Tuttavia, possiamo creare una logica personalizzata per le nostre funzioni.

Ad esempio, prendi la funzione di seguito che richiede due numeri interi e restituisce il massimo dei due:

fnmaximum (x: i32, y: i32)
lascia mut max = 0;
if x> y
max = x;
altro
max = y;

println!("Max valore è: ", max);

Possiamo quindi chiamare la funzione e passare i due valori interi come mostrato di seguito:

fn main ()
massimo (100, 50);

L'esecuzione del codice sopra dovrebbe stampare:

Il valore massimo è: 100

Valori di restituzione della funzione

Una funzione può anche restituire un valore in base alla logica e alle azioni che esegue. Possiamo quindi utilizzare il valore restituito dalla funzione per eseguire altre operazioni. Sebbene non nominiamo il valore di reso in una funzione, dobbiamo dire al compilatore che ci aspettiamo che la funzione restituisca un valore di un tipo specifico.

Lo facciamo usando la freccia -> notazione.

Prendi la funzione massima () che abbiamo definito in precedenza. Invece di stampare il valore massimo, possiamo avere la funzione restituire il valore massimo e possiamo usarlo per agire su altre parti del programma.

Per definire un tipo di restituzione della funzione, possiamo usare la sintassi come:

fn function_name (parametro: type) -> return_type
// Function Body

Considera l'esempio seguente che ridefinisce la funzione massima per includere un valore di ritorno:

fn Maximum (x: i32, y: i32) -> i32
// logica

In questo caso, ci aspettiamo che la funzione restituisca un tipo i32.

Una volta definito un tipo di restituzione della funzione, dobbiamo assicurarci che la funzione restituisca effettivamente qualcosa.

Possiamo farlo usando la parola chiave di ritorno. Ad esempio, per restituire il valore massimo dalla funzione sopra, possiamo fare:

fnmaximum (x: i32, y: i32) -> i32
lascia mut max = 0;
if x> y
max = x;
altro
max = y;

restituire max;

La funzione dovrebbe restituire il valore della variabile massima.

Un altro formato che possiamo utilizzare per restituire un valore da una funzione è specificare il valore di restituzione senza terminatori semi-colon.

Un esempio è come mostrato:

fnMain ()
Say_hello ("Sarah!");
massimo (100, 50);

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

fnmaximum (x: i32, y: i32) -> i32
letmut max = 0;
if x> y
max = x;
altro
max = y;

// nessuna parola chiave di ritorno o semi-colon
max

L'esempio sopra dovrebbe comportarsi in modo simile alla parola chiave di ritorno.

Possiamo quindi usare il valore restituito dalla funzione per eseguire un'azione. Per esempio:

fn main ()
println!("Prodotto: ", massimo (100, 10) * 2);

Qui, prendiamo il valore restituito dalla funzione massima e moltiplichiamo per 2.

In chiusura

Per questo tutorial, abbiamo esplorato il concetto di funzioni, come definire una funzione, parametri della funzione, valori di ritorno della funzione e altro ancora. Le funzioni sono un concetto importante nella programmazione e ci consentono di organizzare e riutilizzare il codice senza ripetizione.

Speriamo che ti sia piaciuto il tutorial.

Arrivederci!