我的主力博客：半亩方塘

Closures

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

var mutiplyClosure: (Int,Int) -> Int  

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,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
  
  
  with a closure,like so:
 
 
 
 

  
  
  
  
let addClosure = { (a: Int,b: Int) -> Int in
    a + b
}
operateOnNumbers(4,2,operation: addClosure)  
  
  

  
  
You candefine the closure inlinewith thefunction call,like this:
  
  

  
  
operateOnNumbers(4,operation: { (a: Int,b: Int) -> Int in
    return a + b
})  
  
  

  
  You can reduce the above to the following:
  
  

  
  
  
  

  
  
operateOnNumbers(4,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 calledtrailing 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!
  
  
  
  
  
 
 
resultoperateOnNumbersoperateOnNumbers