Swift - Closures

方法是特殊的闭包

• 全局方法：一个有名字并且没有捕获任何值的闭包
• 嵌套方法：一个有名字并且能捕获从外部方法的值
• 闭包表达式：一个没有名字但是能捕获上下文

// parameters can inout，can't default
{ (parameters) -> return type in
   statements
}

对一个字符串数组进行排序

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
let reversedNames = names.sorted{ (s1: String, s2: String) -> Bool in 
    return s1 > s2
}
/************************* 使用形式 *************************/
// 正常形式
names.sorted(by:{s1, s2 in return s1 > s2})
// 隐藏 return 单表达闭包
names.sorted(by:{s1, s2 in s1 > s2})
// 速记参数名 如: $0 $1 $2 
// 使用速记参数名可以省略闭包参数和 in 关键字
names.sorted(by:{ $0 > $1 })
// 操作符方法
// Swift 的字符串类型定义一个 " > " 作为方法，该方法具有两个字符串类型的参数，并返回一个 Bool 类型的值
names.sorted(by: >)

尾随闭包

闭包表达式作为方法的最后一个参数

// 声明
func tailingClosures(closure: () -> Void) {
}
// 调用方式
// 1.
tailingClosures(closure:{
})
// 2.
tailingClosures() {
}
// 3.
tailingClosures {
  // 方法仅有一个参数且是一个尾随闭包，可以不写 "()"
}

捕获值

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
     var runningTotal = 0
     func increment() -> Int {
          runningTotal += amount
          return runningTotal
     }
     return incremeter
}

// Add Ten
let incrementByTen = makeIncrementer(forIncrement: 10)
// returns a value of 10
incrementByTen()
// returns a value of 20
incrementByTen()
// returns a value of 30
incrementByTen()

// Add Seven
let incrementBySeven = makeIncrementer(forIncrement: 7)
// returns a value of 7
incrementBySeven()

// incrementByTen 和 incrementBySeven 相互独立

闭包是一个引用类型

let alsoIncrementByTen = incrementByTen
// returns a value of 50
alsoIncrementByTen()

逃逸闭包

在方法 return 之后依然没有调用闭包，需要使用 @escaping

var completionHandlers: [() -> Void] = []

func escapingClosure(compltionHandler: @escaping() -> Void) {
     completionHandlers.apped(completionHandler)
}

// 非逃逸闭包
func noescapingClosure(closure: () -> Void) {
     closure()
}

// self 调用
class SomeClass {
      var x = 10
      func doSomeThing() {
           // escapingClosure 需要self
           escapingClosure { self.x = 100 }
           // 无 escaping 隐式调用 self
           noescapingClosure { x = 200 }
      }
}

// eg: 
let instance = SomeClass()
instance.doSomeThing() // 200
completionHandlers.first?() // 100

自动闭包

• 自动创建一个闭包表达式
• 不需要任何参数
• returns 闭包中表达式的值

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
let customerProvider = { customersInLine.remove(at:0) }
print("Now serving \(customerProvider())!")
// Print "Now serving Chris!"

如果声明了 autoclosure 可以直接传 String

func serve(customer customerProvider: @autoclosure() -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at:0))