?在Swift中定義一個函數(shù)有兩種方式
??1. 可以通過func定義一個函數(shù)
??2. 通過閉包表達式
閉包格式：
{
（參數(shù)列表）-> 返回值 in
? 函數(shù)體代碼
}
示例：
//函數(shù)
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. 閉包表達式的簡寫
//函數(shù)定義
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 //如果函數(shù)體代碼就是一個單一的表單時，則return可以省略
}
)
//4
exec(v1: 10, v2: 20, fn: {$0 + $1})//$0 第一個參數(shù)
//5
exec(v1: 10, v2: 20, fn: + )
2. 尾隨閉包
- 如果將一個很長的閉包表達式作為函數(shù)的最后一個實參，使用尾隨閉包可以增強函數(shù)的可讀性
- 尾隨閉包是一個書寫在函數(shù)調用括號外面（后面）的閉包表達式
exec(v1: 10, v2: 20){
(v1, v2) -> Int in
return v1 + v2
}
exec(v1: 10, v2: 20){$0 + $1}
- 如果閉包表達式是函數(shù)唯一實參，而且使用了尾隨閉包的語法呢诬，那就不需要在函數(shù)后面寫圓括號
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 的地方最好明確注釋清楚：這個值會被推遲執(zhí)行
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還是會執(zhí)行戒良，浪費資源
//優(yōu)化
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 格式的參數(shù) -
@autoclosure并非只支持最后一個參數(shù) - 空合并運算符?? 使用了-
@autoclosure技術 - 有
@autoclosure和 無@autoclosure構成了函數(shù)重載
4. 非逃逸閉包谋逻、逃逸閉包
非逃逸閉包殷绍、逃逸閉包染苛，一般都是當做參數(shù)傳遞給函數(shù)
非逃逸閉包：閉包調用發(fā)生在函數(shù)結束之前，閉包調用在函數(shù)作用域內(nèi)
逃逸閉包：閉包有可能在函數(shù)結束后調用主到，閉包調用逃離了函數(shù)的作用域殖侵，需要通過@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()// 異步，可能不再函數(shù)作用域
}
}
閉包
- 一個函數(shù)和它所捕獲的變量/常量環(huán)境組合起來镰烧。稱為閉包，
- 一般指定義在函數(shù)內(nèi)部的函數(shù)楞陷。
- 一般它捕獲的是外層函數(shù)的局部變量/常量
typealias Fn = (Int) -> Int
func getFn() -> Fn{
//局部變量 num
var num = 0
func plus(_ i:Int) -> Int{
//被捕獲后怔鳖，會在堆空間分配一個內(nèi)存用來存儲num
num += i
return num
}
return plus// 返回的plus 跟 捕獲的 num 組合起來叫做閉包，getFn只是一個函數(shù)
}
// 上面閉包的簡寫方式
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
- 可以把閉包想象成一個類的實例對象
- 內(nèi)存在堆空間
- 捕獲的局部變量/常量就是對象的成員（存儲屬性）
- 組成閉包的函數(shù)就是類內(nèi)部定義的方法
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
