Nomi dei parametri esterni
A volte è utile dare un nome ad ogni parametro quando si chiama una funzione.

Se si desidera che gli utenti che utilizzeranno le vostre funzioni forniscano i nomi dei parametri quando chiamano la funzione, definire un nome  per ogni parametro esterno, in aggiunta al nome del parametro locale. Si scrive un nome di parametro esterno prima del nome del parametro locale , separati da uno spazio:

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

Si consideri la seguente funzione, che unisce due stringhe con l’inserimento di un terzo “joiner” tra di loro:

“func join(s1: String, s2: String, joiner: String) -> String {
return s1 + joiner + s2
}

Quando si chiama questa funzione, lo scopo dei tre parametri che vengono passati alla funzione non è chiaro:

join(“hello”, “world”, “, “)
// returns “hello, world”

Per rendere tutto più chiaro, definire i nomi dei parametri esterni:

func join(string s1: String, toString s2: String, withJoiner joiner: String)
-> String {
return s1 + joiner + s2
}

In questa versione della funzione join, il primo parametro ha un nome esterno di stringa e un nome locale di s1; il secondo parametro ha un nome esterno di toString e un nome locale di s2; e il terzo parametro ha un nome esterno di withJoiner e un nome locale di joiner.

È ora possibile utilizzare questi nomi di parametri esterni per chiamare la funzione in modo chiaro e inequivocabile:

“join(string: “hello”, toString: “world”, withJoiner: “, “)
// returns “hello, world”

Parametri per i nomi esterni
Se si desidera fornire un nome di parametro esterno per un parametro di una funzione, e il nome del parametro locale è già un nome appropriato da usare, non è necessario scrivere lo stesso nome due volte per quel parametro. Invece, scrivere il nome una volta, e apporre il simbolo cancelletto al parametro (#). Questo farà capire a Swift di usare quel nome come fosse il nome del parametro locale e il nome del parametro esterno.

Questo esempio definisce una funzione chiamata containsCharacter, che definisce i nomi dei parametri esterni per entrambi i parametri mettendo un # davanti ai loro nomi:

func containsCharacter(#string: String, #characterToFind: Character) -> Bool {
for character in string {
if character == characterToFind {
return true
}
}
return false
}

La scelta utilizzata per questa funzione elimina ogni ambiguità:

let containsAVee = containsCharacter(string: “aardvark”, characterToFind: “v”)
// containsAVee equals true, because “aardvark” contains a “v”

Valori dei parametri di default
È possibile definire un valore di default per ogni parametro come parte della definizione di una funzione. Se un valore di default è definito, è possibile omettere il parametro quando si chiama la funzione.

Ecco una versione della funzione join da prima, che fornisce un valore predefinito per il suo parametro joiner:

func join(string s1: String, toString s2: String,
withJoiner joiner: String = ” “) -> String {
return s1 + joiner + s2
}

Se un valore di stringa per joiner viene fornito quando la funzione join viene chiamata,  il valore di stringa viene utilizzato in questo modo:

join(string: “hello”, toString: “world”, withJoiner: “-“)
// returns “hello-world”

Tuttavia, se nessun valore di joiner viene fornito quando la funzione viene chiamata, il valore predefinito di un unico spazio (“”) viene usato al posto:

“join(string: “hello”, toString: “world”)
// returns “hello world”

Nomi esterni per i parametri con valori di default
Nella maggior parte dei casi, è utile fornire un nome esterno per ogni parametro con un valore predefinito. Questo assicura che l’argomento per tale parametro sia chiaro nel momento in cui la funzione viene chiamata.

Per rendere questo processo più semplice, Swift fornisce un nome esterno automatico per qualsiasi parametro default che viene definito, se non si specifica un nome esterno da soli. Il nome esterno automatico è lo stesso del nome locale, come se si fosse apposto il cancelletto prima del nome locale nel codice.

Ecco una versione della funzione join di prima, che non prevede nomi esterni per uno qualsiasi dei suoi parametri, ma comunque fornisce un valore predefinito per il suo parametro joiner:

func join(s1: String, s2: String, joiner: String = ” “) -> String {
return s1 + joiner + s2
}

In questo caso, Swift fornisce automaticamente un nome di parametro esterno a joiner per il parametro default. Il nome esterno deve essere fornito quando si chiama la funzione, rendendo lo scopo del parametro chiaro e inequivocabile:

join(“hello”, “world”, joiner: “-“)
// returns “hello-world”‌

Un parametro variadic accetta zero o più valori di un tipo specificato. Si utilizza un parametro variadic per specificare che al parametro può essere passato un numero variabile di valori di ingresso quando la funzione viene chiamata.

I valori passati ad un parametro variadic sono resi disponibili all’interno del corpo della funzione come una matrice del tipo appropriato. Ad esempio, un parametro variadic con un nome numerico di tipo double  è reso disponibile all’interno del corpo della funzione sotto forma di matrice costante di tipo double [].

L’esempio seguente calcola la media aritmetica (noto anche come media) per un elenco dei numeri di qualsiasi lunghezza:

func arithmeticMean(numbers: Double…) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(3, 8, 19)
// returns 10.0, which is the arithmetic mean of these three numbers

 

Parametri costanti e variabili
Parametri di funzione sono costanti per impostazione predefinita.

Tuttavia, a volte è utile per una funzione avere una copia variabile del valore di un parametro con cui lavorare.

Definire i parametri variabili anteponendo al nome del parametro con la parola chiave var:

“func alignRight(var string: String, count: Int, pad: Character) -> String {
let amountToPad = count – countElements(string)
for _ in 1…amountToPad {
string = pad + string
}
return string
}
let originalString = “hello”
let paddedString = alignRight(originalString, 10, “-“)
// paddedString is equal to “—–hello”
// originalString is still equal to “hello”

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