Die Anleitung zu Swift Closure

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


// Declare the variable myVar1, with data types, and assign value.

var myVar1 : () -> () =  {
    
    print("Hello from Closure 1");
}

// Declare the variable myVar2, with data types, and assign value.

var myVar2 : () -> (String)  = { () -> (String) in

    return "Hello from Closure 2"

}

// Declare the variable myVar3, with data types, and assign value.

var myVar3 : (Int, Int) -> (Int)  =  { (a : Int, b: Int) -> (Int) in
    
    var c : Int =  a + b
    
    return c
}
    

func test_closure()     {
    
    // Execute Closure.
    myVar1()
    
    // Execute Closure, and get returns value.
    var str2 = myVar2()
    
    print(str2)
    
    // Execute closure, pass parameters
    // and get returns value.
    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

// Declaring a Closure in the usual way.

var myClosure : (String, String) -> String
    
    = { (firstName: String, lastName: String) -> String in
    
    
    return firstName + " " + lastName
}

// Declare a Closure in the anonymous way.
// (Ignore parameter names).

var anonymousClosure : (String, String) -> String
    
    = {
      // Using
      // $0: For first parameter
      // $1: For second 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()  {
    
    // Declare a variable type of Closure.
    var mySum : ( Int, Int ) -> (Int)
    
    // Assign a anonymous closure.
    // $0: For first parameter.
    // $1: For second 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

// This is a Closure that its content is only an expression.

var closureWithReturn  =  { (a: Int, b: Int) -> Int in
    
    // Only an expression.
    return a + b

}

// Can omit the 'return' keyword.

var closureWithoutReturn =  { (a: Int, b: Int) -> Int in
    
    // If only a single expression.
    // Omit 'return' keyword.
    a + b
    
}

5- Closure in einer Funktion

  • TODO