swift-闭包

import Foundation
/*
闭包 大致有三种形式
1.函数 有名  (全局函数)

2.闭包表达式 匿名 （相当于匿名函数） //和 OC 中的 block 类似

3.嵌套函数  （局部函数）在一个函数内部定义的新的函数
*/
//闭包类型 就是函数类型 或者 闭包表达式的类型

func myPrint(_: Void)->Void {//有名闭包 /全局函数
print("myPrint")
}
//1.定义一个闭包类型常量 保存有名闭包
//就是函数类型
let say:(Void)->Void = myPrint
//调用
say()

//2.闭包表达式 无名函数
let show:(Void)->Void = {
(Void)->Void in  //闭包的类型
print("无名闭包")
}
show()

//如果闭包是无参无返回值 那么里面的 (Void)->Void in可以省略不写
let show2:(Void)->Void = {
//(Void)->Void in    //无参无返回值 那么里面的 (Void)->Void in可以省略不写

print("无名闭包2")
}
show2()

//2.2带参数和返回值的匿名闭包（闭包表达式）

//把一个闭包表达式值赋给 add常量

//把一个闭包表达式值（匿名闭包） 给 myadd
let myadd:(Int,Int)->Int = {
(a:Int,b:Int)->Int in  //有参数的必须要写这个类型这样才能捕获参数
return a+b
}
//调用
let sum = myadd(1,2)
print("sum = \(sum)")

//闭包 应用于 回调 (和C语言的函数指针一样/OC block)

//下面 写一个 函数 实现对一个数组可以进行升序或者降序排列

//1.实现排序函数
//内部 不知道是升序还是降序 那么这个时候我们需要 传一个比较准则
//需要把一个比较代码传入 swift 可以通过闭包(可以传有名闭包(函数)或者匿名闭包(闭包表达式)) 把代码传入到函数中
//和C语言的函数指针类似

func mySorted(inout newArr:[Int],compare:(Int,Int)->Bool) {//对外部数组修改 用inout修饰
//冒泡
for var i = 0;i < newArr.count-1 ;i++ {
for var j = 0;j < newArr.count-1-i;j++ {
// 调用闭包compare(newArr[j],newArr[j+1])
if compare(newArr[j],newArr[j+1]) {
let tmp = newArr[j]
newArr[j] = newArr[j+1]
newArr[j+1] = tmp
}
}
}
}

//提供一个升序比较函数
//有名闭包
func asecCmp(a:Int,b:Int)->Bool {
return a > b
}

//提供一个降序比较函数
//有名闭包
func desecCmp(a:Int,b:Int)->Bool {
return a < b
}

//定义一个数组
var arr:[Int] = [10,2,100,29,4,20]

print(arr)

//调用排序函数 需要传入一个比较准则 比较代码/闭包
//升序
//下面传入的时候有名的闭包
mySorted(&arr, compare: asecCmp)//把函数名传入
print(arr)

//降序
mySorted(&arr, compare: desecCmp)//函数名传入
print(arr)

//传入匿名闭包
//升序
//传入一个闭包表达式
//方式1
//和OC 的block 类似
mySorted(&arr, compare: {
(a:Int,b:Int)->Bool in
return a > b
})
//方式2
//还可以先把闭包表达式的值给一个闭包变量或者闭包常量
let xxx:(Int,Int)->Bool = {
(a:Int,b:Int)->Bool in
return a > b
}
mySorted(&arr, compare: xxx)

print(arr)

<span style="font-size:24px;">嵌套函数</span>
import Foundation

//实现一个交换函数
//全局函数
func mySwap(inout a:Int,inout b:Int) {
let tmp = a
a = b
b = tmp
}

//1.实现排序函数
//内部 不知道是升序还是降序 那么这个时候我们需要 传一个比较准则
//需要把一个比较代码传入 swift 可以通过闭包(可以传有名闭包(函数)或者匿名闭包(闭包表达式)) 把代码传入到函数中
//和C语言的函数指针类似

func mySorted(inout newArr:[Int],compare:(Int,Int)->Bool) {//对外部数组修改 用inout修饰

//定义一个嵌套函数  在函数里面定义 可以在函数内部调用
func mySwap2(inout a:Int,inout b:Int) {
let tmp = a
a = b
b = tmp
}

//冒泡
for var i = 0;i < newArr.count-1 ;i++ {
for var j = 0;j < newArr.count-1-i;j++ {
// 调用闭包compare(newArr[j],newArr[j+1])
if compare(newArr[j],newArr[j+1]) {
//调用一个函数 交换函数
//mySwap(&newArr[j], &newArr[j+1])//全局函数

//我们可以定义一个嵌套函数 实现交换
//交换函数实际上只在排序方法中调用 那么实际上我们可以把这个交换函数 定义在 mySorted函数内部就可以了，那么这就是嵌套函数（在一个函数内部定义另外一个函数）
mySwap2(&newArr[j], b: &newArr[j+1])

}
}
}
}

//定义一个数组
var arr:[Int] = [10,2,100,29,4,20]

print(arr)

//传入匿名闭包
//升序
//传入一个闭包表达式
//方式1
//和OC 的block 类似
mySorted(&arr, compare: {
(a:Int,b:Int)->Bool in
return a > b
})

print(arr)

//  main.swift
//  Swift_嵌套函数语法

import Foundation

func test() {
var cnt:Int = 0

//嵌套函数
func inTest() {
cnt++ //  嵌套函数 可以使用上面函数的变量
// 内部的真实操作 是在嵌套函数中会临时拷贝一份cnt 操作嵌套函数的中这个cnt 同时会操作外面的cnt
print("inTest_cnt = \(cnt)")
}
print("test_cnt = \(cnt)")//0
inTest()//调用嵌套函数 //1
print("test_cnt2 = \(cnt)")//1

}
test()

//实现一个函数 返回一个闭包 (Int)->Int

func getFunc() ->   (Int)->Int {
var cnt:Int = 0

//实现一个嵌套函数
func inFunc(num:Int)->Int {
cnt++ //每次调用inFunc 实际上这里inFunc 会重新拷贝一份cnt 在堆段或者数据段  操作的inFunc里面的 会同时操作外面的
print("inFunc_cnt = \(cnt)")
return num * 1000
}

return inFunc //返回一个函数/就是返回一个闭包
//这样外面的函数也可以调用这个内部的嵌套函数
}

//方式1 调用内部的嵌套函数
var n = getFunc()(10)
print("n = \(n)")

n = getFunc()(10)
print("n = \(n)")
//上面 每调用一次getFunc 会重新创建新的局部变量cnt 初始值就是 0

//方式2

var myFunc = getFunc() //把getFunc()的返回值给myFunc
//getFunc 返回值就是一个闭包  myFunc 就是getFunc里面返回的闭包

var m = myFunc(10)
print("m = \(m)")

m = myFunc(10)
print("m = \(m)")
//上面的myFunc 操作的是同一个cnt