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()  // 0
counter2()  // 0
counter1()  // 1
counter1()  // 2
counter2()  // 1
The two counters created by the function are mutually exclusive and count independently. Neat!