Die Anleitung zu Swift Closure

Was ist Closure?
Der Vergleich zwischen Function und Closure
Die Meldung des anonymen Closure
Die Rückgabewert implizieren
Closure in einer Funktion

1. Was ist Closure?

Closure: Closure ist ein besonderes Befehlblock. Es kann 0 oder mehr Parameter haben und das Rückgabetyp haben. Es ist so ziemlich gleich wie den Befehlblock in C oder Object-C. Es bedeutet ein schließendes Package

Es ist einfach, dass Sie können das folgende Meldung sehen und dann können Sie seine Bedeutung vermuten?

Die oben Meldungen können durch das folgende Beispiel erklärt werden

Das ist ein Syntax für die Variable-meldung der Daten und die Zuweis der Wert für die Variable, das an Sie gewöhnt

MyFirstClosure.swift

import Foundation

// Eine Variable myVar1 mit dem Datentyp erklären und die Wert für sie übertragen.
var myVar1 : () -> () =  { 
    print("Hello from Closure 1");
} 
// Eine Variable myVar2 mit dem Datentyp erklären und die Wert für sie übertragen.
var myVar2 : () -> (String)  = { () -> (String) in 
    return "Hello from Closure 2" 
} 
// Eine Variabel myVar3 mit dem Datentyp erklären und die Wert für sie übertragen.
var myVar3 : (Int, Int) -> (Int)  =  { (a : Int, b: Int) -> (Int) in 
    var c : Int =  a + b 
    return c
}  
func test_closure()     { 
    //  Closure implementieren.
    myVar1() 
    // Closure implementieren und die Rückgabewert bekommen.
    var str2 = myVar2() 
    print(str2) 
    // Die Closure implementieren und den Parameter übertragen 
    // und die Rückgabenwert bekommen
    var c: Int =  myVar3(11, 22) 
    print(c) 
}

Closure ist hauptsächlich der Befehlblock. Es kann den Parameter und Rückgabentyp haben

Die Syntax vom Closure:

{  (parameters) -> returntype in
     // statements
}

2. Der Vergleich zwischen Function und Closure

Function ist ein besonderer Fall vom Closure. Function ist ein Closure mit dem Name. Oder Closure ist ein anonyme Function

Die Definition

Die Benutzung

3. Die Meldung des anonymen Closure

Bei der Meldung vom Closure brauchen Sie den Name vom Parameter nicht schreiben. Der Parameter können durch $0, $1,...verweisen

AnonymousClosure.swift

import Foundation

// Eine Closure normal erklären.
var myClosure : (String, String) -> String 
    = { (firstName: String, lastName: String) -> String in  
        return firstName + " " + lastName
} 
// Eine Closure anonym erklären (anonymous).
// (den Name der Parameter ignorieren).
var anonymousClosure : (String, String) -> String 
    = {
        // benutzen:
        // $0: der erste Parameter
        // $1: der zweite Parameter
        return $0 + " " + $1
}

Beachten Sie: $0, $1,... sind die anonymen Parameter. Sie werden in dem anonymen Closure nur benutzt . Wenn Sie sie in den normalen Closure benutzen, bekommen Sie eine Fehleranmeldung
Anonymous closure arguments cannot be used inside a closure that has explicit arguments

Zum Beispiel über das anonyme Closure (2):

AnonymosClosure2.swift

import Foundation 

func test_anonymousClosure()  { 
    // Eine Variable von dem Typ Closure erklären.
    var mySum : ( Int, Int ) -> (Int)
    
    // Eine anonyme Closure für sie anweisen
    // $0: der erste Parameter
    // $1: der zweite Parameter
    mySum =  {
        return $0 + $1
    } 
    var value = mySum(1, 2) 
    print(value) 
}

4. Die Rückgabewert implizieren

Wenn es in der Inhalt vom Closure eine Ausdruck gibt, können Sie das Schlusselwort return.ignorieren

ImplicitReturnValues.swift

import Foundation

// Das ist eine Closure, deren Inhalt nur eine einzige Ausdruck hat
var closureWithReturn  =  { (a: Int, b: Int) -> Int in 
    // Eine einzige Ausdruck (expression) .
    return a + b 
} 
// Den Schlüsselwort 'return' ignorieren.
var closureWithoutReturn =  { (a: Int, b: Int) -> Int in 
    // Wenn eine Ausdruck (expression) einzige ist, 
    // den Schlüsselswort 'return' ignorieren können.
    a + b 
}

5. Closure in einer Funktion

TODO