汇编分析闭包本质

引用类型的赋值操作

class Size {
    var width = 1
    var height = 2
}

值类型、引用类型的let

struct Point {
    var x: Int
    var y: Int
}

let p = Point(x: 1, y: 2)
p = Point(x: 2, y: 3)//❌
p.x = 33//❌
p.y = 44//❌

class Size {
    var w: Int
    var h: Int
    init(w: Int, h: Int) {
        self.w = w
        self.h = h
    }
}

let s = Size(w: 1, h: 2)
s.h = 3
s.w = 4

let str = "Jack"
str.append("_rose")//❌

func testInstanceSize() {
    class Size {
        var w: Int
        var h: Int
        var test: Bool?
        init(w: Int, h: Int) {
            self.w = w
            self.h = h
        }
    }
    
    let s = Size(w: 1, h: 2)//malloc
    print(class_getInstanceSize(Size.self)) // 40
    print(class_getInstanceSize(type(of: s)))// 40
}
testInstanceSize()

嵌套类型

struct TestStruct {
    enum TestEnum {
        case one
    }
    enum TestEnum1 {
           case one
       }
}

枚举、结构体、类都可以定义方法

class Size {

func test() {
}
}

思考: 方法占用实例对象的内存空间吗?
存储在哪里?在内存中,在内存的哪个位置呢?
代码端,函数放在哪里方法就放在哪里,方法本质就是函数

class Size {

func test() {
}
}

func test1() {
}
class Size1 {
}

var s = Size()
s.test()

类似于

var s1 = Size1()
test1(s1)

全局变量

堆空间

栈空间

闭包表达式(Closure Expression)

func sum(_ v1: Int, _ v2: Int) -> { v1 + v2 }

var fn = { (v1 :Int, v2: Int) -> Int  in
  return v1 + v2
}
fn(10, 20)

闭包表达式的简写

func exec(_ v1: Int, _ v2: Int, fn:(Int, Int) -> Int) {
  print(fn(v1, v2))
}
exec(v1: 10, v2: 20, fn: {
(v1: Int, v2:Int) -> Int in
 return v1 + v2
})

省略

exec(v1: 10, v2: 20, fn: {
v1, v2  in
 return v1 + v2
})

再省略

exec(v1: 10, v2: 20, fn: {
v1, v2  in
 v1 + v2
})

再省略

exec(v1: 10, v2: 20, fn: {
 $0 + $1
})

再省略

exec(v1: 10, v2: 20, fn: +)

尾随闭包

如果将一个很长的闭包表达式作为函数的最后一个实参,使用尾随闭包可以增强函数的可读性.

func exec(v1: Int, v2: Int, fn:(Int, Int) -> Int) {
    print(fn(v1,v2))
}

exec(v1: 10, v2: 20) {
  $0 + $1
}

如果闭包表达式作为函数的唯一参数,而且使用尾随闭包的语法,那么就不需要在函数后面添加圆括号.

func exec( fn:(Int, Int) -> Int) {
    print(fn(1,2))
}

调用

exec(fn: {$0+$1})
exec(){$0+$1}
exec{$0+$1}

事栗-数组的排序

func testSort() {
    var arr = [2,3,4,1,6,7,8,3,4]
    arr.sort()
    print(arr)
}

[1, 2, 3, 3, 4, 4, 6, 7, 8]
Program ended with exit code: 0

sort源码

func sort(by areInIncreasingOrder: (Element, Element)->Bool)

///返回true: i1排在i2前面
///返回false: i1排在i2后面
func cmp(i1: Int, i2: Int) -> Bool {
  //大的排在前面
  return i1 > i2
}