Swift－闭包

  闭包表达式

 {

    (参数) ->返回值类型 in

    执行语句

 }

/*
 1、 闭包表达式
 {
    (参数) -> 返回值类型 in
    执行语句
 }
 */
print("1、 闭包表达式")
let sayHello = {
    print("hello")
}
sayHello()

let add:(Int,Int) -> Int = {
    (a:Int,b:Int) -> Int in
    return a+b
}
print(add(3,2))

/*
 2、 闭包表达式作为函数回调
 {
 (参数) -> 返回值类型 in
 执行语句
 }
 */
print("\n2、 闭包表达式作为函数回调")
func showArray(array:[Int]){
//    for i in array{
//        print("\(i) ")
//    }
    print(array)
}

//冒泡排序
//func bubbleSort(array:inout [Int]){
//    for i in 1 ..< array.count
//    {
//        for j in 0 ..< array.count - i
//        {
//            if array[j] > array[j+1]
//            {
//                let t = array[j]
//                array[j] = array[j + 1]
//                array[j+1] = t
//            }
//        }
//    }
//}
func bubbleSort(array:inout [Int],cmp:(Int,Int) -> Int){
    for i in 1 ..< array.count
    {
        for j in 0 ..< array.count - i
        {
            if cmp(array[j],array[j+1]) == -1
            {
                let t = array[j]
                array[j] = array[j + 1]
                array[j+1] = t
            }
        }
    }
}


var arr = [20,30,4,5,80]
showArray(array:arr)
let intCmp:(Int,Int) -> Int = {
    (a:Int,b:Int) -> Int in
    if a>b{
        return -1
    }else if a<b {
        return 1
    }
    else{
        return 0
    }
}
//bubbleSort(array: &arr)
//bubbleSort(array: &arr,cmp:intCmp)

//闭包表达式优化（类型推断机制--根据已经定义好的参数、返回值类型进行省略，且可以使用$符号进行参数省略，即 $0: 表示第一个参数）
bubbleSort(array:&arr,cmp:{
    if $0>$1 {
        return -1
    }else if $0<$1 {
        return 1
    }
    else{
        return 0
    }
})
showArray(array: arr)

//.sort-系统冒泡排序
arr.sort{
    (a:Int,b:Int) -> Bool in
    return a>b
}
showArray(array: arr)

/*
 3、嵌套函数
 */
print("\n3、嵌套函数")
func swap(a:inout Int,b:inout Int){
    let t = a
    a = b
    b = t
}

//冒泡排序
func bubbleSortFunc(array:inout [Int]){
    for i in 1 ..< array.count
    {
        for j in 0 ..< array.count - i
        {
            if array[j] > array[j+1]
            {
                swap(a:&array[j], b:&array[j+1])
            }
        }
    }
}
bubbleSortFunc(array: &arr)
showArray(array: arr)

/*
 4、闭包捕获值
 */
print("\n4、闭包捕获值")
//嵌套函数
func getFuncValue(inc:Int) -> (Int) -> Int{
    //内部函数（局部的），捕获了上下文的值
    var m = 10 //对值进行保存并增加
    func inFunc(v:Int) -> Int{
        //var m = 10 //写在里面值不会被保存增加
        m += 1
        return inc+v+m
    }
    return inFunc
}
let getFunc1 = getFuncValue(inc: 2)
let getFunc2 = getFuncValue(inc: 2)//每个函数都有自己独有的一份闭包
print(getFunc1(10))
//这时将m = 11当成了一个全局变量进行保存，因此值在不断增加
print(getFunc1(10))
print(getFunc2(10))