English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
In questo articolo, imparerai diverse funzioni definite dall'utente, che riceveranno diversi tipi di input e restituiranno output attraverso esempi.
Nell'articolo precedenteFunzioni in Swiftabbiamo imparato cosa sono le funzioni. Ora, esploreremo diversi modi e tipi di creazione delle funzioni in Swift, ovvero come gestire l'input e l'output nelle funzioni.
Questi tipi di funzioni non accettano alcun input e non restituiscono alcun valore.
func funcname() {
//Statementi
}
oppure
func funcname() -> () {
//Statementi
}
oppure
func funcname() -> Void {
//Statementi
}Tutte le sintassi elencate sono valide per creare funzioni senza parametri e senza valore di ritorno.
La sintassi func funcname()->() è equivalente a func funcname()->void, poiché void è un alias di tipo per (). Puoi accedere aAlias di tipo Swiftper ottenere ulteriori informazioni.
func greetUser() {
print("Buongiorno!")
}
greetUser()Quando si esegue il programma sopra, l'output sarà:
Buongiorno!
Questi tipi di funzioni non accettano alcun parametro di input, ma restituiscono un valore. Per aggiungere il tipo di ritorno, aggiungi un freccia (->) e il tipo di ritorno.
func funcname() -> ReturnType {
//Statementi
return value
}func greetUser() -> String {
return "Buongiorno!"
}
let msg = greetUser()
print(msg)Quando si esegue il programma sopra, l'output sarà:
Buongiorno!
Nel programma sopra, hai definito il tipo di ritorno come String. Ora, la dichiarazione deve restituire una stringa da una dichiarazione interna alla funzione, altrimenti genererai un errore.
Il关键字 return trasferisce il controllo del programma dal corpo della funzione alla chiamata della funzione. Se è necessario restituire un valore dalla funzione, aggiungi il valore da restituire dopo il chiave word return.
return "Buongiorno!" restituisce un valore di tipo String. Nota che il tipo e il valore del valore di ritorno devono corrispondere.
Puoi anche assegnare il valore di ritorno a una variabile o una costante. let msg = assegna il valore di ritorno alla costante msg. Pertanto, la dichiarazione print(msg) produce"Buongiorno!".
Se desideri ignorare il valore, utilizza semplicemente un trattino basso _, ovvero let _ =.
I parametri vengono utilizzati per introdurre dati nelle funzioni. I parametri includono il nome e il tipo, seguiti da due punti (:. Questi tipi di funzioni accettano parametri di input ma non restituiscono valori.
func funcname(parameterName:Type) {
//Statementi
}func greetUser(msg:String) {
print(msg)
}
greetUser(msg: "Buongiorno!")Quando si esegue il programma sopra, l'output sarà:
Buongiorno!
Nel programma sopra, la funzione accetta un singolo parametro di tipo stringa. Il parametro può essere utilizzato solo all'interno della funzione. msg è il nome del parametro.
Puoi chiamare la funzione greetUser(msg: "Buongiorno!") passando un valore di stringa con il nome del parametro msg. Il nome del parametro è visibile solo all'interno della funzione greetUser().
Quindi, la dichiarazione print(msg) produce "Buongiorno!".
Questi tipi di funzioni utilizzano parametri e restituiscono valori.
func funcname(parameterName:Type) -> ReturnType {
//Statementi
}func greetUser(name: String) -> String {
return "Good Morning! " + name
}
let msg = greetUser(name: "Jack")
print(msg)Quando si esegue il programma sopra, l'output sarà:
Good Morning! Jack
Nel programma sopra, la funzione accetta un singolo parametro di tipo String e restituisce il valore di tipo String “Good Morning! Jack”.
Questi tipi di funzioni accettano più parametri separati da virgola e restituiscono anche più valori. Puoi usare i tuple per restituire più valori in Swift.
func funcname(parameterName: Type, parameterName2: Type, ...) -> (ReturnType, ReturnType...) {
//Statementi
}func greetUser(name: String, age: Int) -> (String, Int) {
let msg = "Good Morning!" + name
var userage = age
if age < 0 {
userage = 0
}
return (msg, userage)
}
let msg = greetUser(name: "Jack", age: -2)
print(msg.0)
print("Ti rimangono \(msg.1) monete")Quando si esegue il programma sopra, l'output sarà:
Good Morning!Jack Ti rimangono 0 monete
Nel programma sopra, la funzione greetUser() accetta più parametri di tipo String e Int. La funzione restituisce anche più valori, di tipo String e Int.
Per accedere a ciascun valore di ritorno, usiamo gli indici di posizione 0, 1, ecc. In questo caso, usiamo msg.0 per accedere a “Good Morning!Jack” e msg.1 per accedere a “0”.
L'uso dell'indice di posizione a volte può essere non intuitivo e non leggibile. Possiamo risolvere questo problema elegantemente assegnando nomi ai valori di ritorno. Il programma sopra può essere riscritto come segue.
func greetUser(name: String, coins: Int) -> (name: String, coins: Int) {
let msg = "Good Morning!" + name
var userCoins = coins
if coins < 0 {
userCoins = 0
}
return (msg, userCoins)
}
let msg = greetUser(name: "Jack", coins: -2)
print(msg.name)
print("You (msg.coins) coins left")In questo programma, il tipo di ritorno è un tuple che contiene i nomi delle variabili di quel tipo. Un grande vantaggio di questo è che è possibile utilizzare i nomi delle variabili msg.name e msg.coins invece di msg.0 e msg.1 per accedere ai risultati.
Quando si definisce una funzione che accetta input, è possibile definire il nome dell'input con l'aiuto del nome del parametro. Ma c'è anche un altro nome che può essere utilizzato insieme al nome del parametro, chiamato tag del parametro.
L'uso dei tag dei parametri permette di chiamare la funzione in modo espressivo, simile a una frase, mantenendo al contempo un corpo della funzione leggibile e chiaro.
Ogni parametro della funzione ha un tag del parametro e un nome del parametro. Di default, il parametro utilizza il suo nome del parametro come tag del parametro. Ma, se avete definito chiaramente il nome del parametro, alla chiamata della funzione utilizzerà il tag del parametro.
La sintassi della funzione con tag dei parametri è
func funcname(argumentLabel parameterName: Type) -> Return Type {
//Statementi
}Vediamo questo nel seguente esempio.
func sum(a: Int, b: Int) -> Int {
return a + b
}
let result = sum(a: 2, b: 3)
print("La somma è \(result)")Quando si esegue il programma sopra, l'output sarà:
La somma è 5
Nell'esempio sopra, non abbiamo specificato i tag dei parametri, quindi alla chiamata della funzione utilizzerà i nomi dei parametri predefiniti a e b come tag dei parametri.
Quando si chiama la funzione, potrebbe notarsi che la chiamata di funzione non è espressiva/sintattica. Se potete impostare la chiamata di funzione come:
let result = sum(of: 2, and: 3)
Ora, cambiiamo la funzione:
func sum(of: Int, and: Int) -> Int {
return of + and
}
let result = sum(of: 2, and: 3)
print("La somma è \(result)")Ora, la chiamata di metodo è espressiva. Ma, ora dobbiamo utilizzare i nomi dei parametri of＆and, return of + and per trovare la somma di due numeri. Questo rende il corpo della funzione meno leggibile. È più significativo usare a e b al posto di of＆and nel corpo della funzione.
Per questo, dobbiamo definire chiaramente i tag dei parametri:
func sum(of a :Int, and b:Int) -> Int {
return a + b
}
let result = sum(of: 2, and: 3)
print("La somma è \(result)")Nel programma sopra, la funzione accetta due parametri di tipo Int. La chiamata della funzione utilizza i tag dei parametri of & and, come nella chiamata della funzione sum(of: 2, and: 3), piuttosto che sum(a: 2, b: 3).
Inoltre, il corpo della funzione utilizza i nomi dei parametri a e b, invece di of & and, il che è anche più significativo nell'applicazione delle operazioni.
Puoi anche omettere i tag dei parametri scrivendo un trattino basso _ davanti al nome del parametro.
func sum(_ a :Int, _ b:Int) -> Int {
return a + b
}
let result = sum(2, 3)
print("La somma è \(result)")Puoi assegnare un valore di default a qualsiasi parametro della funzione, assegnando un valore al parametro dopo il tipo del parametro. L'uso di parametri con valori di default ti permette di ignorare il parametro durante la chiamata della funzione.
Se non si passa un valore ai parametri durante la chiamata della funzione, viene utilizzato il valore di default. Tuttavia, se si passa esplicitamente un valore ai parametri durante la chiamata, viene utilizzato il valore specificato.
func funcname(parameterName:Type = value) -> Return Type {
//Statementi
}func sum(of a :Int = 7, and b:Int = 8) -> Int {
return a + b
}
let result1 = sum(of: 2, and: 3)
print("La somma è \(result1)")
let result2 = sum(of: 2)
print("La somma è \(result2)")
let result3 = sum(and: 2)
print("La somma è \(result3)")
let result4 = sum()
print("La somma è \(result4)")Quando si esegue il programma sopra, l'output sarà:
La somma è 5 La somma è 10 La somma è 9 La somma è 15
Nel programma sopra, la funzione sum(of a :Int = 7, and b:Int = 8) -> Int accetta due parametri di tipo Int e assegna valori di default a a=7 e b=8.
If value is passed as a parameter in the function call, sum(of: 2, and: 3) is used.2and3Instead of the parameter default value.
But if you do not pass the parameter value as sum(), then the default values 7 and 8 will be used as the parameter values.
Variable arguments can accept zero or more specific types of values. You can specify variable arguments by inserting three dot characters (...) after the parameter type name.
When it is necessary to pass various numbers of input values to the parameters when calling a function, it is usually used with variable arguments. For example, a list of numbers, a list of letters, etc.
The syntax for a function with variable arguments is:
func funcname(parameterName: Type...) -> Return Type {
//Statementi
}func sum(of numbers: Int...) {
var result = 0
for num in numbers {
result += num
}
print("The sum of the numbers is \(result)")
}
sum(of: 1, 2, 3, 4, 5, 6, 7, 8)In the above program, the function sum(of numbers: Int...) accepts variable arguments of type Int. Variable arguments can accept multiple values separated by commas, such as sum(of: 1, 2, 3, 4, 5, 6, 7, 8).
Values passed as variable arguments1, 2, 3, 4, 5, 6, 7, 8It can be used as an Int type array within the function body. Therefore, we can apply the for-in loop as for num in numbers.
Quando si esegue il programma sopra, l'output sarà:
The sum of the numbers is 36
Note: Swift's built-in print() function also accepts arbitrary types of variable arguments.
Any represents any data type in Swift, such as Int, Float, Double, String, etc.
When defining function parameters, you cannot modify function parameters within the body. Therefore, by default, they are constants. Let's see an example in the sample:
func process(name: String) {
if name == ""{
name = "guest"
}
}The above program will cause a compile-time error because you cannot change the value of the parameter.
If you want the function to modify the parameter value, you need to define the parameter as an in-out parameter. You can write input/output parameters by placing the inout keyword before the parameter type.
In background, an in-out parameter has a value that is passed to the function, modified by the function, and then passed back from the function to replace the original value. Therefore, the value passed in the function call cannot be a constant. You must declare it as a variable.
La sintassi delle funzioni con parametri in-out è:
func funcname(parameterName: inout Type) -> Return Type {
//Statementi
}func process(name: inout String) {
if name == ""{
name = "guest"
}
}
var userName = ""
process(name: &userName)
print(userName)Quando si esegue il programma sopra, l'output sarà:
guest
Nel programma sopra, abbiamo dichiarato una funzione che accetta un parametro in-out per modificare/aggiornare il parametro name all'interno della funzione.
Quando si passano parametri a un parametro in-out, è necessario utilizzare direttamente il simbolo & davanti al nome della variabile in modo che la funzione possa modificarlo.