iOS_Swift_闭包

闭包可以在其定义的上下文中捕获常量或变量。 即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。

let sayhello = {

            print("hello world")
        }
        let add:(Int,Int)->Int = {

            (a:Int,b:Int) -> Int in
            return a+b
        }

        var array = [20,2,3,70,8]
        //array 自带排序函数sort
        showArray(array)
        print(array.sort())



        bublleSort(&array,cmp: {

            (a:Int,b:Int)->Int in
            if(a>b){
                return -1
            }else if(a<b){

                return 1
            }else{

                return 0
            }
        })
        //闭包的优化
        bublleSort(&array, cmp: {

            if $0 > $1{

                return -1
            }else{

                return 0
            }
        })
        showArray(array)

        /*
         尾随闭包,闭包要放在函数的最后一个参数
         **/
        /*
         Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。 嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
         嵌套函数(函数内部声明的函数,作用域仅限于该函数)
         值捕获
         **/
        let incresult = incfunc(3)

        //这个值得说的是两个值是不同的,说明了值得到了保存
        print(incresult(5))
        print(incresult(5))
        // Do any additional setup after loading the view, typically from a nib.
    }

    func incfunc(inc:Int) -> (Int)->Int {
        var geta = 10
        func incfuncs (incinside:Int)->Int{

            geta += 1
            return inc + incinside + geta
        }
        return incfuncs
    }

    func bublleSort(inout array:[Int] , cmp:(a:Int,b:Int)->Int) {
        let cnt = array.count

        for var i = 1 ; i<cnt ;i += 1 {
            for var j = 0; j<cnt-i ; j+=1 {
                if (cmp(a: array[j],b: array[j+1]) == -1) {
                    let a = array[j]
                    array[j] = array[j+1]
                    array[j+1] = a
                }
            }
        }

    }
    func showArray(array:[Int]){
        for x in array {
            print("\(x)")
        }
    }