一·函数
函数结构
func 方法名字(参数名字：参数类型，参数名字1: 参数类型) ->返回值类型/（返回值名字：返回值类型，返回值名字1:返回值类型）
func sum(a : Int , b : Int) -> (c : Int , d : Int)?{
//为什么要添加一个可选类型，可以使用可选的 元组返回类型反映整个元组可以是 nil 的事实
}
忽略参数标签
func add (_ firstInta : Int , b secendIntB : Int) -> Int?{}
方法调用 add (1,secendIntB: 2)
默认参数
func add (firstPara : Int,SecendPara : Int = 12)
方法调用 add (firstPara : 1) 此时第二个参数没有传入，默认第二个参数等于12
add (firstPara:1, SecendPara : 0)
可变参数
func sum (_ num : Double...) -> Double{}
...调用者无法知道传入的参数num有多少个，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入 。。。
二·闭包
形式1: 有名字但是不会捕获任何值的闭包 -> 全局函数
形式2: 有名字并可以捕获其封闭函数域内值的闭包 -> 嵌套函数
形式3: 闭包表达式可以捕获上下文中的变量和常量 -> 普通闭包
普通闭包：攥写一个符合其类型要求的函数，并作为参数传入到另外一个函数当中去。
例:
符合类型的函数
func background(_ s1 : String , _ s2 : String ) -> BOOL{
return s1 > s2
}
作为sorted(by:)参数传入
var reverseName = name.sorted(by:backround)
那么闭包表达式为 :
var reverseName = name.sorted(by:{s1:String , s2:String -> BOOL in
return s1 > s2
})
闭包的一般表达式：
{ (入参的函数) -> 返回类型 in
闭包体
} ⚠️注意：像这样的内联闭包表达式中，函数和返回值都在大括号内，函数体由 in 引入
推断：reversedNames = names.sorted(by:{ > })
尾随闭包
还是由上诉例子
普通闭包：
var reverseName = name.sorted(by:{s1:String , s2:String -> BOOL in
return s1 > s2
})
尾随闭包：
var reverseName = name.sotred(){
s1 > s2 //如果闭包函数是唯一的参数 ()可以省略
}
值捕获
func makeCatch (forCatch num : Int) -> () -> Int{
var i = 0
func catch() -> Int{
i = num
return i
}
return catch
}
->() 返回值类型是一个函数
-> Int 该函数调用时不传入参数，返回Int
注意⚠️：可以看到嵌套函数catch捕获了外面的i 和 num , 而且闭包函数也是一种类型可以赋值给变量和常量
逃逸闭包
定义：当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。
关键字：@escaping
1.定义一个闭包函数
func ccccc(closure:() -> void){
闭包函数
}
2.定义一个逃逸闭包
var completionHandlers:[()->Void]=[]
func ddddd(completionHandler :@escaping () -> void){
completionHandlers.append(completionHandler)
}
class mainClass{
var x = 0
func dosomething(){
ccccc{ self.x = 100 }
ddddd{ x = 200 }
}
}
let Instance = mainClass()
Instance.dosomething()
print(Instance.x) //200
