fermeture Swift

Fermetures (fermetures) est un bloc fonctionnel autonome de code, vous pouvez utiliser ou être utilisé comme une valeur de paramètre dans le code.

fermetures Swift en C et des blocs de code Objective-C (blocs) et quelques autres langages de programmation fonction anonyme est tout à fait similaire.

Les fonctions globales et fonctions imbriquées est en fait une fermeture spéciale.

Clôture de la forme:

fermetures Swift ont beaucoup de lieux d'optimisation:

1. Selon le type de paramètre contexte inférer et de la valeur de retour
2. De une seule ligne de fermeture d'expression rendement implicite (qui est, le corps de fermeture est une seule ligne de code, vous pouvez omettre le retour)
3. Il peut être utilisé pour simplifier le nom du paramètre, comme $ 0, $ 1 (de 0, ce qui indique que l'argument i-ème ...)
4. Fournir la syntaxe de fermeture arrière (Trailing fermeture syntaxe)

grammaire

Ce qui suit est un paramètre de réception et renvoie le type spécifié de la syntaxe de fermeture:

{(parameters) -> return type in
   statements
}

Exemples

import Cocoa

let studname = { print("Swift 闭包实例。") }
studname()

La sortie de l'exécution du programme ci-dessus est la suivante:

Swift 闭包实例。

La forme de la fermeture suivante prend deux paramètres et renvoie une valeur booléenne:

{(Int, Int) -> Bool in
   Statement1
   Statement 2
    ---
   Statement n
}

Exemples

import Cocoa

let divide = {(val1: Int, val2: Int) -> Int in 
   return val1 / val2 
}
let result = divide(200, 20)
print (result)

La sortie de l'exécution du programme ci-dessus est la suivante:

10

---

fermetures d'expression

expression Closures est un moyen de construire l'utilisation de simples fermetures syntaxe inline. syntaxe d'expression Closures fournit une certaine optimisation afin que composent la fermeture devient simple et claire.

---

fonction de tri

bibliothèque standard Swift fournit une fonction nommée sorte, elle sera triée en fonction de la fonction de fermeture que vous fournissez sera utilisée pour trier les valeurs de type connu dans le tableau.

Après l'achèvement de la sorte, le tri (_ :) méthode renvoie un tableau de la même taille que l'original, le nouveau tableau contient le même type d'élément et l'élément a été correctement triés, le tableau original ne sort (_ :) méthodes modifiées.

sort (_ :) méthode prend deux arguments:

• Un tableau de type connu
• Fonction fermeture, cette fonction de fermeture doivent passer une série d'éléments avec le même type de deux valeurs et renvoie une valeur booléenne pour indiquer que le premier paramètre après la fin de la ligne entrante de tri devant ou derrière le second paramètre. Si les premières valeurs de paramètre apparaissent en face des deuxièmes valeurs de paramètre, régler la fonction de fermeture doit retourner true , contrairement à revenir false .

Exemples

import Cocoa

let names = ["AT", "AE", "D", "S", "BE"]

// 使用普通函数(或内嵌函数)提供排序功能,闭包函数类型需为(String, String) -> Bool。
func backwards(s1: String, s2: String) -> Bool {
    return s1 > s2
}
var reversed = names.sort(backwards)

print(reversed)

La sortie de l'exécution du programme ci-dessus est la suivante:

["S", "D", "BE", "AT", "AE"]

Si la première chaîne de caractères (s1) est supérieure à la deuxième chaîne (s2), en arrière fonction renvoie true, indiquant que le nouveau tableau doit comparaître devant s1 s2. Pour les caractères de la chaîne, le "plus grand que" signifie "apparaissent plus tard dans l'ordre alphabétique." Cela signifie que la lettre "B" est supérieure à la lettre "A", la chaîne «S» est plus grande que la chaîne «D». Il renversera tri alphabétique, "AT" sera triée avant "AE".

---

Nom du paramètre abréviation

Swift fournit automatiquement un nom de paramètre fonction inline abréviation, vous pouvez directement à travers les $ 0 paramètres de fermeture de 1 $, 2 $ pour appeler l'ordre.

Exemples

import Cocoa

let names = ["AT", "AE", "D", "S", "BE"]

var reversed = names.sort( { $0 > $1 } )
print(reversed)

0 $ et 1 $ pour la fermeture de la première et le deuxième paramètre de type String.

La sortie de l'exécution du programme ci-dessus est la suivante:

["S", "D", "BE", "AT", "AE"]

Si vous utilisez le nom du paramètre abréviation de l'expression de fermeture, vous pouvez la fermeture liste des paramètres de sa définition est omis, et les types de l'acronyme nom de paramètre correspondant sera déduit par type de fonction. en mots-clés, il peut également être omis.

---

fonction de l'opérateur

En fait, il y a un chemin plus court pour écrire l'exemple des fermetures d'expression ci-dessus.

Swift String type définit le signe supérieur ( > string) la mise en œuvre, comme une fonction qui prend deux String paramètre de type et retourne un Bool type de valeur. Cela a coïncidé avec le sort(_:) fonction de type du deuxième paramètre de la méthode doit être conforme. Par conséquent, vous pouvez tout simplement passer un signe supérieur à, Swift peut automatiquement déduire que vous souhaitez utiliser est supérieur au nombre de fonctions de chaîne pour atteindre:

import Cocoa

let names = ["AT", "AE", "D", "S", "BE"]

var reversed = names.sort(>)
print(reversed)

La sortie de l'exécution du programme ci-dessus est la suivante:

["S", "D", "BE", "AT", "AE"]

---

Trailing fermetures

Trailing fermeture est une fonction écrite entre parenthèses après la fermeture des expressions, des fonctions pour appuyer son appel comme le dernier paramètre.

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // 函数体部分
}

// 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure({
    // 闭包主体部分
})

// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() {
  // 闭包主体部分
}

Exemples

import Cocoa

let names = ["AT", "AE", "D", "S", "BE"]

//尾随闭包
var reversed = names.sort() { $0 > $1 }
print(reversed)

sort () après {$ 0> $ 1} fermeture arrière.

La sortie de l'exécution du programme ci-dessus est la suivante:

["S", "D", "BE", "AT", "AE"]

Remarque: Si la fonction d' un seul paramètre de fermetures d'expression, lorsque vous utilisez les fermetures de fuite, vous pouvez même mettre () omis.

reversed = names.sort { $0 > $1 }

---

valeur capturée

Fermetures peuvent être capture constante ou variable dans le cadre de sa définition.

Même la définition de ces constantes et les variables du domaine d'origine n'existe pas, la fermeture peut encore fonctionner in vivo fermeture référencement et la modification de ces valeurs.

Swift forme la plus simple de fermeture est fonction imbriquée, la fonction est définie dans le corps des autres fonctions de la fonction.

La fonction imbriquée peut capturer tous ses paramètres de fonctions externes et des constantes et des variables définies.

Regardez cet exemple:

func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}

Une fonction makeIncrementor, il a un paramètre de type Int amout, et il a un nom de paramètre forIncremet externe, signifie que lorsque vous appelez, vous devez utiliser le nom externe. La valeur de retour est un ()-> Int fonction.

Dans la fonction de titre, déclarer une variable et une incrémentation fonction RunningTotal.

fonction incrémentation ne reçoit pas d'arguments, mais dans le corps de la fonction pour accéder aux variables RunningTotal et le montant. En effet, il contient le corps de la fonction en captant sa RunningTotal existante et quantité variable réalisée.

Comme il n'y a pas de variable de quantité de modification, incrémentation fait capturer et stocker une copie de la variable, qui est stocké avec une copie comme incrémentation.

Ainsi, lorsque nous appelons cette fonction s'accumuler:

import Cocoa

func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}

let incrementByTen = makeIncrementor(forIncrement: 10)

// 返回的值为10
print(incrementByTen())

// 返回的值为20
print(incrementByTen())

// 返回的值为30
print(incrementByTen())

La sortie de l'exécution du programme ci-dessus est la suivante:

10
20
30

---

Les fermetures sont types de référence

L'exemple ci-dessus, incrementByTen est constant, mais le point de fermeture de ces constantes peut encore augmenter la valeur de sa capture variable.

En effet, les fonctions et les fermetures sont des types de référence.

Que vous soyez une fonction / fermeture affectée à une constante ou variable, vous définissez en réalité la valeur de la variable références fonction / de fermeture constants / correspondants. L'exemple ci-dessus, incrementByTen Fermetures point de référence est une constante, plutôt que le contenu de la fermeture elle-même.

Cela signifie également que si vous affectez la fermeture des deux constantes / variables différentes, les deux valeurs seront pointer vers la même fermeture:

import Cocoa

func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}

let incrementByTen = makeIncrementor(forIncrement: 10)

// 返回的值为10
incrementByTen()

// 返回的值为20
incrementByTen()

// 返回的值为30
incrementByTen()

// 返回的值为40
incrementByTen()

let alsoIncrementByTen = incrementByTen

// 返回的值也为50
print(alsoIncrementByTen())

La sortie de l'exécution du programme ci-dessus est la suivante:

50

Précédent: fonction Swift
Suivant: énumération Swift