closures是什么意思sures在线翻译读音例

Swift闭包（Closures）

我的博客

1、What\'stheclosure?

作为

iOS

开发者对于

Objective-C

中的

Block

⼀定⾮常熟悉，在其他开发语⾔中，也把

closure

也称作

lambdas

等。简答来说，闭包就是⼀个独⽴的

函数，⼀般⽤于捕获和存储定义在其上下⽂中的任何常量和变量的引⽤。

closure

的语法如下：

{(parameters)->returntypein

statements

}

closure

能够使⽤常量形式参数、变量形式参数和输⼊输出形式的参数，但不能设置默认值。可变形式参数也可以使⽤，但需要在⾏参列表的最后

使⽤。元组也可以被⽤来作为形式参数和返回类型。

实际上全局函数和内嵌函数也是⼀种特殊的闭包，（关于函数的相关概念可参考官⽅⽂档TheSwiftProgrammingLanguage:Functions），

闭包会根据其捕获值的情况分为三种形式：

全局函数是⼀个有名字但不会捕获任何值的闭包

内嵌函数是⼀个有名字且能从其上层函数捕获值的闭包

闭包表达式是⼀个轻量级语法所写的可以捕获其上下⽂中常量或变量值的没有名字的闭包

2、各种不同类型的闭包

如果需要将⼀个很长的闭包表达式作为函数最后⼀个实际参数传递给函数，使⽤尾随闭包将增强函数的可读性。尾随闭包⼀般作为函数⾏参使⽤。

如系统提供的

sorted

,

map

等函数就是⼀个尾随闭包。

2.1、尾随闭包（TrailingClosure）

尾随闭包虽然写在函数调⽤的括号之后，但仍是函数的参数。使⽤尾随闭包是，不要将闭包的参数标签作为函数调⽤的⼀部分。

letstrList=[\"1\",\"2\",\"3\",\"4\",\"5\"]

letnumList:[Int]={(num)in

returnInt(num)??0

}

2.2、逃逸闭包（EscapingClosure）

当闭包作为⼀个实际参数传递给⼀个函数的时候，并且它会在函数返回之后调⽤，我们就说这个闭包逃逸，⼀般⽤

@escaping

修饰的函数形式参数

来标明逃逸闭包。

逃逸闭包⼀般⽤于异步任务的回调万壑松风图

逃逸闭包在函数返回之后调⽤

让闭包

@escaping

意味着必须在闭包中显式地引⽤self

//逃逸闭包

funcrequestServer(withURL:String,parameter:@escaping(AnyObject?,Er湖心亭看雪写作背景 ror?)->Void){

}

//尾随闭包

funcrequestServerTrailing(losure:()->Void){

}

classEscapingTest{

varx=10

funcrequest(){

//尾随闭包

requestServerTrailing{

x=x+1

}

//逃逸闭包

requestServer(with:\"\"){(obj,error)in

x=x+1

}

}

}

Referencetoproperty\'x\'inclosurerequiresexplicituseof\'self\'tomakecapturesemanticsexplicit

修改代码：

requestServer(with:\"\"){[weakself](obj,error)in

guardletself=`self`else{

return

}

self.x=self.x+1

}

逃逸闭包的实际使⽤

如我要设计⼀个下载图⽚管理类，异步下载图⽚下载完成后再返回主界⾯显⽰，这⾥就可以使⽤逃逸闭包来实现，核⼼代码如下：

structDownLoadImageManager{

//单例

staticletsharedInstance=DownLoadImageManager()

letqueue=DispatchQueue(label:\"ngClosure\",attributes:.concurrent)

//逃逸闭包

//pat畦怎么读 h:图⽚的URL

funcdownLoadImageWithEscapingClosure(path:String,completionHandler:@escaping(UIImage?,Error?)->Void){

{

sk(with:URL(string:path)!){(data,response,error)in

ifleterror=error{

print(\"error===============(error)\")

{

completionHandler(nil,error)

}

}else{

guardletresponseData=data,letimage=UIImage(data:responseData)else{

return

}

{

completionHandler(image,nil)

}

}

}.resume()

}

}

//保证init⽅法在外部不会被调⽤

privateinit(){

}

}

下载图⽚并显⽰：

letpath=\"/image_search/src=http%3A%2F%%2Fnewsapp_match%2F0%2F%&refer=http%3A%2F%

adImageWithEscapingClosure(path:path){(image:UIImage?,error:Error?)in

ifleterror=error{

print(\"error===============(error)\")

}else{

guardletimage=imageelse{return}

print(\"图⽚下载完成，显⽰图⽚:(image)\")

letimageView=UIImageView(image:image)

Radius=5

}

}

下载图⽚

以上的代码虽然能够完成对图⽚的下载管理，事实上在项⽬中下载并显⽰⼀张图⽚的处理要复杂的多，这⾥不做更多赘述，可参考官⽅的demo:

AsynchronouslyLoadingImagesintoTableandCollectionViews

2.3、⾃动闭包（AutoClosure）

⾃动闭包是⼀种⾃动创建的⽤来把座位实际参数传递给函数的表达式打包的闭包

⾃动闭包不接受任何参数，并且被调⽤时，会返回内部打包的表达式的值

⾃动闭包能过省略闭包的⼤括号，⽤⼀个普通的表达式来代替显式的闭包

⾃动闭包允许延迟处理，因此闭包内部的代码直到调⽤时才会运⾏。对于有副作⽤我未成名卿未嫁 或者占⽤资源的代码来说很⽤

如我有个家庭作业管理类，⽼师需要统计学⽣上交的作业同时处理批改后的作业，为了演⽰⾃动闭包，我⽤以下的代码来实现：

enumCourse{

casespacePhysics//空间物理

casenuclearPhysics//原⼦核物理

casecalculus//微积分

casequantumMechanics//量⼦⼒学

casegeology//地质学

}

structStudentModel{

varname:String=String()

varcourse:Course!

init(name:String,course:Course){

=name

=course

}

}

//MARK:-⾃动闭包

classStudentManager{

varstudentInfoArray:[StudentModel]=[StudentModel]()

//某个学⽣交了作业

funcautoAddWith(_student:@autoclosure()->StudentModel){

(student())

}

//⽼师批改完了某个学⽣的作业

funcautoDeleteWith(_index:@autoclosure()->Int){

(at:index())

}

}

其中，

autoAddWith

表⽰学⽣某个学⽣交了作业，

autoDeleteWith

表⽰⽼师批改完了某个学⽣的作业。⼀般调⽤⽅式为：

letstudentManager:StudentManager=StudentManager()

//KateBell交了作业

dWith(StudentModel(name:\"KateBell\",course:.spacePhysics))

//KateBell交了作业

dWith(StudentModel(name:\"KateBell\",course:.nuclearPhysics))

//AnnaHaro交了作业

dWith(StudentModel(name:\"AnnaHaro\",course:.calculus))

//⽼师批改完了第⼀份作业

leteWith(0)

2.4、⾃动+逃逸（Autoclosure+Escaping）

如果想要⾃动闭包逃逸，可以同时使⽤

@autoclosure

和

@escaping

来标志。

funcautoAddWith(_student:@autoclosure@escaping()->StudentModel){

(student())

}

3、闭包捕获值

前⾯简单介绍了尾随闭包、逃逸闭包、⾃动闭包的概念和基本使⽤，这⾥来说闭包是如何捕获值的。在Swift中，值类型变量⼀般存储于栈

（Stack）中，⽽像

funcclassclosure

等引⽤类型存储于堆(Heap)内存中。⽽

closure

捕获值本质上是将存在栈(Stack)区的值存储到堆(Heap)区。

为了验证

closure

可以捕获哪些类型的值，⽤下⾯的代码做⼀个测试：

classDemo:NSObject{

vartest=String()

}

//常量

letindex=10086

//变量

varnumber=1008611

//引⽤类型

letdemo=Demo()

varcapturel={

number=1008611-998525

=\"blocktest\"

print(\"index==========(index)\")

print(\"number==========(number)\")

print(\"==========()\")

}

number=number+1

=\"test\"

capturel()

//打印结果

//index==========10086

//number==========10086

//==========blocktest

上⾯的代码中，⽆论是常量、变量、还是引⽤类型调⽤

capturel()

后都可以正常打印数据。⽆论是常量、变量、值类型还是引⽤类型，

Closure

都

可捕获其值。事实上在Swift中作为优化当

Closure

中并没有修改或者在闭包的外⾯的值时，Swift可能会使⽤这个值的copy⽽不是捕获。同时

Swift也处理了变量的内存管理操作，当变量不再需要时会被释放。

在来看⼀个实现递增的例⼦：

funcmakeIncrementer(_amount:Int)->()->Int{

vartotal=0

//内嵌函数也是⼀种特殊的Closure

funcincrementerClosure()->Int{

total=total+amount

returntotal

}

returnincrementerClosure

}

在上⾯的代码中,

incrementerClosure

中捕获了

total

值，当我返回

incrementerClosure

时，理论上包裹

total

的函数就不存在了，但

是

incrementerClosure

仍然可以捕获

total

值。可以得出结论：即使定义这些变量或常量的原作⽤域已经不存在了，但

closure

依旧能捕获这个值。

letincrementerTen=makeIncrementer(10)//()->Int

incrementerTen()//10

incrementerTen()//20

incrementerTen()//30

letincrementerSix=makeIncrementer(6)//()->Int

incrementerSix()//6

incrementerSix()//12

incrementerTen()//40

letalsoIncrementerTen=incrementerTen//()->Int

alsoIncrementerTen()//50

在上⾯的代码中，调⽤了递增闭包

incrementerTen

每次+10，当我新建⼀个

incrementerSix

闭包时就变成了+6递增，也就说产⽣了⼀个新的变量引

⽤。

当调⽤

alsoIncrementerTen

后，返回的值是50，这⾥可以确定

Closure

是引⽤类型,是因为

alsoIncrementerTen

引⽤了

incrementerTen

他们共享同⼀个

内存。如果是值类型，

alsoIncrementerTen

返回的结果会是10,⽽不是50；

根据上⾯的代码关于闭包捕获值做出总结：

closure

捕获值本质上是将存在栈(Stack)区的值存储到堆(Heap)区

当

Closure

中并没有修改或者在闭包的外⾯的值时，Swift可能会使⽤这个值的copy⽽不是捕获

Closure

捕获值时即使定义这些变量或常量的原作⽤域已经不存在了

closure

依旧能捕获这个值

如果建⽴了⼀个新的闭包调⽤，将会产⽣⼀个新的独⽴的变量的引⽤

⽆论什么时候赋值⼀个函数或者闭包给常量或变量，实际上都是将常量和变量设置为对函数和闭包的引⽤

4、Closure循环引⽤

Swift中的

closure

是引⽤类型,我们知道Swift中的引⽤类型是通过

ARC

机制来管理其内存的。在Swift中，两个引⽤对象互相持有对⽅时回产⽣强

引⽤环，也就是常说的循环引⽤。虽然在默认情况下，Swift能够处理所有关于捕获的内存的管理的操作，但这并不能让开发者⼀劳永逸的不去关

⼼内存问题，因为相对于对象产⽣的循环引⽤

Closure

产⽣循环引⽤的情况更复杂，所以在使⽤

Closure

时应该更⼩⼼谨慎。那么在使⽤

Closure鲁山山行 梅尧臣

时

⼀般哪些情况会产⽣循环引⽤问题呢？

4.1、Closure捕获对象产⽣的循环引⽤

当分配了⼀个

Closure

给实例的属性，并且

Closure

通过引⽤该实例或者实例的成员来捕获实例，将会在

Closure

和实例之间产⽣循环引⽤。

这⾥我⽤学⽣

Student

类来做演⽰,假设现在学⽣需要做⼀个单项选择题，⽼师根据其返回的答案来判断是否正确。我将对照

Objective-C

中

的

Block

来做⼀个对⽐,在Xcode中编写如下代码：

typedefNS_ENUM(NSInteger,AnswerEnum){

A,

B,

C,

D,

};

@interfaceStudent:NSObject

@property(copy,nonatomic)NSString*name;

@property(copy,nonatomic)void(^replyClosure)(AnswerEnumanswer);

@end

@implementationStudent

-(instancetype)init{

self=[superinit];

if(self){

if(losure){

losure(B);

}

}

returnself;

}

@end

@interfaceTeacher:NSObject

@property(assign,nonatomic)BOOLisRight;

@property(strong,nonatomic)Student*student;

@end

@implementationTeacher

-(instancetype)init{

self=[superinit];

if(self){

losure=^(AnswerEnumanswer){

//Capturing\'self\'stronglyinthisblockislikelytoleadtoaretaincycle

NSLog(@\"%@\",);

};

}

returnself;

}

@end

其实上⾯的代码，不⽤运⾏在Build的时候就会警告

Capturing\'self\'stronglyinthisblockislikelytoleadtoaretaincycle

。

那么在Swift中使⽤

closure

是否同样也会产⽣循环引⽤呢？我把

Objective-C

代码转换成

Swift

：

enumAnswer{

caseA

caseB

caseC

caseD

}

classStudent:CustomStringConvertible{

varname:String=String()

varreplyClosure:(Answer)->Void={_in}

vardescription:String{

return\"\"

}

init(name:String){

=name

print(\"==========Studentinit==========(name)\")

replyClosure(.B)

}

deinit{

print(\"==========Studentdeinit==========()\")

}

}

classTeacher{

varisRight:Bool=false

init(){

print(\"==========Teacherinit==========\")

letstudent=Student(name:\"KateBell\")

letjudgeClosure={(answer:Answer)in

print(\"()is(answer)\")

}

losure=judgeClosure

}

deinit{

print(\"==========Teacherdeinit==========\")

}

}

Student

类有两个属性：

name

表⽰学⽣姓名，

replyClosure

表⽰学⽣回答问题这⼀动作并返回答题结果。

//调⽤并运⾏代码

Teacher()

//打印结果

==========Teacherinit==========

==========Studentinit==========KateBell

==========Teacherdeinit==========

运⾏上⾯的代码，通过打印结果可以看到

Student

类并没有调⽤

deinit

⽅法，此处说明

Student

在被初始化后内存并没有释放。实际上

在

judgeClosure

内部，只李白的行路难全诗 要我调⽤(捕获)了

student

，⽆论是任何操作,该部分内存都不能有效释放了。那么为什么会造成这种现象呢？下⾯做逐步

分析：

当我调⽤了闭包之后，闭包才会捕获值，在执⾏

losure=judgeClosure

之后，在内存中他们的关系是这样的：

在Swift中，

class、func、closure

都是引⽤类型，因此在上⾯的代码中，

student

和

judgeClosure

都指向各种对象的

strongreference

。

同时由于在闭包中捕获了

student

,因此

judgeClosure

闭包就有了⼀个指向

student

的强引⽤。最后当执⾏

losure=judgeClosure

之后，

让

replyClosure

也成了

judgeClosure

的强引⽤。此时

student

的引⽤计数为1，

judgeClosure

的引⽤计数是2。

当超过作⽤域后，

student

和

judgeClosure

之间的引⽤关系是这样的：

此时，只有

Closure

对象的引⽤计数变成了1。于是

Closure

继续引⽤了

student

，

student

继续引⽤了他的对象

replyClosure

，⽽这个对象继续引

⽤着

judgeClosure

。这样就造成了⼀个引⽤循环，所以就会出现内存⽆法正常释放的情况。

4.2、closure属性的内部实现捕获self产⽣的循环引⽤

同样的这⾥我先利⽤

Objective-C

的代码来举例，修改

Student

类的代码如下：

@implementationStudent

-(instancetype)init{

self=[superinit];

if(self){

if(losure){

losure=^(AnswerEnumanswer){

//Capturing\'self\'stronglyinthisblockislikelytoleadtoaretaincycle

NSLog(@\"%@\",self);

};

}

}

returnself;

}

@end

同样的在Build时编译器会警告，

Capturing\'self\'stronglyinthisblockislikelytoleadtoaretaincycle

。

在Swift中虽然编译器不会警告，但也会产⽣同样产⽣循环引⽤问题。修改

Student

中定义

replyClosure

代码如下：

lazyvarreplyClosure:(Answer)->Void={_in

print(\"replyClosureself=============(self)\")

}

为了保证在

replyClosure

内部调⽤

self

时

replyClosure

闭包已经正确初始化了，所以采⽤了

lazy

懒加载的⽅式。修改调⽤的代码为：

Student(name:\"Tom\").replyClosure(.B)

运⾏代码，打印结果：

==========Studentinit==========KateBell

replyClosureself=============

由于

Student

实例和

replyClosure

是互相强持有关系，即使超出了作⽤域他们之间依然存在着引⽤，所以内存不能有效释放。此时他们之间的引⽤

关系是：

在

Objective-C

中⼀般采⽤弱引⽤的⽅式解决

Block

和实例循环引⽤的问题，这⾥对

Block

和类实例之间产⽣循环引⽤的原因不做赘述，关

于

Objective-C

中

Block

的更多使⽤细节可查阅Objective-C⾼级编程:iOS与OSX多线程和内存管理⼀书和苹果官⽅⽂档GettingStartedwith

Blocks的内容。那么在Swift中该如何处理循环引⽤呢？在Swift中需要根据

closure

和

class

对象⽣命周期的不同，⽽采⽤不同的⽅案来解决循环

引⽤问题。

5、⽆主引⽤（unowned）

5.1、使⽤unowned处理closure和类对象的引⽤循环

为了更易理解，我修改

Teacher

类的代码：

classTeacher{

varisRight:Bool=false

init(){

print(\"==========Teacherinit==========\")

letstudent=Student(name:\"KateBell\")

letjudgeClosure={[student](answer:Answer)in

print(\"student===========(student)\")

}

losure=judgeClosure

}

deinit{

print(\"==========Teacherdeinit==========\")

}

}

这⾥只考虑

student

和

teacher

之间的引⽤关系，此时student

和

closure`之间存在着强引⽤关系，他们的引⽤计数都是2，在内存中他们之间的

引⽤关系为：

超过作⽤域后，由于互相存在强引⽤

student

和

clousre

的引⽤计数并不为0，所以内存⽆法销毁，此时他们之间的引⽤关系为：

对于这种引⽤关系在前⾯的ARC就已经说过，把循环的任意⼀⽅变成

unowned

或

weak

就好了。我将

student

设置为⽆主引⽤，代码如下：

letjudgeClosure={[unownedstudent](answer:Answer)in

print(\"()is(answer)\")

}

使⽤⽆主引⽤后，他们之间的引⽤关系如下图所⽰：

运⾏代码并打印：

//运⾏

Teacher()

//打印结果

==========Teacherinit==========

==========Studentinit==========KateBell

==========Studentdeinit==========KateBell

==========Teacherdeinit==========

可以看到

student

和

teacher

都可以正常被回收了，说明

closure

的内存也被回收了。当

closure

为

nil

时，

student

对象就会被

ARC

回收，⽽

当

student

为

nil

时，

teacher

也就失去了他的作⽤会被ARC回收其内存。

5.2、unowned并不能解决所有的循环引⽤问题

虽然

unowned

能解决循环引⽤问题，但并不意味着，遇到的所有

closure

循环引⽤问题都可以⽤⽆主引⽤（unowned）来解决:

5.2.1、⽰例代码⼀

同样⽤

Student

对象来举例，在\"KateBell\"学⽣回答完问题后，另⼀个

Tom

⼜回答了问题，他选择了C答案，代码如下：

varstudent=Student(name:\"KateBell\")

letjudgeClosure={[unownedstudent](answer:Answer)in

print(\"student===========(student)\")

}

student=Student(name:\"Tom\")

losure=judgeClosure

losure(.C)

//打印结果

//==========Studentinit==========KateBell

//==========Studentinit==========Tom

//==========Studentdeinit==========KateBell

运⾏代码，程序会Crash并报错，

error:Executionwasinterrupted,reason:signalSIGABRT.

来分析⼀下为什么会这样：

代码中⾸先创建了⼀个名为

KateBell

的学⽣对象，

judgeClosure

捕获了这个

student

对象

当

student=Student(name:\"Tom\")

之后，由于

judgeClosure

是按照

unowned

的⽅式捕获的，此时

judgeClosure

内的

student

对象实际上已经不存了

名为

Tom

的

student

对象引⽤了

replyClosure

闭包

调⽤

losure(.C)

的时候，

replyClosure

之前捕获的

student

对象已经不存在，此时就产⽣了Crash

5.2.1、⽰例代码⼆

那么，如果我将

losure=judgeClosure

移动到最前⾯呢？修改代码如下：

varstudent=Student(name:\"KateBell\")

letjudgeClosure={[unownedstudent](answer:Answer)in

print(\"student===========(student)\")

}

losure=judgeClosure

student=Student(name:\"Tom\")

losure(.C)

//打印结果

//==========Studentinit==========KateBell

//==========Studentinit==========Tom

//==========Studentdeinit==========KateBell

可以看到，名为

\"KateBell\"

的

student

对象正常销毁了，但是

Tom

学⽣对象并没有正常销毁，这是由于

replyClosure

闭包在其内部捕获了

self

造成的

循环引⽤。此时他们之间的引⽤关系为：

对于这种情况使⽤

unowned

并不能解决循环引⽤问题，所以只能采⽤另⼀种解决循环引⽤的⽅案弱引⽤(weak),来告诉

closure

当

closure

所捕获的

对象已经被释放时，就不⽤在访问这个对象了。

6、弱引⽤（weak）

6.1、使⽤weak处理closure和类对象之间的引⽤循环

为了解决上⾯的的循环引⽤问题，我把

replyClosure

的代码修改为：

lazyvarreplyClosure:(Answer)->Void={[weakself]_in

print(\"replyClosureself=============(self)\")

}

重新执⾏代码，可以看到

Tom

学⽣对象可以正常释放了：

//==========Studentinit==========KateBell

//==========Studentinit==========Tom

//==========Studentdeinit==========KateBell

//==========Studentdeinit==========Tom

让

self

为弱引⽤后，

student

之间的引⽤关系是：

当我使⽤了

weak

时，就意味这这个对象可能为

nil

,⽽在

closure

⾥捕获和使⽤⼀个

Optional

的值可能会发⽣⼀些不可预期的问题，此处需要

做

unwrap

操作：

lazyvarreplyClosure孤城遥望玉门关的前一句 :(Answer)->Void={[weakself]_in

guardletvalue=selfelse{return}

print(\"replyClosureself=============(value)\")

}

当离开作⽤域后，

student

和

closure

的引⽤计数都为0，他们的内存就会合理的释放，他们之间的引⽤关系如下图所⽰：

关于

closure

和类对象之间的循环问题，如何判断两者之间是否会产⽣循环引⽤，要根据⼀个类对象是否真的拥有正在使⽤的

closure

。如果类对象

没有持有这个

closure

，那么就不必考虑循环引⽤问题。

6.2、weak并不能解决所有的循环引⽤问题

虽然

unowned

和

weak

能够解决

Closure

和类实例之间的循环引⽤问题，但这并不表⽰在任何

Closure

中都可以使⽤这种⽅案来解决问题。相反有

时候滥⽤弱引⽤还会给带来⼀些诡异的⿇烦和内存问题。

6.2.1、滥⽤弱引⽤可能会造成⼀些不必要的⿇烦

这⾥我同样⽤

Student

类来举例，为学⽣添加⼀个写作业的任务：

funcdoHomeWork(){

//全局队列

letqueue=()

{[weakself]in

print(\"(self?.name):开始写作业\")

sleep(2)

print(\"(self?.name):完成作业\")

}

}

//模拟做家庭作业

Student(name:\"KateBell\").doHomeWork()

打印结果：

==========Studentinit==========

==========Studentdeinit==========

Optional(\"KateBell\"):开始写作业

nil:完成作业

为什么完成的作业是

nil

呢？实际上这⾥并不需要使⽤弱引⽤，因为

async

⽅法中使⽤的

closure

并不归

student

对象持有，虽然

closure

会捕

获

student

对象，但这两者之间并不会产⽣循环引⽤，反⽽因为弱引⽤的问题学⽣对象被提前释放了，但是如果这⾥我使⽤了强制拆包就⼜可能导

致程序Crash。所以正确的理解

closure

和类对象的引⽤关系并合理的使⽤

weak

和

unowned

才能从本质上解决问题。

6.2.2、使⽤withExtendedLifetime改进这个问题

那么有没有⽅法可以避免在错误的使⽤了

weak

之后造成的问题呢？这⾥可以使⽤Swift提供的

withExtendedLifetime

函数，它有两个参数：第⼀个

参数是要延长⽣命的对象，第⼆个对象是

clousre

，在这个

closure

返回之前，第⼀个参数会⼀直存活在内存中，修改

asyncclosure

⾥的代码如下：

letqueue书林文学 =()

{[weakself]in

withExtendedLifetime(self){

print(\"(self?.name):开始写作业\")

sleep(2)

print(\"(self?.name):完成作业\")

}

}

重新编译代码，打印结果：

==========Studentinit==========

Optional(\"KateBell\"):开始写作业

Optional(\"KateBell\"):完成作业

==========Studentdeinit==========

6.2.3、改进withExtendedLifetime语法

虽然

withExtendedLifetime

能过解决弱引⽤问题，如果有很多地⽅有要这样访问对象这样就很⿇烦。这⾥有⼀个解决⽅案是对

withExtendedLifetime

做

⼀个封装，,给

Optional

做⼀个扩展（extension）处理:

extensionOptional{

funcwithExtendedLifetime(_body:(Wrapped)->Void){

guardletvalue=selfelse{return}

body(value)

}

}

调⽤的代码：

funcdoHomeWork(){

//全局队列

letqueue=()

{[weakself]in

tendedLifetime{_in

print(\"(self?.name):开始写作业\")

sleep(2)

print(\"(self?.name):完成作业\")

}

}

}

最终打印的结果和之前⼀样，并且我还可以其他地⽅调⽤：

==========Studentinit==========

Optional(\"KateBell\"):开始写作业

Optional(\"KateBell\"):完成作业

==========Studentdeinit==========

本⽂主要介绍了

closure

基本概念、

closure

的类型、

closure

和类对象之间的内存问题及其解决⽅法，如果您发现我的理解有错误的地⽅，请指

出。

本⽂参考：

TheSwiftProgrammingLanguage:Closures

TheSwiftProgrammingLanguage:AutomaticReferenceCounting

容易让⼈犯错的closure内存管理

本⽂demo