Swift Language
Domknięcia

Składnia

• var closureVar: (<parameters>) -> (<returnType>) // Jako zmienna lub typ właściwości
• typealias ClosureType = (<parameters>) -> (<returnType>)
• {[<captureList>] (<parameters>) <throws-ness> -> <returnType> w <statements>} // Pełna składnia zamknięcia

Uwagi

Podstawy zamknięcia

Zamknięcia (znane również jako bloki lub lambda ) to fragmenty kodu, które można przechowywać i przekazywać w ramach programu.

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

sayHi()  // prints "Hello"

Podobnie jak inne funkcje, zamknięcia mogą akceptować argumenty i zwracać wyniki lub zgłaszać błędy :

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"

Zamknięcia mogą wychwytywać wartości ze swojego zakresu:

// 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

Zamknięcia można przekazać bezpośrednio do funkcji:

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()

Wariacje składniowe

Podstawowa składnia zamknięcia to

{ [ lista przechwytywania ] ( parametry ) rzuca-ness -> zwraca typ in treści } .

Wiele z tych części można pominąć, więc istnieje kilka równoważnych sposobów pisania prostych zamknięć:

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 }

• Listę przechwytywania można pominąć, jeśli jest pusta.
• Parametry nie wymagają adnotacji typu, jeśli można wywnioskować ich typy.
• Typ zwrotu nie musi być określony, jeśli można go wywnioskować.
• Parametry nie muszą być nazywane; zamiast tego można się do nich odwołać za pomocą $0 $1 $2 itp.
• Jeśli zamknięcie zawiera pojedyncze wyrażenie, którego wartość ma zostać zwrócona, słowo kluczowe return można pominąć.
• Jeśli wnioskowanie o zamknięciu ma na celu wygenerowanie błędu, jest zapisywane w kontekście, który oczekuje zamknięcia rzucania lub nie powoduje błędu, throws można pominąć.

// 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 }

Przekazywanie zamknięć do funkcji

Funkcje mogą przyjmować zamknięcia (lub inne funkcje) jako parametry:

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

Końcowa składnia zamknięcia

Jeśli ostatnim parametrem funkcji jest zamknięcie, nawiasy zamykające { / } mogą zostać zapisane po wywołaniu funkcji:

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")
}

Jeśli jedynym argumentem funkcji jest zamknięcie, możesz również pominąć parę nawiasów () podczas wywoływania jej za pomocą składni końcowego zamykania:

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

bar() { print("Hello") }

bar { print("Hello") }

Parametry @noescape

Parametry zamknięcia oznaczone jako @noescape są gwarantowane do wykonania przed powrotem wywołania funkcji, więc przy użyciu self. nie jest wymagane w korpusie zamknięcia:

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 }
    }
}

Uwaga 3:

Pamiętaj, że w Swift 3 nie oznaczasz już bloków jako @noescape. Bloki domyślnie nie uciekają. W Swift 3 zamiast oznaczać zamknięcie jako nieuchwytne, parametr funkcji, który jest zamknięciem uciekającym, oznacza ucieczkę za pomocą słowa kluczowego „@escaping”.

throws i rethrows

Zamknięcia, podobnie jak inne funkcje, mogą generować błędy :

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

Funkcja może oczywiście przekazać błąd do swojego obiektu wywołującego:

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

Jeśli jednak przekazany blok nie rzuca, osoba dzwoniąca nadal blokuje się funkcją rzucania:

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

Rozwiązaniem jest rethrows , co oznacza, że funkcja może rzucać tylko wtedy, gdy parametr zamknięcia wyrzuci :

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 }

Wiele standardowych funkcji bibliotecznych używa rethrows , w tym map() , filter() i indexOf() .

Przechwytuje, silne / słabe referencje i zachowuje cykle

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

Gdy zamknięcie przechwytuje typ odwołania (instancję klasy), domyślnie przechowuje silne odwołanie:

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"

Listy przechwytywania zamknięcia można użyć do określenia słabego lub nienależącego odniesienia:

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.

Aby uzyskać więcej informacji, zobacz temat Zarządzanie pamięcią oraz sekcję Automatyczne zliczanie odniesień w Swift Programming Language.

Zachowaj cykle

Jeśli obiekt przytrzymuje zamknięcie, które również silnie odnosi się do obiektu, jest to cykl zatrzymania . O ile cykl nie zostanie przerwany, pamięć przechowująca obiekt i zamknięcie zostanie wyciekła (nigdy nie odzyskana).

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)")
        }
    }
}

Używanie zamknięć do kodowania asynchronicznego

Zamknięcia są często używane do zadań asynchronicznych, na przykład podczas pobierania danych ze strony internetowej.

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()
}

Ta funkcja jest asynchroniczna, więc nie blokuje wątku, do którego jest wywoływana (nie zamraża interfejsu, jeśli zostanie wywołana w głównym wątku aplikacji 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")

Ponieważ zadanie jest asynchroniczne, dane wyjściowe zwykle wyglądają następująco:

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

Ponieważ kod wewnątrz zamknięcia, print("2. Fetched data") , nie zostanie wywołany, dopóki dane z adresu URL nie zostaną pobrane.

Zamknięcia i alias typu

Zamknięcie można zdefiniować za pomocą typealias . Zapewnia to symbol zastępczy wygodnego typu, jeśli ten sam podpis zamknięcia jest używany w wielu miejscach. Na przykład popularne wywołania zwrotne żądań sieciowych lub procedury obsługi zdarzeń interfejsu użytkownika są świetnymi kandydatami do nadania nazwy „aliasowi”.

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

Następnie możesz zdefiniować funkcję za pomocą typali:

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