Unterschied zwischen Funktion und Schließung Zuordnung

Question

Gibt es einen Unterschied in swift zwischen Funktionsdeklaration:

func function(a: String) { 
    print(a); 
} 
function("test"); 

und Schließung Zuordnung:

let closure = { 
    (a: String) in 
    print(a); 
} 
closure("test"); 

Gibt es einen Unterschied zwischen denen?

Answer 1

1. benannt oder anonym

   func function(a: String) { 
       print("\(a), name: \(__FUNCTION__)"); 
   } 
   
   let closure = { (a: String) in 
       print("\(a), name: \(__FUNCTION__)"); 
   } 
   

2. Capture-Liste
   nur in Schließungen unterstützt:

   let obj = FooClass() 
   let closure = { [weak obj] in ... } 
   

3. Curried Funktionnur in Funktionen unterstützt:

   func curriedFunc(x:Int)(y:Int) { ... } 
   let curried = curriedFunc(1) 
   curried(y:2) 
   

   ähnlich, aber nicht exakt das gleiche mit der Verwendung von Schließung:

   let closure = { (x:Int) in { (y:Int) in ... }} 
   

4. Generics
   nur in Funktionen unterstützt:

   func function<T>(x:T) { ... } 
   

5. Referenzierbarkeit aus der eigenen Erstmeldung
   nur in globalen Funktionen unterstützt:

   func recursive(var x:Int) -> Int { 
       ... 
       return condition ? x : recursive(x) 
   } 
   

   Sie können auch diesen mit Verschluss tun:

   var recursive:((Int) -> Int)! 
   recursive = { (var x) in 
       ... 
       return condition ? x : recursive(x) 
   } 
   

   Aber dies wird nicht empfohlen, da dies verursacht starke Referenz Fahrräder.

   func function(a: String) { print("String: \(a)") } 
   func function(a: Float) { print("Float: \(a)") } 
   

   N. B.:

6. Überlastung
   nur in Funktionen unterstütztSie können sie als Verschluss wie diese Referenz:

   let f:(Float) -> Void = function 
   

Answer 2

Ein weiterer Unterschied: Rekursivität in einer anderen Funktion

Verschachtelte Funktionen nicht rekursiv sein können:

func foo() { 
    func bar() { bar() } // does not compile 
} 

aber Schließungen innerhalb anderer Funktionen können rekursiv sein:

func foo() { 
    var bar: (() ->())! 
    bar = { bar() } 
}