Swift基础（八）函数和闭包

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
        // 使用函数类型，在Swift中，可以像其他类型那样使用函数类型。例如，可以定义一个常量或变量为一个函数类型，并制定适当的函数给该变量
        var newFunc: (Int, Int) -> Int = additive;
        // 现在你可以调用制定的函数名newFunc：
        print("Result: \(newFunc(2, 3))");
        // 具有相同的匹配类型的不同函数可以分配相同的变量，也同样适用于非函数类型，可以给newFunc函数重新赋值为multiplication函数类型
        newFunc = mutiplication; // newFunc重新赋值为multiplication方法
        print("Result: \(newFunc(3, 4))");
        // prints “Result： 12”
        // 与其他类型一样，可以赋值一个函数变量或常量，Swift自动推测其函数类型。
        let anotherFunc = additive;
        // anotherFunc推测的类型是(Int, Int) -> Int
        
        // 函数类型参数的调用
        printAdditiveResult(additive, a: 4, b: 6);
        
        
        //函数类型的返回值调用
        let aFun = chooseFunction(3 > 2);
        print(aFun(3)); // 输出 2
        
        
        // 嵌套函数的调用
//        internalFunction(1); // 编译失败，因为internalFunction是mainFunction的内部函数，这里找不到函数
        
        
        
        // 调用闭包
        let arr = GetList([1, 2, 3, 4], pre: {(s: Int) in return s > 2});
        print(arr);
        // 运行结果 [3, 4]
        
        /*
         3 种闭包简写方法
         1. 省略 参数类型和括号
         var Arr = GetList([1, 2, 3, 4], pre: {s in return s > 2});
         2. 省略 参数类型和括号，return关键字
         Arr = GetList([1, 2, 3, 4], pre: (s in s > 2));
         3. 参数名称缩写
         Arr = GetList([1, 2, 3, 4], pre: {$0 > 2}) // 其中$0 表示第一个参数
         */
        
        
        
        
    }
    
    // 函数类型，每一个函数都有特定的函数类型，可以充当参数类型和函数的返回类型
    func additive(a: Int, b: Int) -> Int {
        return a + b;
    }
    func mutiplication(a: Int, b: Int) -> Int {
        return a * b;
    }
    // 这个函数的类型是(Int, Int) -> Int。可以解读为：“这个函数类型有两个int形的参数，并返回一个int类型的值”
    // 下面再举一个不带任何参数或返回值的函数
    func printWelcome() {
        print("Welcome Swift Class");
    }
    
    // 函数类型的参数就，函数名后面括号里定义的就是函数类的参数，可以使用一个函数类型作为参数，如(Int, Int) -> Int,
    func printAdditiveResult(addFun: (Int, Int) -> Int, a: Int, b: Int) {
        print("Result: \(addFun(a, b))");
    }
    
    // 函数类型的返回值，可以使用一个函数作为另一个函数的返回值类型
    // 定义一个自增函数，传入Int类型参数，返回Int类型
    func increase(input: Int) -> Int {
        return input + 1;
    }
    
    // 定义一个自减函数，传入Int类型参数，返回Int类型
    func reduce(input: Int) -> Int {
        return input - 1;
    }
    
    // 定义一个返回函数类型的函数
    // 传参Bool型，返回一个函数，该函数类型是(Int) -> Int,也就是传Int返回Int的函数
    func chooseFunction(backwards: Bool) -> (
        Int -> Int) {
            return backwards ? reduce : increase;
    }
    
    // 嵌套函数，在函数内部定义的函数，嵌套函数默认对外界是隐藏的，但是仍然可以调用和使用其内部函数。内部函数也可以返回一个嵌套函数，允许在嵌套函数内的另一个范围内使用。
    func mainFunction(input: Int) -> Int {
        func internalFunction(input: Int) -> Int {
            return input - 1;
        }
        return internalFunction(1) // 调用内部函数 internalFunction
    }
    
    
    //  闭包，可以捕获和存储其所在上下文中任意常量和变量的引用。
    /**
     全局和嵌套函数实际上也是特殊的闭包，闭包采用如下3种形式之一。
     1. 全局函数是一个有名字但不会捕获任何值得闭包
     2. 嵌套函数是一个有名字并可以捕获其封闭函数域内值得闭包。
     3. 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值得没有名字的闭包。
     闭包格式
     {
     (参数：类型) -> 返回类型 in
     执行方法
     return 返回类型
     }
     */
    /*
     说明：
     1. 闭包主要指向函数类型
     2. 闭包的参数必须和函数类型的参数和返回值一致
     */
    // 闭包例子
    func GetList(arr: [Int], pre: (Int) -> Bool) -> [Int] {
        // 定义一个空的可变整型集合
        var tempArr = [Int]();
        
        for temp in arr {
            if pre(temp) {
                tempArr.append(temp);
            }
        }
        return tempArr;
        
    }