Le funzioni sono blocchi autonomi di codice che eseguono uno specifico compito. Ad ogni funzione si assegna un nome e, quando è necessario eseguirla, la si richiama attraverso il nome assegnato.

Le funzioni in Swift possono esprimere qualsiasi cosa, da una semplice funzione C-style senza nomi dei parametri a un metodo di Objective-C-complesso con nomi dei parametri locali ed esterni per ogni parametro. I parametri possono fornire valori predefiniti per semplificare le chiamate di funzione .

Ogni funzione in Swift ha un tipo, costituito da tipi di parametri della funzione e un tipo di ritorno. È possibile utilizzarlo come qualsiasi altro tipo di Swift, il che rende facile passare funzioni stesse ad altre funzioni. Le funzioni possono anche essere scritte all’interno di altre funzioni per incapsulare le funzionalità utili, in questo caso parliamo di funzione annidata.


Definire e richiamare le funzioni

Quando si definisce una funzione, è possibile definire opzionalmente uno o più nomi , i valori digitati che la funzione prende come input (noto come parametri), e / o un tipo di valore che la funzione restituirà come uscita (noto come tipo di ritorno).

Ogni funzione ha un nome, che descrive il compito che la funzione stessa deve eseguire. Per utilizzare una funzione, la funzione stessa deve essere “richiamata” e si devono passare ad essa valori di input (noto come argomenti), che corrispondono ai tipi di parametri della funzione.

La funzione nell’esempio qui sotto (greetingForPerson), ha un nome che descrive il “compito” della funzione stessa, cioè prendere il nome di una persona come input e restituire un messaggio di saluto per quella persona. Per fare questo, si definisce un parametro, un ingresso valore stringa denominato personName e un tipo di dato restituito (in questo caso String), che conterrà un messaggio di saluto per quella persona:

func sayHello(personName: String) -> String {
let greeting = “Hello, ” + personName + “!”
return greeting
}

Si indica il tipo di funzione di ritorno con la freccia ” ->” , che è seguito dal nome del tipo di dato restituito.

La definizione descrive ciò che la funzione fa, che cosa ci si aspetta di ricevere e quello che restituisce quando è terminata:

println(sayHello(“Anna”))
// prints “Hello, Anna!”
println(sayHello(“Brian”))
// prints “Hello, Brian!”

Si chiama la funzione sayHello passando un valore string tra parentesi, come sayHello (“Anna”). Poiché la funzione restituisce un valore String, sayHello può essere inclusa in una chiamata alla funzione println per stampare la stringa e vedere il suo valore di ritorno, come mostrato sopra.

Il corpo della funzione sayHello inizia definendo una nuova stringa costante  e imposta a un semplice messaggio di saluto per personName. Questo saluto è poi passato nuovamente fuori la funzione utilizzando la parola chiave return. Appena saluto di ritorno viene chiamato, la funzione termina la sua esecuzione e restituisce il valore corrente di saluto.

È possibile chiamare la funzione sayHello più volte con valori di input diversi. L’esempio sopra mostra cosa succede se viene chiamato con un valore di ingresso di “Anna”, e un valore di ingresso “Brian”. La funzione restituisce un saluto su misura in ogni caso.

Per semplificare il corpo di questa funzione,si può procedere come segue:

“func sayHelloAgain(personName: String) -> String {
return “Hello again, ” + personName + “!”
}
println(sayHelloAgain(“Anna”))
// prints “Hello again, Anna!”

 

Parametri funzionali e valori di ritorno
In Swift i parametri di funzione e i valori di ritorno sono estremamente flessibili. È possibile definire qualsiasi cosa, da una semplice funzione di utilità con un unico parametro senza nome ad una funzione complessa con i nomi dei parametri espressivi e diverse opzioni per i parametri stessi.
Più parametri di input
Le funzioni possono avere più parametri di input, scritti fra parentesi nella funzione, separati da virgole.

Questa funzione richiede un inizio e un indice di fine per un intervallo semiaperto:

“func halfOpenRangeLength(start: Int, end: Int) -> Int {
return end – start
}
println(halfOpenRangeLength(1, 10))
// prints “9”

Funzioni senza parametri
Non si è tenuti a definire parametri di input per le funzioni. Eccone una senza parametri di input, che restituisce sempre lo stesso messaggio String ogni volta che viene chiamata:

func sayHelloWorld() -> String {
return “hello, world”
}
println(sayHelloWorld())
// prints “hello, world”

Funzioni senza valore di ritorno
La definizione di funzione ha ancora bisogno di parentesi dopo il nome, anche se non prende in input alcun parametro. Il nome della funzione è seguito anche da una coppia vuota di parentesi quando la funzione viene chiamata.


return end – start
}
println(halfOpenRangeLength(1, 10))
// prints “9”

Poichè non c’è bisogno di restituire un valore, la definizione della funzione non include la freccia di ritorno (->) o un tipo di ritorno.

“func printAndCount(stringToPrint: String) -> Int {
println(stringToPrint)
return countElements(stringToPrint)
}
func printWithoutCounting(stringToPrint: String) {
printAndCount(stringToPrint)
}
printAndCount(“hello, world”)
// prints “hello, world” and returns a value of 12
printWithoutCounting(“hello, world”)
// prints “hello, world” but does not return a value

La prima funzione, printAndCount, stampa una stringa, e poi restituisce il numero di caratteri come un int. La seconda funzione, printWithoutCounting, chiama la prima funzione, ma ignora il suo valore di ritorno. Quando la seconda funzione viene chiamata, il messaggio viene ancora stampato dalla prima funzione, ma il valore restituito non viene utilizzato.

Funzioni con più valori di ritorno
È possibile utilizzare un tipo di tupla come tipo di ritorno di una funzione per restituire più valori come parte del valore di ritorno.

L’esempio seguente definisce una funzione che conta il numero di vocali, consonanti, e altri caratteri in una stringa, in base al set standard di vocali e consonanti utilizzati in inglese:

func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
var vowels = 0, consonants = 0, others = 0
for character in string {
switch String(character).lowercaseString {
case “a”, “e”, “i”, “o”, “u”:
++vowels
case “b”, “c”, “d”, “f”, “g”, “h”, “j”, “k”, “l”, “m”,
“n”, “p”, “q”, “r”, “s”, “t”, “v”, “w”, “x”, “y”, “z”:
++consonants
default:
++others
}
}
return (vowels, consonants, others)
}

È possibile utilizzare questa funzione di conteggio per contare i caratteri in una stringa arbitraria, e per recuperare il totale di vocali e consonanti contate come una tupla di tre valori Int denominati:

let total = count(“some arbitrary string!”)
println(“\(total.vowels) vowels and \(total.consonants) consonants”)
// prints “6 vowels and 13 consonants”

Function Parameter Names
Tutte le funzioni di cui sopra definiscono i nomi dei parametri :

func someFunction(parameterName: Int) {
// function body goes here, and can use parameterName
// to refer to the argument value for that parameter
}

Tuttavia, questi nomi dei parametri sono utilizzati solo all’interno del corpo della funzione stessa, e non possono essere utilizzati quando si chiama la funzione. Questi tipi di nomi dei parametri sono noti come i nomi dei parametri locali, perché sono disponibili solo per l’uso all’interno del corpo della funzione.

VOLETE ESSERE AGGIORNATI TEMPESTIVAMENTE ALL’USCITA DI UN NUOVO CAPITOLO ? BASTA UN LIKE SULLA NOSTRA PAGINA FACEBOOK!