Swift关键词简介
我们会经常看到@autoclosure, @noescape等关键词，下面就来简单的说下他们的作用。
@noescape
- 用来修饰函数的闭包参数，意思是说该闭包的生命周期比函数要短，只能在函数中使用，也不能将其存储在变量中。如图，会报错。
1@2x.png
- 使用@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
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
8
说明使用lazy后，只是将r1[2]取出来，然后做increment和double，不需要遍历array，减少了不必要的计算。
======
r2的结果是：
increment 1
increment 2
increment 3
increment 4
double 2
double 3
double 4
double 5
8
不使用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
}
}
}
}
