时间2020.9.10 环境 Mac10.15.6 Xcode11.6 (11E708)
1 闭包Closur
1-1.闭包作用
1.延迟后运行一些代码
2.动画结束后运行一些代码
3.下载完成后运行一些代码
4.当用户从菜单中选择一个可选项后运行一些代码
闭包能将一些功能封装在一个变量（var）中,然后将其存储在某个地方。
我们还可以从函数func中返回一个闭包，然后把它存在其他地方。
Swift让我们能够像使用String 和 Int 这些数据类型一样来使用function，比如将function指派给一个变量，甚至将它作为一个参数parameter，传递给另一个函数function。这种使用方法叫做闭包.(me:闭包相当于函数性质的数据类型)
1-2 闭包的创建和使用
环境 Mac10.15.6 Xcode11.6 (11E708)
@1、无参数，无返回值的闭包_____本质相当于 () -> Void 的形式
let driving = {
print("I am driving my car")
}
调用
driving()
========
@2、带参数，无返回值的闭包
let driving = { (place: String) in
print("I am driving to \(place) in my car")
}
调用
driving("London")
========
@3、带参数，有返回值的闭包
let drivingWithReturn = { (place: String) -> String in
return "I am going to \(place) in my car"
}
调用
let message = drivingWithReturn("London") //
print(message)
========
@4、无参数，有返回值的闭包
let payment = { () -> Bool in
print("Paying an anonymous person...")
return true
}
调用
let end = payment()
print(end)
=======
@5、@@无参数，无返回值闭包充当函数function的参数，即函数的参数类型为 闭包()-> Void
let driving = {
print("AAAA")
}
func travel(action: () -> Void) { //参数类型是 闭包类型 ()-> Void
print("BBBB")
print("CCCC")
action() //@@函数主图中的运行action()就相当于下文直接调用的driving()这个闭包, 相当于函数内使用了 @1 的用法
}
调用
driving() //调用闭包,输出 AAAA，调用同@1
travel(action: driving) //调用函数,传入闭包参数,输出BBBB CCCC AAAA
尾随闭包语法
### 尾随闭包语法 Trailing closure syntax
如果函数function的最后一个参数是闭包,那么在调用该函数function时,与其将闭包作为参数传递，不如在大括号内的函数之后直接传递它。
=======
@6,尾随闭包语法1,函数只有一个参数,且该参数为无参数.无返回值闭包(即,函数最后一个参数为闭包)
func travel(action: () -> Void) {
print("BBB")
print("CCC")
action() //关键
}
调用一
travel() {
print("AAA") //调用函数,直接将闭包传递,而不是把闭包当成参数后,以传统的函数方法使用,输出BBB CCC AAA
}
调用二 但闭包无参数时简化,尾随闭包语法可去掉(),进一步简化如下
trave{
print("AAA") //输出 BBB CCC AAA
}
//与@5对比,使用尾随闭包语法后,调用travel(XXX)函数时,就不要再传入一个闭包参数,而是变成直接闭包传入,使得同样想输出BBB CCC AAA,就少写了 let driving = { print("AAAA") } 闭包作为常量的定义表达
========
@7,尾随闭包语法举例2,函数有多个参数,最后一个参数为无参数.无返回值闭包
func animate(duration: Double, animations: () -> Void) {
print("Starting a \(duration) second animation…")
animations() //关键
}
调用一,未简化
animate(duration: 3, animations: { //调用函数,使用尾随闭包语法函数调用时直接传递闭包内容
print("Fade out the image")
})
调用二,简化,可删除尾随闭包的参数标签
animate(duration: 3) { //调用函数,
print("Fade out the image")
}
=======
@8,尾随闭包举例3,函数带单个参数,且最后一个参数为带参数,无返回值闭包
func travel(action: (String) -> Void) {
print("I'm getting ready to go.")
action("London") //闭包的直接调用,本质是@2
print("I arrived!")
}
调用,未简化
travel { (place: String) in //调用函数,尾随闭包调用方式,将带参数,无返回值闭包直接传入函数
print("I'm going to \(place) in my car")
}
@9,尾随闭包举例4,函数带单个参数,最后一个参数为带参数,有返回值的闭包
func travel(action: (String) -> String) {
print("I'm getting ready to go.")
let description = action("London") //闭包调用,本质同@3
print(description)
print("I arrived!")
}
调用,未简化
travel { (place: String) -> String in //调用函数,尾随闭包调用方式,
return "I'm going to \(place) in my car"
}
========
Swift的速记语法shorthand syntax和尾随闭包语法的结合
@10,尾随闭包的速记语法变形
尾随闭包举例5,函数带单个参数,最后一个参数为带参数,有返回值的闭包
func travel(action: (String) -> String) {
print("I'm getting ready to go.")
let description = action("London") //闭包调用
print(description)
print("I arrived!")
}
调用一,原始尾随闭包调用方式
travel { (place: String) -> String in //完整闭包
return "I'm going to \(place) in my car"
}
调用二,速记语法简化2
travel { place -> String in //简化闭包内参数类型
return "I'm going to \(place) in my car"
}
调用三,速记语法简化2
travel { place in //简化闭包参数类似,返回值类型
return "I'm going to \(place) in my car"
}
调用四,
travel { place in //简化闭包参数类型,返回值类型,return关键字
"I'm going to \(place) in my car"
}
调用五,
travel { //简化闭包参数,返回值类型,in, return关键字,且闭包参数用 $0 代替
"I'm going to \($0) in my car"
}字符串
======
@11,尾随闭包举例6,函数带n个参数,最后一个参数为带参数,有返回值的闭包
func travel(action: (String, Int) -> String) {
print("I'm getting ready to go.")
let description = action("London", 60)
print(description)
print("I arrived!")
}
调用
travel { //函数调用,尾随闭包速记语法形式,$0,$1可知闭包有2个参数,无print(),知道带返回值,且为返回字符串
"I'm going to \($0) at \($1) miles per hour."
}
=======
闭包作为函数function的返回值 (从函数中返回闭包)
@12,一个不带参数的函数,返回值类型是闭包
func travel() -> (String) -> Void {
return {
print("I'm going to \($0)") //用了尾随闭包速记语法,$0知,原始闭包带一个参数,由print()知,闭包无返回值
}
}
调用
let result = travel() //travel()函数返回的是带单参数无返回值的闭包,故result数据类型为闭包
result("London") //闭包的直接调用方式,同@2
=====
如果在闭包中使用外部值，则会捕获它们，以便闭包可以稍后引用它们
@13,从函数返回闭包的一个作用,用于在返回的闭包内捕捉特定可改变值
func travel() -> (String) -> Void {
var counter = 1
return {
print("\(counter). I'm going to \($0)")
counter += 1
}
}
调用,连续调用3次,问输出的内容
let result = travel()
result("London") //输出 1. I'm going to London
result("London") // 2. I'm going to London
result("London") // 3. I'm going to London
/
***************************************************************************
@6,暂时封存,不考虑@@有参数,无返回值闭包充当函数function的参数,即参数类型为
let driving = { (place: String) in
print("start \(place) end")
}
func travel(action: (String) -> Void) {
print("AAA")
print("BBB")
action("222") //相当于运行了 driving("22"),同@2
}
调用
dirving("111") //输出 start 111 end
travel(action: driving) //输出 AAA BBB start 222 end
网友评论