Swift Language
chiusure

Sintassi

• var closureVar: (<parametri>) -> (<returnType>) // Come variabile o tipo di proprietà
• typealias ClosureType = (<parametri>) -> (<returnType>)
• {[<captureList>] (<parametri>) <throws-ness> -> <returnType> in <istruzioni>} // Completa sintassi di chiusura

Osservazioni

Nozioni di base sulla chiusura

Le chiusure (note anche come blocchi o lambda ) sono pezzi di codice che possono essere memorizzati e passati all'interno del programma.

let sayHi = { print("Hello") }
// The type of sayHi is "() -> ()", aka "() -> Void"

sayHi()  // prints "Hello"

Come altre funzioni, le chiusure possono accettare argomenti e restituire risultati o generare errori :

let addInts = { (x: Int, y: Int) -> Int in
    return x + y
}
// The type of addInts is "(Int, Int) -> Int"

let result = addInts(1, 2)  // result is 3

let divideInts = { (x: Int, y: Int) throws -> Int in
    if y == 0 {
        throw MyErrors.DivisionByZero
    }
    return x / y
}
// The type of divideInts is "(Int, Int) throws -> Int"

Le chiusure possono acquisire valori dal loro ambito:

// This function returns another function which returns an integer
func makeProducer(x: Int) -> (() -> Int) {
    let closure = { x }  // x is captured by the closure
    return closure
}

// These two function calls use the exact same code,
// but each closure has captured different values.
let three = makeProducer(3)
let four = makeProducer(4)
three()  // returns 3
four()  // returns 4

Le chiusure possono essere trasferite direttamente nelle funzioni:

let squares = (1...10).map({ $0 * $0 })  // returns [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
let squares = (1...10).map { $0 * $0 }

NSURLSession.sharedSession().dataTaskWithURL(myURL,
    completionHandler: { (data: NSData?, response: NSURLResponse?, error: NSError?) in
        if let data = data {
            print("Request succeeded, data: \(data)")
        } else {
            print("Request failed: \(error)")
        }
    }).resume()

Variazioni di sintassi

La sintassi di chiusura di base è

{ [ capture list ] ( parametri ) throws-ness -> restituisce type in body } .

Molte di queste parti possono essere omesse, quindi ci sono diversi modi equivalenti per scrivere semplici chiusure:

let addOne = { [] (x: Int) -> Int in return x + 1 }
let addOne = { [] (x: Int) -> Int in x + 1 }
let addOne = { (x: Int) -> Int in x + 1 }
let addOne = { x -> Int in x + 1 }
let addOne = { x in x + 1 }
let addOne = { $0 + 1 }

let addOneOrThrow = { [] (x: Int) throws -> Int in return x + 1 }
let addOneOrThrow = { [] (x: Int) throws -> Int in x + 1 }
let addOneOrThrow = { (x: Int) throws -> Int in x + 1 }
let addOneOrThrow = { x throws -> Int in x + 1 }
let addOneOrThrow = { x throws in x + 1 }

• La lista di cattura può essere omessa se è vuota.
• I parametri non hanno bisogno di annotazioni di tipo se i loro tipi possono essere dedotti.
• Il tipo di reso non ha bisogno di essere specificato se può essere dedotto.
• I parametri non devono essere nominati; invece possono essere indicati con $0 , $1 , $2 , ecc.
• Se la chiusura contiene una singola espressione, il cui valore deve essere restituito, la parola chiave return può essere omessa.
• Se la chiusura è dedotta per lanciare un errore, è scritta in un contesto che si aspetta una chiusura di lancio, o non lancia un errore, i throws possono essere omessi.

// The closure's type is unknown, so we have to specify the type of x and y.
// The output type is inferred to be Int, because the + operator for Ints returns Int.
let addInts = { (x: Int, y: Int) in x + y }

// The closure's type is specified, so we can omit the parameters' type annotations.
let addInts: (Int, Int) -> Int = { x, y in x + y }
let addInts: (Int, Int) -> Int = { $0 + $1 }

Passando le chiusure in funzioni

Le funzioni possono accettare chiusure (o altre funzioni) come parametri:

func foo(value: Double, block: () -> Void) { ... }
func foo(value: Double, block: Int -> Int) { ... }
func foo(value: Double, block: (Int, Int) -> String) { ... }

Sintassi di chiusura finale

Se l'ultimo parametro di una funzione è una chiusura, le parentesi di chiusura { / } possono essere scritte dopo il richiamo della funzione:

foo(3.5, block: { print("Hello") })

foo(3.5) { print("Hello") }

dispatch_async(dispatch_get_main_queue(), {
    print("Hello from the main queue")
})

dispatch_async(dispatch_get_main_queue()) {
    print("Hello from the main queue")
}

Se l'argomento di una funzione è solo una chiusura, puoi anche omettere la coppia di parentesi () quando la si chiama con la sintassi della chiusura finale:

func bar(block: () -> Void) { ... }

bar() { print("Hello") }

bar { print("Hello") }

Parametri @noescape

I parametri di chiusura contrassegnati con @noescape sono garantiti per l'esecuzione prima che la chiamata della funzione ritorni, quindi utilizzando self. non è richiesto all'interno del corpo di chiusura:

func executeNow(@noescape block: () -> Void) {
    // Since `block` is @noescape, it's illegal to store it to an external variable.
    // We can only call it right here.
    block()
}

func executeLater(block: () -> Void) {
    dispatch_async(dispatch_get_main_queue()) {
        // Some time in the future...
        block()
    }
}

class MyClass {
    var x = 0
    func showExamples() {
        // error: reference to property 'x' in closure requires explicit 'self.' to make capture semantics explicit
        executeLater { x = 1 }

        executeLater { self.x = 2 }  // ok, the closure explicitly captures self

        // Here "self." is not required, because executeNow() takes a @noescape block.
        executeNow { x = 3 }

        // Again, self. is not required, because map() uses @noescape.
        [1, 2, 3].map { $0 + x }
    }
}

Swift 3 note:

Nota che in Swift 3 non contrassegni più blocchi come @noescape. I blocchi ora non escaping per impostazione predefinita. In Swift 3, invece di contrassegnare una chiusura come non-escape, contrassegni un parametro di funzione che è una chiusura di escape come escaping usando la parola chiave "@escaping".

throws e rethrows

Le chiusure, come altre funzioni, possono generare errori :

func executeNowOrIgnoreError(block: () throws -> Void) {
    do {
        try block()
    } catch {
        print("error: \(error)")
    }
}

La funzione può, naturalmente, passare l'errore al suo chiamante:

func executeNowOrThrow(block: () throws -> Void) throws {
    try block()
}

Tuttavia, se il blocco inoltrato non viene lanciato, il chiamante è ancora bloccato con una funzione di lancio:

// It's annoying that this requires "try", because "print()" can't throw!
try executeNowOrThrow { print("Just printing, no errors here!") }

La soluzione è rethrows , che designa che la funzione può lanciare solo se il suo parametro di chiusura genera :

func executeNowOrRethrow(block: () throws -> Void) rethrows {
    try block()
}

// "try" is not required here, because the block can't throw an error.
executeNowOrRethrow { print("No errors are thrown from this closure") }

// This block can throw an error, so "try" is required.
try executeNowOrRethrow { throw MyError.Example }

Molte funzioni di libreria standard utilizzano i rethrows , inclusi map() , filter() e indexOf() .

Cattura, riferimenti forti / deboli e conserva i cicli

class MyClass {
    func sayHi() { print("Hello") }
    deinit { print("Goodbye") }
}

Quando una chiusura acquisisce un tipo di riferimento (un'istanza di classe), mantiene un riferimento forte per impostazione predefinita:

let closure: () -> Void
do {
    let obj = MyClass()
    // Captures a strong reference to `obj`: the object will be kept alive
    // as long as the closure itself is alive.
    closure = { obj.sayHi() }
    closure()  // The object is still alive; prints "Hello"
} // obj goes out of scope
closure()  // The object is still alive; prints "Hello"

L' elenco di cattura della chiusura può essere utilizzato per specificare un riferimento debole o non associato:

let closure: () -> Void
do {
    let obj = MyClass()
    // Captures a weak reference to `obj`: the closure will not keep the object alive;
    // the object becomes optional inside the closure.
    closure = { [weak obj] in obj?.sayHi() }
    closure()  // The object is still alive; prints "Hello"
} // obj goes out of scope and is deallocated; prints "Goodbye"
closure()  // `obj` is nil from inside the closure; this does not print anything.

let closure: () -> Void
do {
    let obj = MyClass()
    // Captures an unowned reference to `obj`: the closure will not keep the object alive;
    // the object is always assumed to be accessible while the closure is alive.
    closure = { [unowned obj] in obj.sayHi() }
    closure()  // The object is still alive; prints "Hello"
} // obj goes out of scope and is deallocated; prints "Goodbye"
closure()  // crash! obj is being accessed after it's deallocated.

Per ulteriori informazioni, consultare l'argomento Gestione della memoria e la sezione Conteggio riferimento automatico di Swift Programming Language.

Conservare i cicli

Se un oggetto tiene su una chiusura, che contiene anche un forte riferimento all'oggetto, questo è un ciclo di conservazione . A meno che il ciclo non sia interrotto, la memoria che memorizza l'oggetto e la chiusura sarà trapelata (mai bonificata).

class Game {
    var score = 0
    let controller: GCController
    init(controller: GCController) {
        self.controller = controller

        // BAD: the block captures self strongly, but self holds the controller
        // (and thus the block) strongly, which is a cycle.
        self.controller.controllerPausedHandler = {
            let curScore = self.score
            print("Pause button pressed; current score: \(curScore)")
        }

        // SOLUTION: use `weak self` to break the cycle.
        self.controller.controllerPausedHandler = { [weak self] in
            guard let strongSelf = self else { return }
            let curScore = strongSelf.score
            print("Pause button pressed; current score: \(curScore)")
        }
    }
}

Utilizzo di chiusure per la codifica asincrona

Le chiusure sono spesso utilizzate per attività asincrone, ad esempio quando si prelevano dati da un sito Web.

func getData(urlString: String, callback: (result: NSData?) -> Void) {

    // Turn the URL string into an NSURLRequest.
    guard let url = NSURL(string: urlString) else { return }
    let request = NSURLRequest(URL: url)
    
    // Asynchronously fetch data from the given URL.
    let task = NSURLSession.sharedSession().dataTaskWithRequest(request) {(data: NSData?, response: NSURLResponse?, error: NSError?) in

        // We now have the NSData response from the website.
        // We can get it "out" of the function by using the callback 
        // that was passed to this function as a parameter.

        callback(result: data)
    }
        
    task.resume()
}

Questa funzione è asincrona, quindi non bloccherà il thread su cui viene chiamato (non bloccherà l'interfaccia se chiamato sul thread principale dell'applicazione GUI).

print("1. Going to call getData")

getData("http://www.example.com") {(result: NSData?) -> Void in

    // Called when the data from http://www.example.com has been fetched.
    print("2. Fetched data")
}

print("3. Called getData")

Poiché l'attività è asincrona, l'output sarà in genere simile a questo:

"1. Going to call getData"
"3. Called getData"
"2. Fetched data"

Poiché il codice all'interno della chiusura, print("2. Fetched data") , non verrà chiamato fino a quando non verranno recuperati i dati dall'URL.

Chiusure e tipo alias

Una chiusura può essere definita con un typealias . Questo fornisce un comodo segnaposto di tipo se la stessa firma di chiusura viene utilizzata in più punti. Ad esempio, callback di richieste di rete comuni o gestori di eventi dell'interfaccia utente offrono ottimi candidati per essere "denominati" con un alias di tipo.

public typealias ClosureType = (x: Int, y: Int) -> Int

È quindi possibile definire una funzione utilizzando le tipealie:

public func closureFunction(closure: ClosureType) {
    let z = closure(1, 2)
}
    
closureFunction() { (x: Int, y: Int) -> Int in return x + y }