闭包表达式
- 在swift中，可以通过func定义一个函数，也可以通过闭包表达式定义一个函数
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
// 闭包
{
(参数列表) -> 返回值类型 in
函数体代码
}
var fn = {
(v1: Int, v2: Int) -> Int in
return v1 + v2
}
fn(10, 20)
闭包表达式简写
func exec (v1: Int, v2: Int, fn: (Int, Int) -> Int) {
print(fn(v1, v2))
}
//func sum(v1: Int, v2: Int) -> Int {
// return v1 + v2
//}
//exec(v1: 10, v2: 20, fn: sum(v1:v2:))
exec(v1: 10, v2: 20, fn: {
(v1: Int, v2: Int) -> Int in
return v1 + v2
})
//省略参数类型
exec(v1: 10, v2: 20, fn: {
v1, v2 in return v1 + v2
})
//省略return
exec(v1: 10, v2: 20, fn: {
v1, v2 in v1 + v2
})
//美元符代替
exec(v1: 10, v2: 20, fn: {
$0 + $1
})
//
exec(v1: 10, v2: 20, fn: +)
尾随闭包
- 如果将一个很长的闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性
- 尾随闭包是一个被书写在函数调用括号外面（后面）的闭包表达式
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 testSort() {
var arr = [10, 20, 1, 2, 44]
arr.sort()
}
testSort()//1, 2, 10, 20, 44]
- 条件排序
func testSort() {
var arr = [10, 20, 1, 2, 44]
arr.sort(by: cmp)// 条件
print(arr)
}
//返回ture: i1排在i2前面
//返回false: i1排在i2后面
func cmp(i1: Int, i2: Int) -> Bool {
//大的排在前面
return i1 > i2
}
testSort()//[44, 20, 10, 2, 1]
- 闭包写法
//闭包写法
var nums = [10, 20, 1, 2, 3, 99, 49]
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
}
print(nums)//[99, 49, 20, 10, 3, 2, 1]
闭包
- 一个函数和它所捕获的变量\常量环境组合起来，成为闭包
1.一般值定义在函数内部的函数
2.一般它捕获的是外层函数的局部变量\常量
typealias Fn = (Int) -> Int
func getFn() -> Fn {
var num = 0 // 局部变量
func plus(_ i: Int) -> Int {
num += i
return num
}
return plus
} // 返回的 plus 和 num 形成的闭包
var fn = getFn() //堆空间申请一块内存，调用了一次
print(fn(1))// 1
print(fn(2))// 3
print(fn(3))// 6
自动闭包
// 如果第一个数大于0，返回第一个数，否则返回第二个数
func getFirstPositive (_ v1: Int, _ v2: Int) -> Int {
return v1 > 0 ? v1 : v2
}
getFirstPositive(10, 20)
getFirstPositive(-2, 20)
getFirstPositive(0, -4)
// 改成函数参数类型的参数，可以让v2延迟加载
func getFitstPositive (_ v1: Int, _ v2: () -> Int) -> Int? {
return v1 > 0 ? v1 : v2()
}
getFitstPositive(-4) { 20 }
func getFitstPositive(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int? {
return v1 > 0 ? v1 : v2()
}
getFitstPositive(-4, 20)
- @autoclosure 会自动将20封装成闭包 { 20 }
- @autoclosure 只支持 () -> I 格式的参数
- @autoclosure 并非只支持最后一个参数
- 空合并运算符 就是运用了 @autoclosure
- 有@autoclosure 和 无 @autoclosure 构成了函数重载
