08-闭包

//闭包1-9
/*1.闭包表达式
在swift中可以通过func定义一个函数，也可以通过闭包表达式定义一个函数
 {
        (参数列表) -> 返回值类型 in 函数体代码
 }
 */
func sum(_ v1: Int, _ v2: Int) -> Int {v1 + v2}
var fn = { //闭包定义函数
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
}
fn(10, 20)

//2.闭包表达式的简写
func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
    print(fn(v1, v2))
}
exec(v1: 10, v2: 20, fn: {
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
})
exec(v1: 10, v2: 20, fn: {
    v1, v2 in return v1 + v2
})
exec(v1: 10, v2: 20, fn: {
    v1, v2 in v1 + v2
})
exec(v1: 10, v2: 20, fn: {$0 + $1})
exec(v1: 10, v2: 20, fn: +)

//3.尾随闭包:是一个被书写在函数调用括号外面（后面）的闭包表达式
//如果讲一个很长的闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性

//func execa(v1: Int, v2: Int, fns: (Int, Int) -> Int) {
//    print(fn(v1 + v2))
//}
//execa(v1: 10, v2: 20) {
//    $0 + $1
//}

func exe(fn: (Int, Int) -> Int) {
    print(fn(1, 2))
}
exe(fn: {$0 + $1})
exe() {$0 + $1}//尾随闭包
exe {$0 + $1} //闭包表达式是函数的唯一实参 + 用了尾随闭包 -> 就可以省略函数名后的括号

//4.示例 - 数组的排序
//返回true: i1排在i2前面
//返回false:i2排在i1前面
func cmp(i1: Int, i2: Int) -> Bool {
    return i1 > i2
}
var nums = [11, 2, 18, 6, 5, 68, 45]
nums.sort(by: cmp)
print(nums) //[68, 45, 18, 11, 6, 5, 2]

nums.sort(by: {
    (i1: Int, i2: Int) -> Bool in
    return i1 < i2
})
nums.sort(by: {i1, i2 in return i1 < i2})
nums.sort(by: {i1, i2 in i1 < i2})
nums.sort(by: {$0 < $1})
nums.sort(by: <)
nums.sort() {$0 < $1}
nums.sort {$0 < $1}

//5.忽略参数
func exec1(fn: (Int, Int) -> Int) {
    print(fn(1, 2))
}
exec1 {
    v1, v2 in 10
}
//等价
//exec1 {_,_ in 10} //忽略参数
exec1 {$0 + $1}

//6.闭包
//闭包：一个函数和它所捕获的变量/常量环境组合起来，一般指定义在函数内部的函数，一般它捕获的外层函数的局部变量/常量
typealias Fn = (Int) -> Int
func getFn() -> Fn {
    var num = 0
    func plus(_ i: Int) -> Int {
        num += i
        return num
    }
    return plus
}//返回的plus和num形成了闭包
var fn1 = getFn()
var fn2 = getFn()
fn1(1)//1
fn2(2)//2
fn1(3)//4
fn2(4)//6
fn1(5)//9
fn2(6)//12
//可以把闭包想象成是一个类的实例对象，内存在堆空间，捕获的局部变量/常量就是对象的成员(存储属性),组成闭包的函数就是类内部定义的方法
class Closure {
    var num = 0
    func plus(_ i: Int) -> Int {
        num += i
        return num
    }
}
var cs1 = Closure()
var cs2 = Closure()
cs1.plus(1)//1
cs2.plus(2)//2
cs1.plus(3)//4
cs2.plus(4)//6
cs1.plus(5)//9
cs2.plus(6)//12

//7.练习
typealias Fnn = (Int) -> (Int, Int)
func getFns() -> (Fnn, Fnn) {
    var num1 = 0
    var num2 = 0
    func plus(_ i: Int) -> (Int, Int) {
        num1 += i
        num2 += i << 1
        return (num1, num2)
    }
    func minus(_ i: Int) -> (Int, Int) {
        num1 -= i
        num2 -= i << 1
        return (num1, num2)
    }
    return (plus, minus)
}
let (p, m) = getFns()
p(5)//(5, 10)
m(4)//(1, 2)
p(3)//(4, 8)
m(2)//(2, 4)

class Closure0 {
    var num1 = 0
    var num2 = 0
    func plus(_ i: Int) -> (Int, Int) {
        num1 += i
        num2 += i << 1
        return (num1, num2)
    }
    func minus(_ i: Int) -> (Int, Int) {
        num1 -= i
        num2 -= i << 1
        return (num1, num2)
    }
}
var cs = Closure0()
cs.plus(5) //(5, 10)
cs.minus(4)//(1, 2)
cs.plus(3)//(4, 8)
cs.minus(2)//(2, 4)

var functions: [() -> Int] = []
for i in 1...3 {
    functions.append{i}
    //等价于
//    func myFunc() -> Int {
//        return i
//    }
//    functions.append(myFunc)
}
for f in functions {
//    print(f()) //1 //2 //3
}

//8.注意,如果返回值是函数类型，那么参数的修饰要保持统一
func add(_ num: Int) -> (inout Int) -> Void {
    func plus(v: inout Int) {
        v += num
    }
    return plus
}
var num = 5
add(20)(&num)
print(num)


/*
 9.自动闭包
 @autoclosure 会自动将20封装成背闭包{20}
 @autoclosure只支持() -> T 格式的参数
 @autoclosure并非只支持最后1个参数
 空合运算符??使用了@autoclosure技术
 有 @autoclosure、无 @autoclosure构成了函数重载
 */
//func getFirstPositive(_ v1: Int, _ v2: Int) -> Int {
//    return v1 > 0 ? v1 : v2
//}
//getFirstPositive(10, 20)
//getFirstPositive(-2, 20)
//getFirstPositive(0, -4)
//改成函数类型的参数,可以让v2延迟加载
func getFirstPositive(_ v1: Int, _ v2: () -> Int) -> Int? {
    return v1 > 0 ? v1 : v2()
}
getFirstPositive(-4) {20}
//等价
func getFirstPositive(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int? {
    return v1 > 0 ? v1 : v2()
}
getFirstPositive(-4, 20)