Differenza tra funzione e la chiusura assegnazione

Question

C'è qualche differenza in rapida tra dichiarazione di funzione:

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

e la chiusura incarico?

Answer 1

1. anonimo o

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

2. Lista Capture
   supportate solo le chiusure:

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

3. funzione curry
   supportate solo funzioni:

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

   simili, ma non è esatto lo stesso con l'utilizzo di chiusura:

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

4. Generics
   supportate solo funzioni:

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

5. referenceability dalla propria dichiarazione iniziale
   supportate solo in funzioni globali:

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

   si può fare questo con la chiusura anche:

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

   Ma questo non è raccomandato perché questo fa sì riferimento forte cicli.

6. sovraccarico
   supportate solo funzioni:

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

   N.B.È possibile fare riferimento come chiusura come questo:

   let f:(Float) -> Void = function 
   

Answer 2

Un'altra differenza: ricorsività all'interno di un'altra funzione

funzioni nidificate non possono essere ricorsive:

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

ma chiusure dentro altra le funzioni possono essere ricorsive:

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