Swift 中閉包的復雜運用

Swift 中閉包的復雜運用。本站提示廣大學習愛好者：（Swift 中閉包的復雜運用）文章只能為提供參考，不一定能成為您想要的結果。以下是Swift 中閉包的復雜運用正文

本文次要是引見Swift中閉包的復雜運用，將從“閉包的定義”、"閉包的創立、賦值、調用"、“閉包罕見的幾種運用場景”，"運用閉包能夠惹起的循環強援用" 四個方面動手，重點引見閉包如何運用，沒有深邃的概念，只是專注於實踐運用，屬於入門級程度，前面還會有關於閉包愈加詳細和深化了解的文章。希望大家在閱讀完本文後可以對閉包有一個全體的了解以及可以復雜的運用它。

閉包的定義

在Swift開發文檔中是這樣引見閉包的：閉包是可以在你的代碼中被傳遞和援用的功用性獨立模塊。Swift 中的閉包和 C 以及 Objective-C 中的 block 很像，還有其他言語中的匿名函數也相似。閉包的作用次要是：夠捕捉和存儲定義在其上下文中的任何常量和變量的援用， 可以為你處置一切關於捕捉的內存管理的操作(概念性問題，可以不必糾結太多啦)。

閉包的表達式語法

閉包表達式語法有如下的普通方式：

 { (parameters/接納的參數) -> (return type/閉包前往值類型) in
  statements/保管在閉包中需求執行的代碼
 }

閉包依據你的需求是有類型的，閉包的類型 普通方式如下:

(parameters/接納的參數) -> (return type/閉包前往值類型)

應用typealias為閉包類型定義別名

這裡先引見一下 typealias的運用 : typealias是Swift中用來為曾經存在的類型重新定義名字的關鍵字（相似於OC語法中的 typedef），重新命名的新名字用來替代之前的類型，並且可以使代碼變得愈加明晰復雜容易了解。typealias 的用法很復雜，直接用 = 賦值就可以了：

typealias <type name> = <type expression>

這裡我們可以用 typealias 來為看似較為復雜的閉包類型定義別名，這樣當前我們就可以用別名直接去聲明這樣類型的閉包了，例子如下：

//為沒有參數也沒有前往值的閉包類型起一一般名
 typealias Nothing = () -> ()

 //假如閉包的沒有前往值，那麼我們還可以這樣寫，
 typealias Anything = () -> Void

 //為承受一個Int類型的參數不前往任何值的閉包類型 定義一一般名：PrintNumber
 typealias PrintNumber = (Int) -> ()

 //為承受兩個Int類型的參數並且前往一個Int類型的值的閉包類型 定義一一般名：Add
 typealias Add = (Int, Int) -> (Int)

閉包能否承受參數、承受幾個參數、前往什麼類型的值完全取決於你的需求。

閉包的創立、賦值、調用

閉包表達式語法可以運用常量方式參數、變量方式參數和輸出輸入方式參數，但不能提供默許值。可變方式參數也能運用，但需求在方式參數列表的最前面運用。元組也可被用來作為方式參數和前往類型。在閉包的中會用到一個關鍵字in，in 可以看做是一個聯系符，他把該閉包的類型和閉包的函數體分開，in後面是該閉包的類型，in前面是詳細閉包調用時保管的需求執行的代碼。表示該閉包的方式參數類型和前往類型定義曾經完成，並且閉包的函數體行將開端執行。這裡總結了一下能夠用到的幾種方式完成閉包的創立、賦值、調用的進程。例子如下:

方式一：應用typealias最完好的創立

//為(_ num1: Int, _ num2: Int) -> (Int) 類型的閉包定義別名：Add
 typealias Add = (_ num1: Int, _ num2: Int) -> (Int)
//創立一個 Add 類型的閉包常量：addCloser1
 let addCloser1: Add
//為曾經創立好的常量 addCloser1 賦值
 addCloser1 = {
  (_ num1: Int, _ num2: Int) -> (Int) in
  return num1 + num2
 }
//調用閉包並承受前往值
 let result = addCloser1(20, 10)

方式二：閉包類型聲明和變量的創立兼並在一同

//創立一個 (_ num1: Int, _ num2: Int) -> (Int) 類型的閉包常量：addCloser1
 let addCloser1: (_ num1: Int, _ num2: Int) -> (Int)
//為曾經創立好的常量 addCloser1 賦值
 addCloser1 = {
   (_ num1: Int, _ num2: Int) -> (Int) in
   return num1 + num2
 }
 //調用閉包並承受前往值
 let result = addCloser1(20, 10)

方式三：省略閉包接納的形參、省略閉包體中前往值

//創立一個 (Int, Int) -> (Int) 類型的閉包常量：addCloser1
 let addCloser1: (Int, Int) -> (Int)
//為曾經創立好的常量 addCloser1 賦值
 addCloser1 = {
   (num1, num2) in
   return num1 + num2
 }
//調用閉包並承受前往值
 let result = addCloser1(20, 10)

方式四：在方式三的根底上進一步精簡

//創立一個 (Int, Int) -> (Int) 類型的閉包常量：addCloser1 並賦值
 let addCloser1: (Int, Int) -> (Int) = {
   (num1, num2) in
   return num1 + num2
  } 
//調用閉包並承受前往值
 let result = addCloser1(20, 10)

方式五：假如閉包沒有接納參數省略in

//創立一個 () -> (String) 類型的閉包常量：addCloser1 並賦值
  let addCloser1: () -> (String) = {
   return "這個閉包沒有參數，但是有前往值"
   }
 //調用閉包並承受前往值
  let result = addCloser1()

方式六：簡寫的實踐參數名

//創立一個 (String, String) -> (String) 類型的閉包常量：addCloser1 並賦值
  let addCloser1: (String, String) -> (String) = {
   return "閉包的前往值是:\($0),\($1)"
   }
 //調用閉包並承受前往值
  let result = addCloser1("Hello", "Swift!")

闡明： 得益於Swift的類型推斷機制，我們在運用閉包的時分可以省略很多東西，而且Swift自動對行內閉包提供簡寫實踐參數名，你也可以經過 $0, $1, $2 等名字來援用閉包的實踐參數值。假如你在閉包表達式中運用這些簡寫實踐參數名，那麼你可以在閉包的實踐參數列表中疏忽對其的定義，並且簡寫實踐參數名的數字和類型將會從希冀的函數類型中推斷出來。in關鍵字也能被省略，$0 和 $1 辨別是閉包的第一個和第二個 String類型的 實踐參數（引自文檔翻譯）。

閉包罕見的幾種運用場景

根本掌握閉包的概念後，我們就可以應用閉包做事情了，上面引見一下閉包在開發中的能夠被用到的場景。
場景一：應用閉包傳值
開發進程中經常會有這樣的需求：一個頁面的失掉的數據需求傳遞給前一個頁面運用。這時分運用閉包可以很復雜的完成兩個頁面之間傳值。

圖片發自簡書App

場景再現：

第一個界面中有一個用來顯示文字的UILabel和一個點擊進入到第二個界面的UIButton,第二個界面中有一個文本框UITextField和一個點擊前往到上一個界面的UIButton,如今的需求是在第二個界面的UITextField中輸出完文字後，點擊前往按鈕前往到第一個界面並且將輸出的文字顯示在第一個界面（以後頁面）的UILabel中。

完成代碼:

首先在第二個界面的控制器中定義一個( String) -> ()可選類型的閉包常量closer作為SecondViewController的屬性。closer接納一個String類型的參數（就是輸出的文字）並且沒有前往值。然後在前往按鈕的點擊事情中傳遞參數執行閉包。

import UIKit
class SecondViewController: UIViewController {
 //輸出文本框
 @IBOutlet weak var textField: UITextField!
 //為創立一個(String) -> () 的可選類型的閉包變量作為控制器的屬性
 var closer: ((String) -> ())?
 //前往按鈕的點擊事情
 @IBAction func backButtonDidClick(_ sender: AnyObject) {
  //首先判別closer閉包能否曾經被賦值，假如曾經有值，直接調用該閉包，並將輸出的文字傳出來。
  if closer != nil {
   closer!(textField.text!)
  }
  navigationController?.popViewController(animated: true)
 }
}

這裡有一個留意點：我們在為SecondViewController定義變量閉包屬性的時分需求將類型聲明為可選類型，閉包可選類型應該是((String) -> ())?而不是(String) -> ()?的，後者指的是閉包的前往值是可選類型。

回到第一個界面的控制器中，我們需求拖線拿到UILabel的控件，然後重寫prepare(for segue: UIStoryboardSegue, sender:Any?) { }辦法，在這個跳轉辦法中拿到跳轉的目的控制器SecondVC並為他的閉包屬性賦值，當然假如你的跳轉按鈕的點擊事情是自己處置的，直接在按鈕的點擊事情中這樣做就OK了。

import UIKit
class FirstViewController: UIViewController {
 //顯示文字的label
 @IBOutlet weak var label: UILabel!
 //重寫這個辦法
 override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
  //拿到跳轉的目的控制器
  let secondVC = segue.destination as! SecondViewController
  //為目的控制器的閉包屬性賦值
  secondVC.closer = {
   //將閉包的參數(輸出的文本內容)顯示在label上
   self.label.text = $0
  }
 }
}

經過下面的處置，我們就可以完成兩個頁面之間的傳值了（是不是很復雜呢），當然在詳細的開發中很能夠不是傳遞文本內容這麼復雜，當需求傳遞更復雜的值時，我們可以將傳遞的值包裝成一個模型，直接用閉包傳遞模型就好了。

場景二：閉包作為函數的參數

在OC語法中block可以作為函數的參數停止傳遞，在Swift中異樣可以用閉包作為函數的參數，還記得下面應用typealias關鍵字定義別名嗎，定義完的別名就是一個閉包類型，可以用它聲明一個閉包常量或變量當做參數停止傳遞。一個最復雜的閉包作為函數參數例子如下：

//為承受一個Int類型的參數並且前往一個Int類型的值的閉包類型定義一一般名：Number
 typealias Number = (num1: Int) -> (Int)
 //定義一個接納Number類型的參數沒有前往值的辦法
 func Text(num: Number) {
  //code
 }

閉包在作為函數的參數停止傳遞的時分依據函數接納參數的狀況有很多種不同的寫法。這裡我們次要引見一下尾隨閉包的概念。

首先看一下普通方式的閉包作為函數的參數傳遞：

//拼接兩個字符串和一個整數
 func combine(handle:(String, String) -> (Void), num: Int) {
   handle("hello", "world \(num)")
  }
//辦法調用
 combine(handle: { (text, text1) -> (Void) in
   print("\(text) \(text1)")
   }, num: 2016)

可以看到下面的combine辦法在自動調用的時分照舊是依照func(形參: 實參)這樣的格式。當我們把閉包作為函數的最後一個參數的時分就引出了尾隨閉包的概念。

一，尾隨閉包

尾隨閉包是指當需求將一個很長的閉包表達式作為函數最後一個實踐參數傳遞給函數時，一個書寫在函數方式參數的括號裡面（前面）的閉包表達式：

 func combine1(num:Int, handle:(String, String)->(Void)) {
   handle("hello", "world \(num)")
 }
 combine1(num: 2016) { (text, text1) -> (Void) in
   print("\(text) \(text1)")
 }

進一步：假如閉包表達式被用作函數獨一的實踐參數並且你把閉包表達式用作尾隨閉包，那麼調用這個函數的時分函數名字的（）都可以省略：

 func combine2(handle:(String, String)->(Void)) {
   handle("hello", "world")
 }
 combine2 { (text, text1) -> (Void) in
   print("\(text) \(text1)")
 }

二，逃逸閉包

假如一個閉包被作為一個參數傳遞給一個函數，並且在函數return之後才被喚起執行，那麼我們稱這個閉包的參數是“逃出”這個函數體外，這個閉包就是逃逸閉包。此時可以在方式參數前寫 @escaping來明白閉包是允許逃逸的。
閉包可以逃逸的一種辦法是被貯存在定義於函數外的變量裡。比方說，很多函數接納閉包實踐參數來作為啟動異步義務的回調。函數在啟動義務後前往，但是閉包要直就任務完成——閉包需求逃逸，以便於稍後調用。用我們最常用的網絡懇求舉例來說：

func request(methodType:RequestMethodType, urlString: String, parameters: [String : AnyObject], completed: @escaping (AnyObject?, NSError?) -> ()) {
  // 1.封裝成功的回調
  let successCallBack = { (task : URLSessionDataTask?, result : Any?) -> Void in
   completed(result as AnyObject?, nil)
  }
  // 2.封裝失敗的回調
  let failureCallBack = { (task : URLSessionDataTask?, error : Error?) -> Void in
   completed(nil, error as NSError?)
  }
  //判別是哪種懇求方式
  if methodType == .get {
   get(urlString, parameters: parameters, success: successCallBack, failure: failureCallBack)
  } else {
   post(urlString, parameters: parameters, success: successCallBack, failure: failureCallBack)
  }
 }

這裡的completed閉包被作為一個參數傳遞給request函數，並且在函數調用get或post後才會被調用。

運用閉包能夠惹起的循環強援用
Swift中不當的運用閉包能夠會惹起循環強援用，之所以稱之為“強”援用，是由於它會將實例堅持住，只需強援用還在，實例是不允許被銷毀的。循環強援用會不斷阻止類實例的釋放，這就在你的使用順序中形成了內存走漏。
舉個例子：

import UIKit
class ThirdViewController: UIViewController {
 var callBack: ((String) -> ())?
 override func viewDidLoad() {
  super.viewDidLoad()
  printString { (text) in
   print(text)
   //閉包中捕捉了self
   self.view.backgroundColor = UIColor.red
  }
 }
 func printString(callBack:@escaping (String) -> ()) {
  callBack("這個閉包前往一段文字")
  //控制器強援用於著callBack
  self.callBack = callBack
 }
 deinit {
  print("ThirdViewController---釋放了")
 }
}

當你在定義printString這個辦法時執行self.callBack = callBack代碼實踐上是self對callBack閉包停止了強援用，到這裡其實並沒有發生循環援用，但是當你在調用printString辦法的閉包外面又訪問了self.view.backgroundColor屬性，此時強援用就發作了，即self援用了callBack,而callBack外部又援用著self,誰都不情願松手，我們就說這兩者之間發生了循環強援用。

運用閉包何時會呈現循環強援用 ：

當你把一個閉包分配給類實例屬性的時分，並且這個閉包中又捕捉了這個實例。捕捉能夠發作於這個閉包函數體中訪問了實例的某個屬性，比方 self.someProperty ，或許這個閉包調用了一個實例的辦法，例如 self.someMethod() 。這兩種狀況都招致了閉包捕捉了self ，從而發生了循環強援用。

閉包循環援用的實質是：

閉包中循環強援用的發生，是由於閉包和類類似（還有一種兩個類實例之間的循環強援用），都是援用類型。當你把閉包賦值給了一個屬性，你實踐上是把一個援用賦值給了這個閉包。兩個強援用讓彼此不斷無效。

如何處理閉包的循環強援用：

方式一：相似於OC中運用__weak處理block的循環援用，Swift中支持運用weak關鍵字將類實例聲明為弱援用類型（留意，弱援用類型總是可選類型），打破類實例對閉包的強援用，當對象銷毀之後會自動置為nil，對nil停止任何操作不會有反響。

import UIKit
class ThirdViewController: UIViewController {
 var callBack: ((String) -> ())?
 override func viewDidLoad() {
  super.viewDidLoad()
  //將self聲明為弱援用類型，打破循環援用
  weak var weakSelf = self
  printString { (text) in
   print(text)
   //閉包中鋪捕捉了self
   weakSelf?.view.backgroundColor = UIColor.red
  }
 }
 func printString(callBack:@escaping (String) -> ()) {
  callBack("這個閉包前往一段文字")
  //控制器強援用於著callBack
  self.callBack = callBack
 }
 deinit {
  print("ThirdViewController---釋放了")
 }
}

方式二：作為第一種方式的簡化操作，我們可以在閉包的第一個大括號前面緊接著拔出這段代碼[weak self]，前面的代碼直接運用self？也能處理循環援用的問題。

import UIKit
class ThirdViewController: UIViewController {
  var callBack: ((String) -> ())?
  override func viewDidLoad() {
    super.viewDidLoad()
    printString {[weak self] (text) in
      print(text)
      self?.view.backgroundColor = UIColor.red
    }
  }
  func printString(callBack:@escaping (String) -> ()) {
    callBack("這個閉包前往一段文字")
    //控制器強援用於著callBack
    self.callBack = callBack
  }
  deinit {
    print("ThirdViewController---釋放了")
  }
}

方式三：在閉包和捕捉的實例總是相互援用並且總是同時釋放時，可以將閉包內的捕捉定義為無主援用unowned。

import UIKit
class ThirdViewController: UIViewController {
  var callBack: ((String) -> ())?
  override func viewDidLoad() {
    super.viewDidLoad()
    printString {[unowned self] (text) in
      print(text)
      self?.view.backgroundColor = UIColor.red
    }
  }
  func printString(callBack:@escaping (String) -> ()) {
    callBack("這個閉包前往一段文字")
    //控制器強援用於著callBack
    self.callBack = callBack
  }
  deinit {
    print("ThirdViewController---釋放了")
  }
}

留意：unowned是Swift中另外一種處理循環援用的聲明無主援用類型的關鍵字，相似於OC中的__unsafe_unretained；大家都知道__weak和__unsafe_unretained的相反點是可以將該關鍵字修飾的對象變成弱援用處理能夠存在的循環援用。不同點在於前者修飾的對象假如發現被銷毀，那麼指向該對象的指針會立刻指向nil，而__unsafe_unretained修飾的對象假如發現被銷毀，指向該對象的指針仍然指向原來的內存地址，假如此時持續訪問該對象很容易發生壞內存訪問/野指針/僵屍對象訪問。
異樣的道理Swift中也是一樣的。和弱援用相似，無主援用不會牢牢堅持住援用的實例。但是不像弱援用，總之，無主援用假定是永遠有值的。因而，無主援用總是被定義為非可選類型。你可以在聲明屬性或許變量時，在後面加上關鍵字unowned 表示這是一個無主援用。由於無主援用是非可選類型，你不需求在運用它的時分將它展開。無主援用總是可以直接訪問。不過 ARC 無法在實例被釋放後將無主援用設為 nil ，由於非可選類型的變量不允許被賦值為 nil 。假如此時持續訪問曾經被釋放實例很容易發生壞內存訪問/野指針/僵屍對象訪問。

所以Swift建議我們假如被捕捉的援用永遠不為 nil ，應該用unowned而不是weak，相反，假如你不確定閉包中捕捉的援用是不是存在為nil的能夠，你應該運用weak。

以上的代碼是依據最新的Swift3.0語法編寫的，經自己在Xcode8.0、iOS10.0環境下編譯經過。有任何疑問歡送在評論區留言，覺得大家的閱讀。