詳解Swift中的函數及函數閉包運用。本站提示廣大學習愛好者：（詳解Swift中的函數及函數閉包運用）文章只能為提供參考，不一定能成為您想要的結果。以下是詳解Swift中的函數及函數閉包運用正文
一、引言
函數是有特定功用的代碼段，函數會有一個特定的稱號調用時來運用。Swift提供了非常靈敏的方式來創立與調用函數。現實上在Swift，每個函數都是一品種型，這品種型由參數和前往值來決議。Swift和Objective-C的一大區別就在於Swift中的函數可以停止嵌套。
而Swift中的閉包是有一定功用的代碼塊，這非常相似於Objective-C中的block語法。Swift中的閉包語法作風非常簡約，其作用和函數的作用類似。
二、函數的創立與調用
函數經過函數名，參數和前往值來定義，參數和前往值決議一個函數的類型，在調用函數時，運用函數名來停止調用，示例如下：
//傳入一個名字 打印並將其前往
func printName(name:String) -> String {
print(name)
return name
}
//停止函數的調用
printName("HS")
也可以創立沒有參數的函數：
func onePuseTwo()->Int {
return 1+2
}
onePuseTwo()
異樣也可以創立沒有前往值的函數：
func sayHello(){
print("Hello")
}
sayHello()
下面引見的函數類型都比擬罕見，關於多前往值的函數，在Objective-C中非常難處置，開發者通常會采用字典、數組等集合方式或許干脆運用block回調，在Swift中，可以運用元組作為函數的前往值，示例如下：
func tuples()->(Int,String){
return (1,"1")
}
tuples()
也可以是函數前往一個Optional類型的值，支持前往nil，示例如下：
func func1(param:Int)->Int? {
guard(param>0)else{
return nil
}
return param
}
func1(0)
func1(1)
在函數的參數名前，開發者還可以再為其添加一個參數稱號作為內部參數名，示例如下：
func func1(count param:Int ,count2 param2:Int)->Int? {
//外部仍然運用param
guard(param>0)else{
return nil
}
return param
}
//內部調用運用count
func1(count: 0,count2: 0)
func1(count: 1,count2: 1)
其實Swift函數中的參數列表有這樣一個特點，除了第一個參數外，之後的參數都默許添加一個一個和外部稱號相反的內部稱號，假如開發者不想運用這個內部稱號，運用_符號設置，示例如下：
func func2(param:Int,param2:Int,param3:Int) {
}
//有內部稱號
func2(0, param2: 0, param3: 0)
func func3(param:Int,_ param2:Int,_ param3:Int) {
}
//沒有內部稱號
func3(0, 0, 0)
Swift也支持開發者為函數的參數創立一個默許值，假如函數的某個參數有設置默許值，則開發者在調用時可以省略此參數，示例如下：
func func4(param:Int=1,param2:Int=2,param3:Int) {
print(param,param2,param3)
}
func4(3,param3:3)
還有一種情形在Objective-C中也很處置，關於參數數量不定的函數，在後面章節引見過，Objective-C普通會運用list指針來完成，在Swift中編寫這樣的函數非常復雜，示例如下：
func func5(param:Int...) {
for index in param {
print(index)
}
}
func5(1,2,3,4)
Swift中參數默許是常量，在函數中是不能修正內部傳入參數的值得，假如有需求，需求將參數聲明成inout類型，示例如下：
func func6(inout param:Int) {
param = 10
}
var count = 1
//實踐上傳入的是參數地址
func6(&count)
print(count)
三、函數類型
函數是一種特殊的數據類型，每一個函數屬於一種數據類型，示例如下：
func func7(a:Int,_ b:Int)->Int{
return a+b
}
var addFunc:(Int,Int)->Int = func7
addFunc(1,2)
函數也可以作為參數傳入另一個函數，這非常相似於Objective-C中的block語法，示例如下：
func func7(a:Int,_ b:Int)->Int{
return a+b
}
var addFunc:(Int,Int)->Int = func7
addFunc(1,2)
func func8(param:Int,param2:Int,param3:(Int,Int)->Int) -> Int {
return param3(param,param2)
}
//傳入函數
func8(1, param2: 2, param3: addFunc)
//閉包的方式
func8(2, param2: 2, param3:{ (a:Int,b:Int) -> Int in
return a*b
})
一團體函數也可以作為另一個函數的前往值，示例如下：
func func9()->(Int)->Int{
//Swift支持嵌套函數
func tmp(a:Int)->Int{
return a*a
}
return tmp
}
var myFunc = func9()
myFunc(3)
四、從一個零碎函數看閉包
Swift規范函數庫中提供了一個sort排序函數，關於曾經元素類型的數組，調用sort函數會停止重新排序並前往新的排序後的數組。這個sort函數可以接納一個前往值為Bool類型的閉包，來確定第一個元素能否排在第二個元素後面。代碼示例如下：
var array = [3,21,5,2,64]
func func1(param1:Int,param2:Int) -> Bool {
return param1>param2
}
//經過傳入函數的方式
//array = [64,21,5,3,2]
array = array.sort(func1)
//經過閉包的方式
//array = [2,3,5,21,64]
array = array.sort({(param:Int,param2:Int)->Bool in
return param<param2
})
Swift言語有一個很明顯的特點就是簡約，可以經過上下文推斷出類型的狀況普通開發都可以將類型的書寫省略，這也是Swift言語設計的一個思緒，由於閉包是作為函數的參數傳入函數中的，由於函數參數的類型是確定，因而閉包的類型是可以被編譯器推斷出來的，開發者也可以將閉包的參數類型和前往值省略，下面的代碼可以簡寫如下：
//將閉包的參數類型和前往值都省略
array = array.sort({(p1,p2) in return p1>p2})
實踐上，假如閉包中的函數體只要一行代碼，可以將return關鍵字也省略，這時會隱式的前往此行代碼的值，如下：
array = array.sort({(p1,p2) in p1>p2})
看到下面的表達式，是不是有點小震驚，閉包表達式居然可以簡寫成這樣！但是，你還是小看的Swift開發團隊，前面的語法規則會讓你明白什麼是簡約的極致。可以看到下面的代碼完成還是有3局部：參數和前往值，閉包關鍵字，函數體。參數和前往值即是參數列表，p1，p2，雖然省略了參數類型和前往值類型，但這局部的模塊還在，閉包關鍵字即是in，它用來表示上面將是閉包的函數體，p1>p2即是函數體，只是這裡省略了return關鍵字。閉包中既然參數類型和前往值類型編譯器都可以自己推斷出來，那麼參數的數量編輯器也是可以自行推斷的，因而，參數列表實踐上也是多余的，閉包中會自動生成一些參數稱號，和實踐的參數數量向對應，例如下面sort函數中的閉包有兩個參數，零碎會自動生成$0和$1這兩個參數名，開發者可以直接運用，由於參數列表都會省略了，那麼也不再需求閉包關鍵字in來分隔參數列表與函數體，這時，閉包的寫法實踐上變成了如下的容貌：
array = array.sort({$0<$1})
你沒有看錯，加上左右的大括號，一共7個字符，完成了一個排序算法。除了Swift，我不知道能否還有第二種言語可以做到。拋開閉包不說，Swift中還有一種語法，其可以定義類型的運算符辦法，例如String類型可以經過=，<，>來停止比擬，實踐上是String類中完成了這些運算符辦法，在某種意義上說，一個運算符即相似與一個函數，那麼好了，sort函數中需求傳入的辦法關於某些類型來說實踐上只是需求一個運算符，示例如下：
array = array.sort(>)
這次你可以真的震驚了，完成排序新算法只需求一個字符，不折不扣的一個字符。
五、Swift中閉包的更多特點
Swift中的閉包還有一個風趣的特點，首先閉包是作為參數傳入另一個函數中的，因而慣例的寫法是將閉包的大括號寫在函數的參數列表小括號中，假如閉包中的代碼很多，這時在代碼構造下去看會變得並不太明晰，為理解決這個問題，Swift中這樣規則：假如這個閉包參數是函數的最後一個參數，開發者可以將其拉出小括號，在函數尾部完成閉包代碼，示例如下：
//閉包開頭
func func2(param1:Int,param2:()->Void)->Void{
param2()
print("調用了func2函數")
}
func2(0){
print("閉包中的內容")
}
假如一個函數中只要一個參數，且這個參數是一個閉包，那麼開發者運用閉包開頭這種寫法，完全可以將函數的參數列表小括號也省略掉，示例如下：
func func3(param:()->Void)->Void{
param()
print("調用了func3函數")
}
func3{
print("閉包中的內容")
}
Swift中還有一個閉包逃逸的概念，這個很好了解，當閉包作為參數傳遞進函數時，假如這個閉包只在函數中被運用，則開發者可以將這個閉包聲明成非逃逸的，即通知零碎當此函數完畢後，這個閉包的聲明周期也將完畢，這樣做的益處是可以進步代碼功能，將閉包聲明稱非逃逸的類型運用@noescape關鍵字，示例如下：
func func3(@noescape param:()->Void)->Void{
param()
print("調用了func3函數")
}
func3{
print("閉包中的內容")
}
逃逸的閉包常用於異步的操作，例如這個閉包是異步處置一個網絡懇求，只要當懇求完畢後，閉包的聲明周期才完畢。非逃逸的閉包還有一個風趣的特點，在其外部假如需求運用self這個關鍵字，self可以被省略。
閉包也可以被自動的生成，這種閉包被稱為自動閉包，自動閉包可以自動將表達式封裝成閉包，開發者不需求再寫閉包的大括號格式，自動閉包不接納參數，前往值為其中表達式的值。示例如下：
//自動閉包演示
var list = [1,2,3,4,5,6]
//創立一個顯式閉包
let closures = {
list.removeFirst()
list.append(7)
}
//將打印[1,2,3,4,5,6]
print(list)
//執行閉包
closures()
//將打印[2,3,4,5,6,7]
print(list)
func func4(closure:()->Void) -> Void {
//執行顯式的閉包
closures()
}
func func5(@autoclosure auto:()->Void) -> Void {
//執行自動閉包
auto()
}
//顯式閉包 需求大括號
func4(closures)
//將打印[3,4,5,6,7,7]
print(list)
//將表達式自動生成閉包
func5(list.append(8))
//將打印[3,4,5,6,7,7,8]
print(list)
自動閉包默許是非逃逸的，假如要運用逃逸的閉包，需求手動聲明，如下：
func func5(@autoclosure(escaping) auto:()->Void) -> Void {
//執行自動閉包
auto()
}
