Die Anleitung zu Swift Closure

View more categories:

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

View more categories: