Swift六&七 一: 函数定义在结构体, 类, 枚举中 二:

一: 函数定义在结构体, 类, 枚举中
二: 闭包表达式
三: 闭包

一: 函数定义在结构体, 类, 枚举中

枚举定义在结构体内部

截屏2022-04-15 下午6.50.57.png

结构体 枚举 类
1 func声明的都为对象方法 枚举呢case调用
2 方法不占用用对象内存, 是放在代码段调用的

截屏2022-04-15 下午7.07.03.png

二: 闭包表达式

用处: 函数作为参数, 可以传入闭包表达式
语法
{(参数列表) -> 返回值 in
函数体
}
1 通过闭包定义个函数

截屏2022-04-15 下午7.36.21.png

2 闭包表达式简写
方法有个带函数的参数, 可以传个闭包表达式, 还能简写

截屏2022-04-15 下午7.38.10.png

3 尾随闭包
就是一种优化的简洁写法, 方法最后一个参数是函数, 可以使用尾随闭包书写

截屏2022-04-15 下午7.56.10.png

 /*
        定义个函数
        参数1: v1
        参数2: v2
        参数3: 函数 入参两个Int 返回Int
        返回值: Int
        */
      // 定义个闭包类型& 函数类型
        typealias addBlock = (Int, Int)->Int

        func exec(v1: Int, v2: Int, fn: (Int, Int)-> Int) -> Int{
            fn(v1,v2)
        }
    
        // 正常调用
        func sumFunc(v1: Int, v2: Int) -> Int {
               v1 + v2
        }
        let sum: (Int, Int) -> Int = sumFunc(v1:v2:)  // 定义函数类型变量
        let k = exec(v1: 1, v2: 2, fn: sum)
        let k1 = exec(v1: 1, v2: 2, fn: sumFunc(v1:v2:)) // 直传变量类型
        let sum1: addBlock = sumFunc(v1:v2:) // 别名
        let k2 = exec(v1: 1, v2: 2, fn: sum1)
        
        // 闭包调用
        let sum1 = {(v1: Int, v2: Int) in
            v1 + v2
        }
        let a = exec(v1: 1, v2: 2, fn: sum1)
        print("--闭包调用\(a)")
        
        // 尾随闭包
        let b = exec(v1: 1, v2: 2){(v1: Int, v2: Int) in
            v1 + v2
        }
        print("尾随闭包\(b)")
        
        let c = exec(v1: 1, v2: 2){$0 + $1}
        print("尾随闭包简写\(c)")

4 闭包应用 数组 排序

截屏2022-04-15 下午8.37.27.png

5 忽略函数
_ 用来占位, 忽略变量

截屏2022-04-15 下午8.40.19.png
{1} 用来简写函数体
截屏2022-04-15 下午8.42.53.png

三: 闭包

截屏2022-04-19 下午3.44.39.png
截屏2022-04-20 下午1.08.10.png

为什么局部变量num会累加
因为返回plus函数前, 把num局部变量拷贝到堆空间了

函数内存
// 占用16个字节 前8存放函数内存地址 后8个存放0(未使用)

截屏2022-04-25 下午3.15.47.png
截屏2022-04-25 下午3.35.11.png
截屏2022-04-25 下午3.39.26.png

var fn1 = getFn()流程图
1 调用函数 var fn1 = getFn() 调用函数地址callq
2 返回的rdx是返回值, 这里是返回了plus
3 rdx内部有 调用函数getFn()地址(即返回地址函数plus)
4 函数fn1 占16个字节, rdx赋值给fn1 前8个字节放函数地址, 后8个字节放0