你要知道的Swift闭包

前言

Swift的闭包在capture变量时，跟oc的还是有些区别的。下面来讲讲。

一览Swift的闭包

在closure中使用外部变量，swift默认会capture该变量的reference，之后会细说。为了避免在闭包执行时，变量释放，所以会retain该变量。来看个例子。

Animal类。

class Animal:CustomDebugStringConvertible {
    let name: String
    init(name: String) {
        self.name = name
    }

    var debugDescription: String {
        return "<Animal \(name)>"
    }
    deinit {
        print("\(self) dealloc")
    }
}

delay函数

func delay(seconds: NSTimeInterval, closure: ()->()) {

    let time = dispatch_time(DISPATCH_TIME_NOW, Int64(seconds * Double(NSEC_PER_SEC)))

    dispatch_after(time, dispatch_get_main_queue()) {
        closure()
    }
}

func demo1() {
    let animal = Animal(name: "cat")
    print("before closure:\(animal)")

    delay(1) {
        // retain animal
        print("inside closure:\(animal)")
    }

    print("bye")
}

output：

 before closure:<Animal cat>
 bye
 inside closure:<Animal cat>
 <Animal cat> dealloc

这里，我们用dispatch_after延迟执行一个闭包。当demo1执行完后，animal是还没有dealloc的，因为被闭包retain了。只有当闭包执行完后，才会释放掉。

好了。知道了上述理论后，来看看刚刚提到的reference。

reference

闭包默认持有变量的reference，而不是变量本身。什么意思呢？看个例子。请注意inside closure打印的那行。

// caputure value evaluted when closure is executed
func demo2() {
    var animal = Animal(name: "cat")
    print("before closure:\(animal)")

    delay(1) { 
        print("inside closure:\(animal)")
    }

    animal = Animal(name: "dog")
    print("after closure:\(animal)")
}

ouput:

 before closure:<Animal cat>
 <Animal cat> dealloc
 after closure:<Animal dog>
 inside closure:<Animal dog>
 <Animal dog> dealloc

是不是觉得有点奇怪？这就是持有reference的作用。
可以看成其持有的是指向animal的指针p，即使animal所指向的obj在变，但其实p的指针是始终不变的。看2张图应该就明白了。

p就是图中的reference。

如果熟悉c的指针的话，跟下面的代码意思类似。

char a = 'a';
char *p1 = &a;

char **p2 = &p1;
printf("%c", **p2);

char b = 'b';
p1 = &b;

// 此时**p2的值会为'b'，虽然p1的指向在变，但p2-->p1的指向关系始终不变
printf("%c", **p2);

除了reference之外，还有提到的是。

1)capture的变量在闭包执行的时候才计算。

在这个例子中，我们修改了animal为dog，闭包中打印的也是成了dog。

如果改成这样，猜猜会打印出什么？

delay(1) { 
        animal = Animal(name:"duck")
        print("inside closure:\(animal)")
    }

2. animal的dealloc。在demo2执行完后，cat就dealloc了。而dog还被持有。看上图，animal--->cat之前的关联已经断了，所以会dealloc，而此时animal指向了dog，所以dog仍会等到闭包执行完后销毁。

value type

那么对于值类型的捕获呢，是否不一样？很遗憾，仍然是reference。意思是：不是简单的捕获当前的值，存起来，亘古不变了。跟上面一样，value变了之后，闭包中的值跟着变。

func demo3() {
    var a = 40
    print("before closure:\(a)")
    delay(1) { 
        print("inside closure:\(a)")
    }

    a = 50
    print("after closure:\(a)")
}

output:

 before closure:40
 after closure:50
 inside closure:50

在闭包中修改值

可以在直接闭包中修改捕获的值，并且后续获取到的就是新值。仍然是reference的功劳。而在oc中，需要声明为__block。

func demo4() {
    var a = 40
    print("before closure:\(a)")
    delay(1) {
        print("inside closure1, before change:\(a)")
        a = 60
        print("inside closure1, after change:\(a)")
    }

    delay(2) {
        print("inside closure2:\(a)")
    }
}

如何做到和oc的捕获一样

如果只想capture变量在创建闭包时的值，使用capture list。它会copy一份变量，而非采用reference的方式。或者先声明个变量 let copyValue = a，跟capture list效果一样。

func demo5() {
    var a = 40
    print("before closure:\(a)")
    
    let copyValue = a
    delay(1) { [constantValue = a] in
        print("inside closure:\(constantValue)")
        print("inside closure:\(copyValue)")
    }

    a = 50
    print("after closure:\(a)")
}

同样对于class类型的，也一样

func demo6() {
    var animal = Animal(name: "cat")
    print("before closure:\(animal)")

    let animalCopy = animal

    delay(1) { [constantAnimal = animal] in
        print("inside closure constantAnimal:\(constantAnimal)")
        print("inside closure constantAnimal:\(animalCopy)")
    }

    animal = Animal(name: "dog")
    print("after closure:\(animal)")
}

终极混合

来个各种混合的。

func demo7() {
    var animal = Animal(name: "cat")
    print("before closure:\(animal)")

    delay(1) { [constantAnimal = animal] in
        print("inside closure1 constantAnimal:\(constantAnimal)")
        print("inside closure1:\(animal)")

        animal = Animal(name: "snake")
        print("inside closure1 animal changed:\(animal)")
    }

    animal = Animal(name: "dog")
    print("animal changed:\(animal)")

    delay(2) { [constantAnimal = animal] in
        print("inside closure2 constantAnimal:\(constantAnimal)")
        print("inside closure2:\(animal)")

        animal = Animal(name: "bear")
        print("inside closure2 animal changed:\(animal)")
    }
}

看看会是神马结果？？

后语

1. swift闭包默认持有变量的reference
2. swift闭包默认在执行时才计算捕获变量的值
3. 可在swift闭包中修改捕获变量的值
4. 使用capture list，做变量的constant copy捕获。

原文在此