swift学习之- 闭包

一、闭包的概念

     在swift中的闭包中被称为结构块，可以在任何地方被调用，它就像C和OC语言中的内置函数一样。函数内部定义的常量和变量引用可被捕获并存储在闭包。闭包可分为三大类：

1、全局函数：有名字但不捕获任何值；

2、嵌套函数：有名字从封闭函数捕捉值；

3、闭合表达式：无名字从相邻块捕获值；

闭合表达式的优化，重量轻语法风格，其中包括：

（1）推导参数并从上下文菜单获取返回值的类型

（2）从单封表达的隐性返回

（3）简略参数名称

（4）尾部闭包语法

二、闭包表达式语法：

函数
func funcName(参数) -> 返回值类型{
    执行语句
}
闭包表达式
{ （参数）->返回值类型 in
    执行语句

}

1、定义一个有两个参数的闭包
let add:(Int, Int) ->Int = { (a: Int, b: Int) ->Int in
    return a + b
}

//调用时通过赋值给一个常量或者变量
print(add(3,5))

2.闭包表达式回调用法

//写一个排序的闭包进行回调

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

var array = [20, 5, 6, 13, 45, 3]
let intCmp = {
    (a: Int, b: Int) ->Int in
    if a > b {
     return -1
    } else if a < b {
     return 1
    } else {
     return 0
    }
}
bubbleSort(&array, cmp: intCmp)
print(array)

//print(bubbleSort(intCmp))
//如果一个闭包的类型已知， 比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句的闭包会把他语句的值当做结果返回。

3. 嵌套函数（闭包捕获上下文的值）

func bubbleSortFunc1(inout array1: [Int]) {
    let cnt1 = array1.count
    func swapValue(inout a: Int, inout b: Int) {
        let t = a
        a = b
        b = t
    }
    for i in 1 ..< cnt1 {
        for j in 0 ..< cnt1 - i {
            if (array1[j] > array1[j + 1]) {
               swapValue(&array1[j], b: &array1[j + 1])
            }
        }
    }
}

var array1 = [4, 6, 2, 1, 11, 90, 67, 80]
bubbleSortFunc1(&array1)
print(array1)