Swift闭包

原创 Laughing  2017-06-30 21:02  阅读 151 次 评论 0 条

闭包是引用类型

  1. let incrementByTen = makeIncrement(forincrement: 10)    
  2.     
  3. let incrementBySeven = makeIncrement(forincrement: 7)    
  4.     
  5. incrementByTen()    
  6.     
  7. incrementByTen()    
  8.     
  9. incrementByTen()    
  10.     
  11. let alsoIncrementByTen = incrementByTen    
  12.     
  13. alsoIncrementByTen()    
  14.     
  15. incrementBySeven()    
  16.     
  17. incrementBySeven()    

逃逸闭包

当一个闭包作为参数传到一个函数中,但是这个闭包在函数返回之后才被执行,我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时,你可以在参数名之前标注 @escaping

  1. //: Playground - noun: a place where people can play    
  2.     
  3. import UIKit    
  4.     
  5. /*   
  6.  一种使用逃逸闭包的方法是将闭包保存到函数外部定义的变量中   
  7.  */    
  8. var completionHandlers:[()->Void] = [] //d定义数组    
  9.     
  10. //定义逃逸闭包    
  11. func someFunctionWithEscapingClosure(completionHandler:@escaping()->Void){    
  12.     completionHandlers.append(completionHandler)    
  13. }    
  14.     
  15. //定义非逃逸闭包    
  16. func someFunctionWithoutEscapingClosure(completionHandler:()->Void){    
  17.     completionHandler()    
  18. }    
  19.     
  20. class SomeClass{    
  21.     var x = 10    
  22.     func doSomething(){    
  23.         someFunctionWithEscapingClosure {//逃逸闭包需要显示的引用self    
  24.             self.x = 100    
  25.         }    
  26.         someFunctionWithoutEscapingClosure {    
  27.             x = 200    
  28.         }    
  29.     }    
  30. }    
  31.     
  32. let instance = SomeClass()    
  33. instance.doSomething()    
  34. print(instance.x)//200    
  35. completionHandlers.first?()    
  36. print(instance.x)//100    

自动闭包

自动闭包是一种自动创建的闭包,用于包装传递给函数作为参数的表达式。

自动闭包不接受任何参数
  1. /*   
  2.  *   
  3.  *自动闭包是一种自动创建的闭包,用于包装传递给函数作为参数的表达式。   
  4.  *自动闭包不接受任何参数   
  5.  */    
  6.     
  7. var customersInLine = ["Chris","Alex","Ewa","Barry","Daneilla"]    
  8.     
  9. let customerPrivider = {customersInLine.remove(at: 0)}    
  10. print(customersInLine.count)    
  11.     
  12. print("Now serving \(customerPrivider())")    
  13.     
  14. print(customersInLine.count)    
  15.     
  16. /*   
  17.  *   
  18.  *   
  19.  *将闭包作为参数传递给函数时,能够获得延时求值效果   
  20.  *   
  21.  *   
  22.  */    
  23. func serve(customer customerProvider:()->String){    
  24.     print("Now serving \(customerPrivider())")    
  25. }    
  26.     
  27. serve(customer: {customersInLine.remove(at: 0)})    
  28.     
  29. /*   
  30.  *   
  31.  *   
  32.  *通过将参数标记为 @autoclosure 来接收一个自动闭包   
  33.  *   
  34.  *   
  35.  */    
  36. func serve(customer customerProvider:@autoclosure ()->String){    
  37.     print("Now serving \(customerPrivider())")    
  38. }    
  39.     
  40. serve(customer: customersInLine.remove(at: 0))    
本文地址:https://www.lisen.me/164.html
版权声明:本文为原创文章,版权归 木子网 所有,欢迎分享本文,转载请保留出处!

发表评论


表情