闭包引入
计算1个数的平方
函数写法
fun csquare(param:Int)->Int{
return param*param
}
square(param:3)
闭包写法
let squareCloure={
(param:Int)->Int in
return
param*param}squareCloure(3)
闭包含义
闭包是可以被传递和引用的一个独立模块
闭包能够捕获和存储定义在其上下文中的任何常量和变量，即闭合并包裹那些常量和变量，因此被称为“闭包”
闭包符合如下三种形式中的一种：
全局函数是一个有名字但不会捕获任何值的闭包
内嵌函数是一个有名字且能从其上层函数捕获值的闭包（函数中的嵌套函数知识点）
闭包表达式是一个轻量级语法，可以捕获其上下文中常量或变量值的没有名字的闭包
闭包和函数一样也是引用类型
简单案例
funcgetScore(score:[Int],con:(Int)->Bool) ->[Int]{
var newScre:[Int] = [Int]()
for item in score {
ifcon(item) {
newScre.append(item)
}
}
return newScre
}
//四种闭包书写方式
第一种简写: 省略 ->与返回类型(根据后面表达式可以推断返回值是一个Bool)
getScore(score: [65,75,85,95]) { (s:Int) ->Bool inreturns >80}
第二种简写:省略参数类型和括号(根据函数的参数可推断传进来的必然是Int)
getScore(score: [65,75,85,95]) { (s:Int)inreturns >80}
第三种简写:省略return关键字
getScore(score: [65,75,85,95]) { sinreturns >80}
第四种简写:参数名称缩写，省略参数声明和in，改为$0
getScore(score: [65,75,85,95]) { $0>80}
数组里面 有很多闭包 的方法
letarr = [65,75,85,95]
arr.filter({$0>80})
arr.forEach{ (s)in
print(s)
}
闭包可以从上下文环境中捕获常量、变量，并在自己的作用域内使用
Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数，嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0 func incrementor() -> Int {
runningTotal += amount
return runningTotal
}
return incrementor
}
let incrementByTen = makeIncrementor(forIncrement: 10)
// 返回的值为10
print(incrementByTen())
// 返回的值为20
print(incrementByTen())
// 返回的值为30
print(incrementByTen())
尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用
闭包是函数的最后一个参数
调用时，函数的)可以前置到倒数第二个参数末尾，后面的参数直接使用{ // 执行代码 }，形式参数标签也随之省略
将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性
//尾随闭包
func doSomething(info:String, clousre:(String)->Void){
clousre(info)
}
//不使用尾随闭包进行函数调用
doSomething(info:"Hello", clousre: { sinprint(s) })
//使用尾随闭包进行函数调用
doSomething(info:"World") { sin
print(s)
}
逃逸闭包
闭包作为一个参数传递给一个函数
传入函数的闭包如果在函数执行结束之后才会被调用，那么这个闭包就叫做逃逸闭包
声明一个接受闭包作为形式参数的函数时，可以在形式参数的类型之前写上@escaping来明确闭包是允许逃逸的
逃逸闭包会在函数结束后才执行
//逃逸闭包:闭包可以超出函数的范围来调用
//存放没有参数、没有返回值的闭包
var closureArray :[()->Void] = [()->Void]()
//定义一个函数，接收一个非逃逸闭包为参数
func nonEscapeClosure(closure:()->Void){
closure()
}
//定义一个函数，接收一个逃逸闭包为参数，将闭包并存储到一个数组里面去，并没有调用
func escapeClosure(closure:@escaping()->Void){
print("函数开始")
closureArray.append(closure)
print("函数结束")
}
var x = 10
//打印10
print(x)
nonEscapeClosure {
x = 100
}
//打印100 因为闭包在函数里面执行了
print(x)
escapeClosure {
x = 200
}
//打印100 因为闭包逃逸了 没有在函数里面执行
print(x)
closureArray.first?()
//打印200 在函数外面调用了闭包
print(x)
//尾随闭包常用于异步回调
自动闭包
一种自动创建的闭包，用于包装函数参数的表达式
不接受任何参数，被调用时会返回被包装在其中的表达式的值
在形式参数的类型之前加上@autoclosure关键字标识这是一个逃逸闭包
//自动闭包
func printIfTrue(predicate:@autoclosure()->Bool){
if predicate() {
print("is true")
}
else{
print("is false")
}
}
//直接进行调用了，Swift 将会把 2 > 1 这个表达式自动转换为 () -> Bool。这样我们就得到了一个写法简单、表意清楚的表达式。
printIfTrue(predicate: 2>1)
printIfTrue(predicate: 2<1)
闭包的循环引用
classNetworkTools:NSObject{
///完成回调属性
var finishedCallBack: (()->())?
///加载数据
///- parameter finished: 完成回调
func loadData(finished: () -> ()) {
self.finishedCallBack = finished
working()
}
func working() {
finishedCallBack?()
}
deinit{
print("网络工具 88")
}
class ViewController: UIViewController {
var tools:NetworkTools?
overridefuncviewDidLoad() {
super.viewDidLoad()
tools = NetworkTools()
tools?.loadData() {
print("加载数据完成,更新界面:", NSThread.currentThread())
weakSelf!.view.backgroundColor = UIColor.redColor()
}
}
/// 与 OC 中的 dealloc 类似，注意此函数没有()
deinit{
print("控制器 88")
}
}
Swift中解决循环引用的方式
方案一:
使用weak,对当前控制器使用弱引用
但是因为self可能有值也可能没有值,因此weakSelf是一个可选类型,在真正使用时可以对其强制解包(该处强制解包没有问题,因为控制器一定存在,否则无法调用所在函数)
// 解决方案一:
weakvarweakSelf =self
tools.loadData {
print("加载数据完成,更新界面:", NSThread.currentThread())
weakSelf!.view.backgroundColor = UIColor.redColor()
}
方案二:
和方案一类型,只是书写方式更加简单
可以写在闭包中,并且在闭包中用到的self都是弱引用
tools.loadData {[weakself] () -> ()in
print("加载数据完成,更新界面:", NSThread.currentThread())
self!.view.backgroundColor =UIColor.redColor()
}
方案三:
使用关键字unowned
从行为上来说 unowned 更像OC中的 unsafe_unretained
unowned 表示:即使它原来引用的对象被释放了，仍然会保持对被已经释放了的对象的一个"无效的"引用，它不能是 Optional 值，也不会被指向nil
tools.loadData {[unownedself] () -> ()in
print("加载数据完成,更新界面:", NSThread.currentThread())
self.view.backgroundColor =UIColor.redColor()
}