{
//        闭包表达式(Closure Expression)
//        在Swift中，可以通过func定义一个函数，也可以通过闭包表达式定义一个函数
//        {
//            (参数列表) -> 返回值类型 in 函数体代码
//        }
//        func sum(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
        
        let fb = { (v1 : Int,v2 : Int) -> Int in
            return v1 + v2
        }
    
        fb(10, 20);
        
        {
            (v1: Int, v2: Int) -> Int in
            return v1 + v2
        }(10, 20)

//        闭包表达式的简写
        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: { $0 + $1 });
        
        exec(v1: 10, v2: 20, fn: {
            v1, v2 in return v1 + v2
        });
        
        exec(v1: 10, v2: 20, fn: +);
        
        exec(v1: 10, v2: 20, fn: {
            v1, v2 in v1 + v2
        });
        
        func ppf_class() {
//            尾随闭包
//            n 如果将一个很长的闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性 p尾随闭包是一个被书写在函数调用括号外面(后面)的闭包表达式
            func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
                print(fn(v1, v2))
            }
//            n 如果闭包表达式是函数的唯一实参，而且使用了尾随闭包的语法，那就不需要在函数名后边写圆括号
            exec(v1: 10, v2: 20) {
                $0 + $1
            }
            
            func exec(fn: (Int, Int) -> Int) {
                print(fn(1, 2))
            }
            exec(fn: { $0 + $1 })
            exec() { $0 + $1 }
            exec { $0 + $1 }
        }
        
        func ppf_class1() {
//            示例 – 数组的排序
//             func sort(by areInIncreasingOrder: (Element, Element) -> Bool)
              /// 返回true: i1排在i2前面
            /// 返回false: i1排在i2后面
            func cmp(i1: Int, i2: Int) -> Bool {
            // 大的排在前面
                return i1 > i2
            
            }
            var nums = [11, 2, 18, 6, 5, 68, 45]
           nums.sort(by: cmp)
           // [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 }
            // [2, 5, 6, 11, 18, 45, 68]
            
//            忽略参数
             func exec(fn: (Int, Int) -> Int) {
                print(fn(1, 2))
            }
            exec { _,_ in 10 } // 10

        }

        ppf_class1()

        func ppf_class2() {
//            闭包(Closure)
//            n 网上有各种关于闭包的定义，个人觉得比较严谨的定义是
//            一个函数和它所捕获的变量\常量环境组合起来，称为闭包 ü 一般指定义在函数内部的函数
//            一般它捕获的是外层函数的局部变量\常量
//            可以把闭包想象成是一个类的实例对象
//            内存在堆空间
//            捕获的局部变量\常量就是对象的成员(存储属性) p 组成闭包的函数就是类内部定义的方法
            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
            
//            n 思考:如果num是全局变量呢?
            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
            func getFn2() -> Fn {
                var num = 0
                return {num += $0
                    return num }
            }
            
            //            注意
            //            n 如果返回值是函数类型，那么参数的修饰要保持统一
             func add(_ num: Int) -> (inout Int) -> Void {
                func plus(v: inout Int) {
                    v += num
                    
                }
                return plus
             }
            var num = 5
            add(20)(&num)
            print(num)

        }

        ppf_class2()


        func ppf_class3() {
//            自动闭包
             // 如果第1个数大于0，返回第一个数。否则返回第2个数
            func getFirstPositive(_ v1: Int, _ v2: Int) -> Int {
                return v1 > 0 ? v1 : v2
            }
            getFirstPositive(10, 20) // 10
            getFirstPositive(-2, 20) // 20
            getFirstPositive(0, -4) // -4
            
             // 改成函数类型的参数，可以让v2延迟加载
            func getFirstPositive2(_ v1: Int, _ v2: () -> Int) -> Int? {
                return v1 > 0 ? v1 : v2()
            }
            
            getFirstPositive2(-4) { 20 }
            
            

            
            func getFirstPositive3(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int? {
                return v1 > 0 ? v1 : v2()
                
            }
            
            getFirstPositive3(-4, 20)
//            n @autoclosure 会自动将 20 封装成闭包 { 20 }
//            n @autoclosure 只支持 () -> T 格式的参数 @autoclosure 并非只支持最后1个参数
//            n 空合并运算符 ?? 使用了 @autoclosure 技术
//            n 有@autoclosure、无@autoclosure，构成了函数重载
            
//            n 为了避免与期望冲突，使用了@autoclosure的地方最好明确注释清楚:这个值会被推迟执行



        }

        ppf_class3()

    }