在Swift中定义一个函数有两种方式
1. 可以通过func定义一个函数
2. 通过闭包表达式
闭包格式：
{
（参数列表）-> 返回值 in
函数体代码
}
示例：
//函数
func sum(_ v1 : Int , _ v2 : Int) -> Int {
return v1 + v2
}
print(sum(1, 2)) //3
//闭包1
var fn = {
(v1 : Int , v2 : Int) -> Int in
return v1 + v2
}
print(fn(1,2)) //3
//闭包2
print({
(v1 : Int , v2 : Int) -> Int in
return v1 + v2
}(20,30)) //50
1. 闭包表达式的简写
//函数定义
func exec(v1: Int, v2: Int , fn: (Int, Int) -> Int){
print(fn(v1,v2))
}
//调用
exec(v1: 10, v2: 20, fn: {
(v1, v2) -> Int in
return v1 + v2
})
//2
exec(v1: 10, v2: 20, fn: {
(v1, v2) in return v1 + v2
}
)
//3
exec(v1: 10, v2: 20, fn: {
(v1, v2) in v1 + v2 //如果函数体代码就是一个单一的表单时，则return可以省略
}
)
//4
exec(v1: 10, v2: 20, fn: {$0 + $1})//$0 第一个参数
//5
exec(v1: 10, v2: 20, fn: + )
2. 尾随闭包
- 如果将一个很长的闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性
- 尾随闭包是一个书写在函数调用括号外面（后面）的闭包表达式
exec(v1: 10, v2: 20){
(v1, v2) -> Int in
return v1 + v2
}
exec(v1: 10, v2: 20){$0 + $1}
- 如果闭包表达式是函数唯一实参，而且使用了尾随闭包的语法，那就不需要在函数后面写圆括号
func execc(fn : (Int, Int) -> Int){
print(fn(1,2))
}
execc(fn: {
(v1, v2) -> Int in
return v1 + v2
}
)
execc { (v1, v2) -> Int in
return v1 + v2
}
execc{$0 + $1}
3. 自动闭包
为了避免与期望冲突，使用了@autoclosure 的地方最好明确注释清楚：这个值会被推迟执行
func getFirstPositive(_ v1: Int, _ v2: Int) -> Int {
return v1 > 0 ? v1 : v2
}
getFirstPositive(10, 20)//10
getFirstPositive(-2, 20)//20
getFirstPositive(0, -4)//-4
func sum( ) -> Int {
let a = 10
let b = 10
return a + b
}
getFirstPositive(10, sum())//对于这种情况，即便v1>0,后面的sum还是会执行，浪费资源
//优化
func getFirstPositive2(_ v1: Int, _ v2: ()->Int) -> Int {
return v1 > 0 ? v1 : v2()
}
getFirstPositive2(10, {20})//10
getFirstPositive2(-2, {20})//20
getFirstPositive2(0, {-4})//-4
//autoclosure自动闭包 延迟加载
func getFirstPositive2(_ v1: Int, _ v2: @autoclosure()->Int) -> Int {
return v1 > 0 ? v1 : v2()
}
getFirstPositive2(10, 20)//10
getFirstPositive2(-2, 20)//20
getFirstPositive2(0, -4)//-4
getFirstPositive2(2, sum())
-
@autoclosure会自动将20 封装成闭包 {20} -
@autoclosure只支持 ()-> T 格式的参数 -
@autoclosure并非只支持最后一个参数 - 空合并运算符?? 使用了-
@autoclosure技术 - 有
@autoclosure和 无@autoclosure构成了函数重载
4. 非逃逸闭包、逃逸闭包
非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数
非逃逸闭包：闭包调用发生在函数结束之前，闭包调用在函数作用域内
逃逸闭包：闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping声明
typealias Fn = () -> ()
//fn 是非逃逸闭包
func test1(_ fn : Fn) {
fn()
}
var gFn : Fn?
//fn 是逃逸闭包
func test2(_ fn: @escaping Fn) {
gFn = fn
}
//fn 是逃逸闭包
func test3(_ fn: @escaping Fn) {
DispatchQueue.global().async {
fn()// 异步，可能不再函数作用域
}
}
闭包
- 一个函数和它所捕获的变量/常量环境组合起来。称为闭包，
- 一般指定义在函数内部的函数。
- 一般它捕获的是外层函数的局部变量/常量
typealias Fn = (Int) -> Int
func getFn() -> Fn{
//局部变量 num
var num = 0
func plus(_ i:Int) -> Int{
//被捕获后，会在堆空间分配一个内存用来存储num
num += i
return num
}
return plus// 返回的plus 跟 捕获的 num 组合起来叫做闭包，getFn只是一个函数
}
// 上面闭包的简写方式
func getFnS() -> Fn{
var num = 0
return {
num += $0
return num
}
}
var fn1 = getFn()
var fn2 = getFn()
print(fn1(1))//1
print(fn2(2))//2
print(fn1(3))//4
print(fn2(4))//6
- 可以把闭包想象成一个类的实例对象
- 内存在堆空间
- 捕获的局部变量/常量就是对象的成员（存储属性）
- 组成闭包的函数就是类内部定义的方法
class Closure {
var num = 0
func plus(_ i: Int) -> Int {
num += i
return num
}
}
var c1 = Closure()
var c2 = Closure()
c1.plus(1)//1
c2.plus(2)//2
c1.plus(3)//4
c2.plus(4)//6
