闭包

Swift闭包(closures)有很多优化的地方

• 根据上下文推断参数和返回值类型
• 从单行表达式闭包中隐式返回（也就是闭包体只有一行代码，可以省略return）
• 可以使用简化参数名，如1(从0开始，表示第i个参数...)
• 提供了尾随闭包语法(Trailing closure syntax)

闭包完全体语法
{(s1: T, s2: T) -> Type in
    ///代码实现
    ...
    return type
}

• 代码简写

///自动闭包
let student1 = {
   print("省略参数和 in")
}

• 参数名称缩写

let sortBlock = { (s1: String, s2: String) -> Bool in
    ///完全体
    return s1 > s2
}
///$0、$1 表示第一个 第二个参数  缩写1
let sortBlock1 = { return $0 > $1 }

• 尾随闭包,闭包作为最后一个参数的时候，可以省略掉参数名

func lastColosure(colosure: ()->()){
    colosure()
}

调用1
lastColosure(colosure: {       
})

简写
lastColosure() {
}

当只有闭包一个参数的时候，括号也可以省略
lastColosure {
}

Swift 中 闭包作为参数和返回值
闭包作为参数的时候，是在函数实现内部调用这个闭包；闭包作为返回值，是在函数实现部分实现闭包。

作为参数
func getData(url: String, complete:(Data)->()){
    let data = NSData(contentsOfFile: url) as Data?
    /// 在此处调用 闭包
    complete(data)
}

/// 函数调用
getData(url: "") { data in
    /// 闭包实现
    print(data)
}

作为返回值  
方式一：内部函数作为返回值，因为函数的类型是  `(String) -> Int` 类型
func students(names: [String]) -> ((String) -> Int){
    func nameFunc(str: String) -> Int{
        return str.count
    }
    return nameFunc(str:)
}

方式二：
func students(names: [String]) -> ((String) -> Int){
    return { $0.count }
}

调用
let name = students(names: ["myk"])
let a = name("123")
`name` 是 `(String) -> Int`类型
`a` 是 `Int`类型

在学习RxSwift的时候，他的bind函数让我困惑好久

bind函数，有两个参数 A 和 B，参数A又是一个函数
参数A ：参数：信号   返回值：闭包
参数B：一个类型
func bind(to binder: (Observable<[Self]>) -> (R1) -> R2, curriedArgument: R1) -> R2

Rx给出的一个例子中

Observable.just([1,2,3])
    .bind(to: picker1.rx.itemTitles, curriedArgument: { name, item in
         return "\(item)"
    })
      .disposed(by: dispose)

picker1.rx.itemTitles中itemTitles是一个函数类型
func itemTitles(_ source: Source) -> (@escaping (Int, Sequence.Element) -> String?) -> Disposable
它的类型是
(_ source: Source) -> (@escaping (Int, Sequence.Element) -> String?) -> Disposable
和 bind 函数的参数A (Observable<[Int]>) -> (R1) -> R2 类型是一样的。
类比一下(@escaping (Int, Sequence.Element) -> String?) == R1，Disposable == R2。
bind函数的第二个参数curriedArgument也就是参数B, 传的是一个R1类型的数据，也就是 (@escaping (Int, Sequence.Element) -> String?)类型，因此参数B是一个闭包<也可以传一个函数>。