Swift 笔记（六）

我的主力博客：半亩方塘

Closures

---

1、Closures are functions without names. Here's a declaration for a varible that can hold a closure:

var mutiplyClosure: (Int, Int) -> Int  

You assign a closure to a variable like so:

multiplyClosure = { (a: Int, b: Int) -> Int in     return a * b}  

With your closure variable defined, you can use it just as if it were a function, like so:
let result = multiplyClosure(4, 2)

As you'd expect, result equals 8.
There are many ways to shorten their syntax:
multiplyClosure = { (a: Int, b: Int) -> Int in    a * b}  multiplyClosure = { (a: Int, b: Int) in    a * b}multiplyClosure = { (a, b) in      a * b}  multiplyClosure = {    $0 * $1}  

2、Consider the following code:
func operateOnNumbers(a: Int, _ b: Int, operation: (Int, Int) -> Int) -> Int {    let result = operation(a, b)    print(result)    return result}  
You can then use operateOnNumbers with a closure, like so:
let addClosure = { (a: Int, b: Int) -> Int in    a + b}operateOnNumbers(4, 2, operation: addClosure)  

You can define the closure inline with the operateOnNumbers function call, like this:
operateOnNumbers(4, 2, operation: { (a: Int, b: Int) -> Int in    return a + b})  

You can reduce the above to the following:
operateOnNumbers(4, 2, operation: {    $0 + $1})  
There's one more way you can simplify the syntax, but it can only be done when the closure is the final parameter passed to a function. In this case, you can move the closure outside of the function call:
operateOnNumbers(4, 2) {    $0 + $1}  
This is called trailing closure syntax.
3、The fact that closures can be used to capture variables from the enclosing scope can be extremely useful.
func countingClosure() -> (() -> Int) {    var counter = 0    let incrementCounter: () -> Int = {        return counter++    }    return incrementCounter}  
The closure returned from this function will increment its internal counter each time it is called. Each time you call this function you get a different counter.
For example, this could be used like so:
let counter1 = countingClosure()let counter2 = countingClosure()counter1()  // 0counter2()  // 0counter1()  // 1counter1()  // 2counter2()  // 1

The two counters created by the function are mutually exclusive and count independently. Neat!