Swift关键词简介

我们会经常看到@autoclosure, @noescape等关键词，下面就来简单的说下他们的作用。

@noescape

用来修饰函数的闭包参数，意思是说该闭包的生命周期比函数要短，只能在函数中使用，也不能将其存储在变量中。如图，会报错。

[email protected]

使用@noescape，编译器会进一步的优化你的代码，带来小小的性能提升。
在其修饰的闭包内，可以不用self关键字，也不会捕获变量，就是说可以不用weak之类的来避免循环引用。因为在函数执行完时，closure也会被销毁。
如果将此闭包传给A函数作为参数，其参数也必须由@noesapce修饰。

@autoclosure

1.同样是用来修饰函数的闭包参数，使用@autoclosure之后将会自动有@noescape的作用。顾名思义，就是将传入的参数自动转换成闭包，而不用我们自己来传一个严格格式的闭包进去。

show(msg: String, @autoclosure ifTrue: () -> Bool){
    if ifTrue(){
        println(msg)
    }
}

func example1(){

    let age = 200
    // 传入age > 140，会自动转换成闭包
    show(msg: "You are too old", ifTrue: age > 140)
}

2.只能用于没有参数的闭包，并且返回值不能是元组。
3.因为@autoclosure会带有@noescape的特性，所以如果我们需要变量可以存储闭包时，可以这样做。@autoclosure(escaping)

func test(@autoclosure(escaping) block: () -> () ) {
        let t: () -> () = block
        t()
    }

lazy var

lazy关键字是指变量用到时才去计算。

1、static，global的变量都是lazy的。

2、lazy的变量用闭包进行初始化。可以直接使用self，并且也不会引起循环引用。在使用闭包时，已经自动转成了@noescape，所以不会捕获self。

lazy var b: Int = {
        self.test4()
    }()
    
// 也可以这样写，去掉闭包
lazy var c: Int = self.test4()

func test4() -> Int {
        return 2
    }

3、lazy sequence，collection

这里有篇文章写的关于lazy的

struct p4 {
    static func f1() {
        func double(x: Int) -> Int {
            print("double \(x)")
            return 2 * x
        }

        func increment(x: Int) -> Int {
            print("increment \(x)")
            return 1 + x
        }

        let array = [1, 2, 3, 4]
        let r1 = array.lazy.map(increment).map(double)
        print(r1[2])

        let r2 = array.map(increment).map(double)
        print(r2[2])
    }
}

r1的结果：

increment 3

double 4

说明使用lazy后，只是将r1[2]取出来，然后做increment和double，不需要遍历array，减少了不必要的计算。

======

r2的结果是：

increment 1

increment 2

increment 3

increment 4

double 2

double 3

double 4

double 5

不使用lazy的话，array会遍历2次。

可变参数

func test5(data: Any...) {
        for obj in data {
            print("\(obj)")
        }
    }

dynamic

将变量或者方法声明为dynamic，即可以使用oc的runtime，动态派发，比如swizzled，replace method，KVO等等。

class Test {
    dynamic var a: Int = 0
    }
    
    dynamic func test1() {
    }
}

交换方法代码如下：


import UIKit

class AwesomeClass {
    dynamic func originalFunction() -> String {
        return "originalFunction"
    }
    
    dynamic func swizzledFunction() -> String {
        return "swizzledFunction"
    }
}

let awesomeObject = AwesomeClass()

print(awesomeObject.originalFunction()) // prints: "originalFunction"

let aClass = AwesomeClass.self
let originalMethod = class_getInstanceMethod(aClass, "originalFunction")
let swizzledMethod = class_getInstanceMethod(aClass, "swizzledFunction")
method_exchangeImplementations(originalMethod, swizzledMethod)

print(awesomeObject.originalFunction())  // prints: "swizzledFunction"

loop label

当有2层for循环，当我们要打破最外层的循环时，要怎么做呢？直接break，只能打破最里层的循环。
loop标签就派上用场了。

func test() {
        firstLoop: for i in 1...3 {
            secondLoop: for j in 2...4 {
                print("i+j=\(i+j)")
                if (i + j == 6) {
                    break firstLoop
                }
            }
        }
    }

Swift关键词简介