Swift-Funktionen

Swift-Funktionen sind eigenständige Codeblöcke, die bestimmte Aufgaben ausführen.

Swift verwendet eine einheitliche Syntax, um Funktionen darzustellen, von einfachen Funktionen im C-Stil bis hin zu komplexen Methoden im Objective-C-Stil.

  • Funktionsdeklaration: Teilt dem Compiler den Namen, den Rückgabetyp und die Parameter der Funktion mit.

  • Funktionsdefinition: Stellt den Funktionskörper bereit.

Swift-Funktionen umfassen Parametertypen und Rückgabewerttypen:

Funktionsdefinition

Swift definiert Funktionen mit dem Schlüsselwortfunc。

Beim Definieren einer Funktion können Sie einen oder mehrere Eingabeparameter und einen Rückgabetyp angeben.

Jede Funktion hat einen Funktionsnamen, der ihre Funktion beschreibt. Sie rufen diese Funktion über ihren Namen und Parameterwerte der entsprechenden Typen auf. Die Reihenfolge, in der Funktionsargumente übergeben werden, muss mit der Parameterliste übereinstimmen.

Die Reihenfolge, in der die tatsächlichen Argumente der Funktion übergeben werden, muss mit der formalen Parameterliste übereinstimmen,->Dann definieren Sie den Rückgabetyp der Funktion.

Syntax

func funcname(形参) -> returntype
{
   Statement1
   Statement2
   ……
   Statement N
   return parameters
}

Beispiel

Im Folgenden definieren wir eine Funktion mit dem Namen example, mit einem formalen Parameter vom Typ String und einem Rückgabewert vom Typ String:

import Cocoa

func example(site: String) -> String {
    return (site)
}
print(example(site: "www.example.com"))

Die Ausgabe der obigen Programmausführung ist:

www.example.com

Funktionsaufruf

Wir können eine Funktion mit ihrem Namen und Parameterwerten der entsprechenden Typen aufrufen. Die Reihenfolge, in der die Argumente der Funktion übergeben werden, muss mit der Parameterliste übereinstimmen.

Unten definieren wir eine Funktion namens example mit einem formalen Parameter site vom Typ String. Wenn wir die Funktion aufrufen, muss das übergebene tatsächliche Argument ebenfalls vom Typ String sein. Nachdem das Argument in den Funktionskörper übergeben wurde, wird es direkt zurückgegeben, und der zurückgegebene Datentyp ist String.

import Cocoa

func example(site: String) -> String {
    return (site)
}
print(example(site: "www.example.com"))

Die Ausgabe der obigen Programmausführung ist:

www.example.com

Funktionsparameter

Eine Funktion kann einen oder mehrere Parameter akzeptieren. Diese Parameter stehen in den Klammern der Funktion und werden durch Kommas getrennt.

Das folgende Beispiel übergibt den Website-Namen name und die Website-Adresse site an die Funktion example:

import Cocoa

func example(name: String, site: String) -> String {
    return name + site
}
print(example(name: "Example：", site: "www.example.com"))
print(example(name: "Google：", site: "www.google.com"))

Die Ausgabe der obigen Programmausführung ist:

Example：www.example.com
Google：www.google.com

Funktionen ohne Parameter

Wir können Funktionen ohne Parameter erstellen.

Syntax:

func funcname() -> datatype {
   return datatype
}

Beispiel

import Cocoa

func sitename() -> String {
    return "Example"
}
print(sitename())

Die Ausgabe der obigen Programmausführung ist:

Rookie Tutorial

Tupel als Rückgabewert einer Funktion

Rückgabetypen von Funktionen können Strings, Ganzzahlen, Gleitkommatypen usw. sein.

Tupel ähneln Arrays, außer dass die Elemente in einem Tupel von beliebigem Typ sein können und in Klammern eingeschlossen sind.

Sie können einen Tupeltyp verwenden, um mehrere Werte als einen zusammengesetzten Wert von einer Funktion zurückzugeben.

Im folgenden Beispiel wird eine Funktion namens minMax(_:) definiert, um die minimalen und maximalen Werte in einem Int-Array zu finden.

import Cocoa

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("最小值为 \(bounds.min) ，最大值为 \(bounds.max)")

Die Funktion minMax(_:) gibt ein Tupel zurück, das zwei Int-Werte enthält, die mit min und max beschriftet sind, sodass beim Abfragen des Rückgabewerts der Funktion über den Namen auf sie zugegriffen werden kann.

Die Ausgabe der obigen Programmausführung ist:

最小值为 -6 ，最大值为 109

Wenn Sie sich nicht sicher sind, dass das zurückgegebene Tupel nicht nil ist, können Sie einen optionalen Tupeltyp zurückgeben.

Sie können ein optionales Tupel definieren, indem Sie ein Fragezeichen nach der schließenden Klammer des Tupeltyps setzen, zum Beispiel (Int, Int)? oder (String, Int, Bool)?

Hinweis
Optionale Tupeltypen wie(Int, Int)?und Tupel, die optionale Typen enthalten, wie(Int?, Int?)sind unterschiedlich. Bei einem optionalen Tupeltyp ist das gesamte Tupel optional, nicht nur jeder Elementwert im Tupel.

Die vorherigeminMax(_:)Funktion gibt ein Tupel zurück, das zweiIntWerte enthält. Die Funktion führt jedoch keine Sicherheitsprüfungen für das übergebene Array durch. Wenn derarrayParameter ein leeres Array ist, die oben definierteminMax(_:)wird beim Zugriff aufarray[0]zu einem Laufzeitfehler führen.

Um dieses "leeres Array"-Problem zu behandeln, ändern Sie dieminMax(_:)Funktion, um einen optionalen Tupel-Rückgabetyp zu verwenden, und wenn das Array leer ist, zurückgebennil：

import Cocoa

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}
if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("最小值为 \(bounds.min)，最大值为 \(bounds.max)")
}

Die Ausgabe der obigen Programmausführung ist:

最小值为 -6，最大值为 109

Funktionen ohne Rückgabewerte

Unten ist eine weitere Version der Funktion example(_:). Diese Funktion nimmt die offizielle Website-URL von Example als Parameter, gibt keinen Rückgabetyp an und gibt direkt einen String-Wert aus, anstatt ihn zurückzugeben:

import Cocoa

func example(site: String) {
    print("Example官网：\(site)")
}
example(site: "http://www.example.com")

Die Ausgabe der obigen Programmausführung ist:

Example官网：http://www.example.com

Funktionsparameternamen

Funktionsparameter haben sowohl einen externen Parameternamen als auch einen lokalen Parameternamen.

Lokale Parameternamen

Lokale Parameternamen werden innerhalb der Implementierung der Funktion verwendet.

func sample(number: Int) {
   println(number)
}

Im obigen Beispiel ist number ein lokaler Parametername und kann nur innerhalb des Funktionskörpers verwendet werden.

import Cocoa

func sample(number: Int) {
    print(number)
}
sample(number: 1)
sample(number: 2)
sample(number: 3)

Die Ausgabe der obigen Programmausführung ist:

1
2
3

Externe Parameternamen

Sie können einen externen Parameternamen vor dem lokalen Parameternamen angeben, getrennt durch ein Leerzeichen. Der externe Parametername wird beim Aufrufen der Funktion verwendet, um das Argument an die Funktion zu übergeben.

Wie folgt können Sie die folgenden zwei Funktionsparameternamen definieren und die Funktion aufrufen:

import Cocoa

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}
pow(firstArg:5, secondArg:3)

Die Ausgabe der obigen Programmausführung ist:

125

Hinweis
Wenn Sie einen externen Parameternamen angeben, muss die Funktion beim Aufruf den externen Parameternamen verwenden.

Variadische Parameter

Variadische Parameter können null oder mehr Werte annehmen. Beim Aufruf einer Funktion können Sie einen variadischen Parameter verwenden, um Funktionsparameter anzugeben, wobei die Anzahl unbestimmt ist.

Variadische Parameter werden definiert, indem (...) nach dem Variablentypnamen hinzugefügt wird.

import Cocoa

func vari<N>(members: N...){
    for i in members {
        print(i)
    }
}
vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Google", "Baidu", "Example")

Die Ausgabe der obigen Programmausführung ist:

4
3
5
4.5
3.1
5.6
Google
Baidu
Example

Konstanten, Variablen und In-Out-Parameter

Im Allgemeinen sind in einer Funktion definierte Parameter standardmäßig konstante Parameter, was bedeutet, dass Sie diesen Parameter nur abfragen und verwenden, aber seinen Wert nicht ändern können.

Wenn Sie einen variablen Parameter deklarieren möchten, können Sie das Schlüsselwort inout vor der Parameterdefinition hinzufügen, sodass der Wert dieses Parameters geändert werden kann.

Zum Beispiel:

func  getName(_ name: inout String).........

An diesem Punkt kann der Wert von name innerhalb der Funktion geändert werden.

Im Allgemeinen erfolgt die Standardparameterübergabe als Wert, nicht als Referenz. Wenn der übergebene Parameter innerhalb der Funktion geändert wird, wirkt sich das daher nicht auf den ursprünglichen Parameter aus. Es wird nur eine Kopie dieses Parameters übergeben.

Wenn ein übergebener Parameter als Eingabe-/Ausgabeparameter verwendet wird, müssen Sie vor dem Parameternamen ein &-Symbol hinzufügen, um anzugeben, dass dieser Wert von der Funktion geändert werden kann.

Beispiel

import Cocoa

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}


var x = 1
var y = 5
swapTwoInts(&x, &y)
print("x 现在的值 \(x), y 现在的值 \(y)")

Die Funktion swapTwoInts(_:_:) vertauscht einfach die Werte von a und b. Die Funktion speichert zuerst den Wert von a in einer temporären Konstanten temporaryA, weist dann a den Wert von b zu und weist schließlich b den Wert von temporaryA zu.

Es ist zu beachten, dass someInt und anotherInt beide ein & vorangestellt bekommen, bevor sie in die Funktion swapTwoInts(_:_:) übergeben werden.

Die Ausgabe der obigen Programmausführung ist:

x 现在的值 5, y 现在的值 1

Funktionstypen und Verwendung

Jede Funktion hat einen spezifischen Funktionstyp, der aus den Parametertypen und dem Rückgabetyp der Funktion besteht.

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

Der Funktionstyp von inputs hat zwei Int-Parameter (no1, no2) und gibt einen Int-Wert zurück.

Beispiel:

import Cocoa

func inputs(no1: Int, no2: Int) -> Int {
    return no1/no2
}
print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))

Die Ausgabe der obigen Programmausführung ist:

2
6

Die obige Funktion definiert zwei Int-Parametertypen, und der Rückgabewert ist ebenfalls vom Typ Int.

Sehen wir uns als Nächstes die folgende Funktion an. Die Funktion definiert einen Parameter vom Typ String und einen Rückgabewert vom Typ String.

func inputstr(name: String) -> String {
   return name
}

Eine Funktion kann auch eine Funktion ohne Parameter und ohne Rückgabewert definieren, wie unten gezeigt:

import Cocoa

func inputstr() {
   print("Example")
   print("www.example.com")
}
inputstr()

Die Ausgabe der obigen Programmausführung ist:

Example
www.example.com

Verwenden von Funktionstypen

In Swift ist die Verwendung von Funktionstypen genauso wie die Verwendung jedes anderen Typs. Zum Beispiel können Sie eine Konstante oder Variable definieren, deren Typ eine Funktion ist, und ihr eine passende Funktion zuweisen:

var addition: (Int, Int) -> Int = sum

Erklärung:

Definieren Sie eine Variable namensadditionderen Parameter- und Rückgabewerttypen beideInt, und lassen Sie diese neue Variable auf diesumFunktion.

sumundadditionSie haben denselben Typ, daher ist die obige Operation zulässig.

Jetzt können Sie addition verwenden, um die zugewiesene Funktion aufzurufen:

import Cocoa

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")

Die Ausgabe der obigen Programmausführung ist:

输出结果: 129

Funktionstypen als Parametertypen, Funktionstypen als Rückgabetypen

Wir können eine Funktion als Parameter an eine andere Funktion übergeben:

import Cocoa

func sum(a: Int, b: Int) -> Int {
    return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
    print("输出结果: \(addition(a, b))")
}
another(addition: sum, a: 10, b: 20)

Die Ausgabe der obigen Programmausführung ist:

输出结果: 129
输出结果: 30

Verschachtelte Funktionen

Funktionsverschachtelung bezieht sich auf das Definieren einer neuen Funktion innerhalb einer Funktion; die äußere Funktion kann die darin definierte Funktion aufrufen.

Ein Beispiel ist wie folgt:

import Cocoa

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}
let decrem = calcDecrement(forDecrement: 30)
print(decrem())

Die Ausgabe der obigen Programmausführung ist:

-30
Andere Erweiterungen