闭包表达式
在Swift中，可以通过func定义一个函数，也可以通过闭包表达式定义一个函数
// 函数
func sum(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
// 闭包表达式的写法一
var fn1 = {(v1: Int, v2: Int) -> Int in
return v1 + v2
}
fn1(10, 20)
// 闭包表达式的写法二
let fn2 = {(v1: Int, v2: Int) -> Int in
return v1 + v2
}(10, 30){ (参数列表) -> 返回值类型 in
函数体代码
}闭包表达式的简写
// 定义一个函数
func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
print(fn(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
})
// 因为只是一个简单的加法运算，这个时候可以省略参数和in，并且 v1 + v2 用 $0 + $1 替代
exec(v1: 10, v2: 20, fn: {
$0 + $1
})
// 什么都省略了，两个值相加可以直接用 + 表示
exec(v1: 10, v2: 20, fn: +)尾随闭包
- 如果将一个很长的闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性
- 尾随闭包是一个被书写在函数调用括号外面(后面)的闭包表达式
func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
print(fn(v1, v2))
}
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 sort(by areInIncreasingOrder: (Element, Element) -> Bool)/// 返回true: i1排在i2前面
/// 返回false: i1排在i2后面
func cmp(i1: Int, i2: Int) -> Bool {
// 大的排在前面
return i1 > i2
}
var nums = [11, 2, 18, 6, 5, 68, 45]
nums.sort(by: cmp)
// [68, 45, 18, 11, 6, 5, 2]
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 }
// [2, 5, 6, 11, 18, 45, 68]忽略参数
func exec(fn: (Int, Int) -> Int) {
print(fn(1, 2))
}
exec { _,_ in 10 } // 10闭包(Closure)
- 一个函数和它所捕获的变量\常量环境组合起来，称之为闭包
- 一般指定义在函数内部的函数
- 一般它捕获的是外层函数的局部变量\常量
typealias Fn = (Int) -> Int
func getFn() -> Fn {
var num = 0
func plus(_ i: Int) -> Int {
num += i
return num
}
return plus
} // 返回的 plus 和 num 形成了闭包
var fn1 = getFn()
var fn2 = getFn()
fn1(1) // 1
fn2(2) // 2
fn1(3) // 4
fn2(4) // 6
fn1(5) // 9
fn2(6) // 12其实 getFn 还可以这么写, 增强闭包表达式的理解。
func getFn() -> Fn {
var num = 0
return {
num += $0
return num
}
}- 可以把闭包想象成是一个类的实例对象
- 内存在堆空间
- 捕获的局部变量\常量就是对象的成员(存储属性)
- 组成闭包的函数就是类内部定义的方法
如下图：
思考：如果是全局变量呢？
如果是全局变量的话，结果是不一样的，因为全局变量放在全局(静态)存储区, 当调用 plus 的时候，它是不会去捕获 num ，然后放到堆空间的，因为已经就在全局区，可以随时访问，没有必要再去捕获(保命)。
所以，num 放在全局区时，num 和 plus 组合起来的环境并不是闭包。
注意
如果返回值是函数类型，那么参数的修饰要保持统一
func add(_ num: Int) -> (inout Int) -> Void {
func plus(v: inout Int) {
v += num
}
return plus
}
var num = 5
add(20)(&num)
print(num) // 25自动闭包
- @autoclosure 会自动将 20 封装成 { 20 }
@autoclosure 只支持() -> T 格式的参数
@autoclosure 并非只支持最后一个参数
空合并运算符 ?? 使用了 @autoclosure 技术
有 @autoclosure ，无 @autoclosure，构成了函数重载
/// 如果 v1 大于 0，返回 v1，否则返回 v2
func getFirstPositive(_ v1: Int, _ v2: Int) -> Int {
return v1 > 0 ? v1 : v2
}
getFirstPositive(10, 20) // 10
getFirstPositive(-2, 20) // 20
getFirstPositive(0, -4) // -4/// 改成函数类型的参数，可以让 v2 延时加载
func getFirstPositive(_ v1: Int, _ v2: () -> Int) -> Int? {
return v1 > 0 ? v1 : v2()
}
getFirstPositive(-4){20}func getFirstPositive(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int? {
return v1 > 0 ? v1 : v2()
}
getFirstPositive(-4, 20)为了避免与期望冲突，使用 @autoclosure
本文章只是本人的学习笔记！
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
