English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
In diesem Artikel werden Sie verschiedene benutzerdefinierte Funktionen lernen, die verschiedene Arten von Eingaben über Beispiele erhalten und Ausgaben zurückgeben.
Im vorherigen ArtikelSwift-Funktionenhabe wir die Funktionen gelernt. Jetzt werden wir die verschiedenen Arten und Methoden der Funktionserstellung in Swift untersuchen, d.h. die Verarbeitung von Eingaben und Ausgaben in Funktionen.
Diese Typen von Funktionen akzeptieren keine Eingaben und geben keine Werte zurück.
func funcname() {
//语句
}
oder
func funcname() -> () {
//语句
}
oder
func funcname() -> Void {
//语句
}Diese Syntax ist für die Erstellung von Funktionen ohne Parameter und ohne Rückgabewert gültig.
Die obige Syntax func funcname()->() ist auch gleich func funcname()->void, da void nur ein Alias für () ist. Sie können aufSwift-Typenbezeichnerum mehr Informationen zu erhalten.
func greetUser() {
print("Good Morning!")
}
greetUser()当您运行上述程序时，输出将是：
Good Morning!
Diese Typen von Funktionen akzeptieren keine Eingabeparameter und geben einen Wert zurück. Um einen Rückgabetyp hinzuzufügen, müssen Sie einen Pfeil (-）und Rückgabetyp.
func funcname() -> Rueckgabetyp {
//语句
return value
}func greetUser() -> String {
return "Good Morning!"
}
let msg = greetUser()
print(msg)当您运行上述程序时，输出将是：
Good Morning!
In dem obigen Programm haben Sie den Rückgabetyp als String definiert. Jetzt muss die Anweisung aus den Anweisungen innerhalb der Funktion eine Zeichenkette zurückgeben, andernfalls wird ein Fehler ausgelöst.
Der Schlüsselwort return überträgt die Kontrolle des Programms von der Funktion selbst auf die Funktionsauf呼叫。Fügen Sie, wenn Sie einen Wert zurückgeben möchten, den zu返回的值后面添加 return-Schlüsselwort.
Das Statement return "Good Morning!" gibt einen String-Typ-Wert zurück. Bitte beachten Sie, dass der Typ und der Wert des Rückgabewerts übereinstimmen müssen.
Sie können den Rückgabewert auch einer Variable oder einem Konstanten zuweisen. let msg = Der Rückgabewert wird der Konstanten msg zugewiesen. Daher gibt die Anweisung print(msg ) aus"Good Morning!".
Wenn Sie den Wert ignorieren möchten, verwenden Sie einfach Unterstrich _ , d.h. let _ = .
Parameter werden verwendet, um in der Funktion einzugeben. Parameter enthalten den Namen und den Typ, gefolgt von einem Doppelpunkt (:.) Diese Typen von Funktionen verwenden Eingangsparameter, geben aber keine Werte zurueck.
func funcname parameterName: Typ) {
//语句
}func greetUser(msg: String) {
print(msg)
}
greetUser(msg: "Good Morning!")当您运行上述程序时，输出将是：
Good Morning!
In dem obigen Programm akzeptiert diese Funktion einen einzigen Parameter vom Typ String. Dieser Parameter kann nur innerhalb der Funktion verwendet werden. msg ist der Name des Parameters.
Sie koennen die Funktion greetUser(msg: "Good Morning!") aufrufen, indem Sie dem Funktion eine Zeichenkette mit dem Namen msg uebergeben. Der Name des Parameters ist nur innerhalb der Funktion greetUser() sichtbar.
Daher gibt das Statement print(msg) aus "Good Morning!".
Diese Typen von Funktionen verwenden Parameter und geben Werte zurueck.
func funcname parameterName: Typ) -> Rueckgabetyp {
//语句
}func greetUser(name: String) -> String {
zurueck "Good Morning! " + name
}
lassen Sie msg = greetUser(name: "Jack")
print(msg)当您运行上述程序时，输出将是：
Good Morning! Jack
In dem obigen Programm akzeptiert diese Funktion einen einzelnen Parameter vom Typ String und gibt auch einen Wert vom Typ String zurueck: "Good Morning! Jack".
Diese Typen von Funktionen verwenden mehrere durch Komma getrennte Parameter und geben auch mehrere Werte zurueck. Sie koennen Tupel verwenden, um mehrere Werte in Swift zurueckzugeben.
func funcname parameterName: Typ, parameterName2: Typ, ...) -> (Rueckgabetyp, Rueckgabetyp...) {
//语句
}func greetUser(name: String, Alter: Int) -> (String, Int) {
let msg = "Good Morning!" + name
var userage = Alter
falls Alter < 0 {
userage = 0
}
zurueck (msg, userage)
}
lassen Sie msg = greetUser(name: "Jack", Alter: -2)
print(msg.0)
print("You have (msg.1) coins left")当您运行上述程序时，输出将是：
Good Morning!Jack You have 0 coins left
In dem obigen Programm akzeptiert die Funktion greetUser() mehrere Parameter vom Typ String und Int. Die Funktion gibt auch mehrere Werte zurück, deren Typ String und Int sind.
Um jeden Rückgabewert zu erreichen, verwenden wir die Indexposition 0,1, … Hier verwenden wir msg.0, um "Good Morning!Jack" und msg.1 den Zugriff auf "0".
Die Verwendung von Indexpositionen kann manchmal unübersichtlich und nicht lesbar sein. Wir können dieses Problem elegant lösen, indem wir den Rückgabewerten Namen zuweisen. Der obige Programmcode kann auch auf die folgende Weise neu geschrieben werden.
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 diesem Programm ist der Rückgabetyp ein Tupel, das Variable names enthält, die diesen Typ haben. Der Hauptvorteil dabei ist, dass Sie die Variablennamen msg.name und msg.coins verwenden können ersetzend msg.0 und msg.1 um das Ergebnis abzurufen.
Bei der Definition von Funktionen, die Eingaben akzeptieren, kann man mit Hilfe der Parameternamen den Eingabennamen definieren. Es gibt jedoch auch einen anderen Namen, der zusammen mit dem Parameternamen verwendet werden kann, und das ist das Parameterkennzeichen.
Die Verwendung von Variablenkennzeichnern ermöglicht es, Funktionen auf eine Art und Weise wie eine Phrase aufzurufen, gleichzeitig bietet sie einen lesbaren und klaren Funktionskörper.
Jeder Funktionsparameter hat ein Parameterkennzeichen und einen Parameternamen. Standardmäßig wird der Parameternamen als Parameterkennzeichen verwendet. Wenn Sie jedoch den Parameternamen explizit definieren, wird bei der Aufrufung der Funktion das Parameterkennzeichen verwendet.
Die Syntax der Funktion mit Parameterkennzeichnung ist
func funcname(argumentLabel parameterName: Type)-> 返回类型 {
//语句
}Lassen Sie dies in den folgenden Beispielen sehen.
func sum(a:Int, b:Int) -> Int {
return a + b
}
let result = sum(a: 2, b: 3)
print("Die Summe beträgt \(result)")当您运行上述程序时，输出将是：
Die Summe beträgt 5
Im obigen Beispiel haben wir keine Parameterbezeichner angegeben, daher verwendet der Aufruf der Funktion standardmäßig die Default-Parameternamen a und b als Parameterbezeichner.
Wenn Sie den Funktionsaufruf aufrufen, werden Sie möglicherweise bemerken, dass der Funktionsaufruf nicht ausdrucksfähig ist/Satz. Wenn Sie den Funktionsaufruf so setzen können:
let result = sum(of: 2, und: 3)
Lassen Sie uns die Funktion ändern:
func sum(of Int, and Int) -> Int {
return von + und
}
let result = sum(of: 2, und: 3)
print("Die Summe beträgt \(result)")Jetzt ist die Methodenaufforderung ausdrucksfähig. Aber jetzt müssen wir die Parameternamen von und und verwenden, return von + und um die Summe zweier Zahlen zu finden. Dies macht den Funktionskörper weniger lesbar. Die Verwendung von a und b anstelle von von und und ist hier sinnvoller.
Dazu müssen wir die Parametertags explizit definieren:
func sum(of a:Int, and b:Int) -> Int {
return a + b
}
let result = sum(of: 2, und: 3)
print("Die Summe beträgt \(result)")In dem obigen Programm akzeptiert die Funktion zwei Parameter vom Typ Int. Der Funktionsaufruf verwendet die Parameterbezeichner von und und, was auch bei dem Aufruf der Funktion sum(of:) 2, and: 3), anstatt sum(a: 2, b: 3)
Außerdem verwendet der Funktionskörper die Parameternamen a und b, anstatt von und und, was bei der Anwendung von Operationen auch sinnvoller ist.
Sie können auch durch Schreiben eines Unterstrichs _ vor dem Parameternamen den Parametertag weglassen.
func sum(_ a:Int, _ b:Int) -> Int {
return a + b
}
let result = sum(2, 3)
print("Die Summe beträgt \(result)")Sie können Standardwerte für jeden Parameter in der Funktion bereitstellen, indem Sie nach dem Typ des Parameters einen Wert für den Parameter zuweisen. Standardparameter können verwendet werden, um den Parameter beim Aufruf der Funktion zu ignorieren.
Wenn der Wert für einen Parameter beim Aufruf der Funktion nicht übergeben wird, wird der Standardwert verwendet. Aber wenn der Wert beim Aufruf explizit an den Parameter übergeben wird, wird der angegebene Wert verwendet.
func funcname(parameterName:Type = value) -> 返回类型 {
//语句
}func sum(of a:Int = 7, und b:Int = 8) -> Int {
return a + b
}
let result1 = sum(of: 2, und: 3)
print("Die Summe beträgt \(result1))
let result2 = sum(of: 2)
print("Die Summe beträgt \(result2))
let result3 = sum(and: 2)
print("Die Summe beträgt \(result3))
let result4 = sum()
print("Die Summe beträgt \(result4))当您运行上述程序时，输出将是：
Die Summe beträgt 5 Die Summe beträgt 10 Die Summe beträgt 9 Die Summe beträgt 15
Im obigen Programm nimmt die Funktion sum(of a: Int = 7 , and b: Int = 8) -> Int akzeptiert zwei Int-Typen als Parameter und gibt die Parameter an a=7und b=8der Standardwert.
Wenn Sie value als Parameter im Aufruf der Funktion übergeben, ist sum(of: 2, and: 3) wird verwendet2und3anstelle des Standardwerts des Parameters verwendet.
Wenn Sie den Parameterwert jedoch nicht als sum() übergeben, wird der Standardwert7und8als Parameterwert.
Variablenargumente können null oder mehrere spezifische Typen von Werten akzeptieren. Sie können durch die Einfügung von drei Punkten (...) nach dem Namen des Parameter-Typs ein variabler Parameter angegeben werden.
Wenn verschiedene Mengen an Eingabewerten beim Aufruf der Funktion an die Parameter übergeben werden müssen, wird in der Regel ein variabler Parameter verwendet. Zum Beispiel eine Liste von Zahlen, eine Liste von Buchstaben und so weiter.
Die Syntax der Funktion mit variablen Argumenten ist:
func funcname(parameterName: Type ...) -> 返回类型 {
//语句
}func sum(of numbers: Int ...) {
var result = 0
for num in numbers {
result += num
}
print("Die Summe der Zahlen ist (result)")
}
sum(of: 1, 2, 3, 4, 5, 6, 7, 8)In dem obigen Programm nimmt die Funktion sum(of numbers: Int ...) variable Int-Typen als Parameter an. Variablenargumente können mehrere durch Kommas getrennte Werte akzeptieren sum(of: 1, 2, 3, 4, 5, 6, 7, 8)
als Werte, die als Variablenargument übergeben werden1,2,3,4,5,6,7,8Kann im Körper als Array vom Typ Int verwendet werden. Daher können wir for-in der Schleife wird als for num in numbers angewendet.
当您运行上述程序时，输出将是：
Die Summe der Zahlen ist 36
Hinweis: Die eingebauten print()-Funktionen von Swift akzeptieren auch beliebige Arten von Variablenargumenten.
Any stellt jeden Datentyp in Swift dar, z.B. Int, Float, Double, String und so weiter.
Bei der Definition von Funktionsparametern können Sie die Funktionsparameter im Körper nicht ändern. Daher sind sie standardmäßig Konstanten. Lassen Sie uns in einem Beispiel sehen:
func process(name: String) {
if name == ""{
name = "guest"
}
}Der obige Code führt zu einem Compilation-Fehler, weil Sie den Wert des Parameters nicht ändern können.
Wenn Sie möchten, dass die Funktion den Wert des Parameters ändert, müssen Sie den Parameter als in definieren-out-Parameter. Sie können einen input schreiben, indem Sie den inout-Schlüssel vor dem Parameter-Typ platzieren/Ausgabeparameter.
Im Hintergrund ein in-Der out-Parameter hat einen Wert, der an die Funktion übergeben wird, von der Funktion geändert wird und dann zurück an die Funktion übergeben wird, um den ursprünglichen Wert zu ersetzen. Daher dürfen die Werte, die in der Funktion aufgerufen werden, keine Konstanten sein. Sie müssen sie als Variable deklarieren.
具有 inout 参数的函数的语法为：
func funcname(parameterName: inout Type) -> 返回类型 {
//语句
}func process(name: inout String) {
if name == ""{
name = "guest"
}
}
var userName = ""
process(name: &userName)
print(userName)当您运行上述程序时，输出将是：
guest
在上面的程序中，我们声明了一个接受 inout 参数的函数，以便可以在函数体内更改/更改参数 name。
在将参数传递给 in-在传递 out 参数时，必须在变量名前直接使用 & 号，以便函数可以修改它。