最近参加朋友举办的开发者聚会，我分享了 Swift 的特性，可以写出更有 Swift 味道的代码，也更加规范。
解决的问题
通常来说，编程语言的特性出现的原因是为了解决开发中不愉快的问题。接下来要介绍的特性提供了关于声明和类型的更多信息。
Format
和大多数情况一样，特性的格式有带/不带参数两个版本
- 不带参数版本
@attribute name - 带参数版本
@attribute name(attribute arguments)
接下来开始介绍各个特性了。
autoclosure - 自动封装成无参数的闭包
被修饰的参数会自动带上闭包属性
//没有使用 autoclosure，调用函数显得别扭
func printWhenTrue(pred: () -> Bool) {
if (prod()) {
print(“I am waiting for you.")
}
}
func printWhenTrue{ 2 > 1 }
// 使用 autoclosure，调用函数自然得多
func printWhenTrue(prod: @autoclosure () -> Bool) {
if (prod()) {
print(“I am here.")
}
}
func( 2 > 1 )
学会了之后，思考在什么场景适合使用。先看系统是如何使用的，看 fatalError 的定义。
// Unconditionally print a `message` and stop execution.
@noreturn public func fatalError(
@autoclosure message: () -> String = default,
file: StaticString = default,
line: UInt = default)
autoclosure 的用途是使调用变得简单，试想一下，如果 message 参数是一个闭包{ xxx } 显得多么的累赘。总结出来是，autoclosure 让调用者用的舒心，在调用有可能变得更加简单的场景下都考虑是否加上该特性，如断言就十分合适。
noescape - 参数与函数的生命周期绑定
参数将不会被存储用作后续的计算,其用来确保不会超出函数调用的生命周期。光看这段文字比较难理解，通过代码理解起来更加轻松。
//这是一个辅助理解的函数，参数 code 的生命周期和 doItMore 一样
func doItMore(@noescape code: (Int) -> ()) {}
//参数 code 和 doIt 的生命周期一样
func doIt(@noescape code: () -> ()) {
code()
doItMore(code)
/* what we CANNOT do *****
// pass it as a non-`@noescape` parameter
dispatch_async(dispatch_get_main_queue(), code)
// store it
let _code:() -> () = code
// capture it in another non-`@noescape` closure
let __code = { code() }
*/
}
任何改变参数 code 生命的行为都会被拒绝。code()没有改变生命周期，doItMore(code)也没有改变生命周期，因为函数doItMore(_:)的参数带上了 noescape，然而dispatch_async改变了生命周期，_code强引用参数code，也改变了生命周期，__code也是如此。
因为参数的生命与函数绑定，因此不能是执行异步操作的闭包，其中一个适用的场景是，开源库规范使用者的使用方法，避免难以察觉的 bug。
值得一提的是，noescape 带来了一个好处，不需要显式的使用 self.xxx。
class Bar {
var i = 0
func some() {
doIt {
//并不需要写成 print(self.i)
print(i)
}
}
}
noreturn - 函数或方法就不会返回到它的调用者中去
系统 API fatalError 和 preconditionFailure 使用了 noreturn，其定义如下。
@noreturn public func fatalError(
@autoclosure message: () -> String = default,
file: StaticString = default,
line: UInt = default)
@noreturn public func preconditionFailure(
@autoclosure message: () -> String = default,
file: StaticString = default,
line: UInt = default)
调用 fatalError 后，程序就会崩溃，打印出错误日志，调用 preconditionFailure后，效果和 fatalError一样。
这两个 API 均改变了程序正常的执行流程，你的程序已经失去控制了。这效果适用于程序错误处理，如断言，在不满足条件可以让程序崩溃。同样，你也可以自定义自己的函数，在出错打印出你关心的信息。
对于一个没有用 noreturn 特性标记的函数或方法,可以将它重写为用该特性标记的。相反,对于一个已经用 noreturn 特性标记的函数或方法,则不可以将它重写为没使用该特性标记的。借助这特性，可以重写某函数，当在不该调用的地方调用时，直接让程序崩溃。
inline - 内联函数
内联函数用得好，才能提高效率。通常来说，简短的函数应当使用内联函数，冗长的函数不适宜用内联函数，不长不短的函数由系统决定，不要干预就好。Swift 也是这样的原则，用inline带上参数的形式显式指定是否内联。
// @inline(never) 显式指定永远不实用内联函数
@inline(never) func randomInt() -> Int{
return Int(arc4random_uniform(UInt32.max))
}
// @inline(__always) 显式指定永远使用内联函数
@inline(__always) func randomInt() -> Int{
return Int(arc4random_uniform(UInt32.max))
}
//有时候是内联，有时候又不是，有系统决定
func randomInt() -> Int{
return Int(arc4random_uniform(UInt32.max))
}
inline 是一个小技巧，简短的内联函数不见得高效非常多，感觉这个特性的最佳使用场景是提高代码的逼格。
NSCopying - 修饰类的存储型变量属性
使属性的setter与属性值的一个副本合成,这个值由copyWithZone(_:)方法返回,而不是属性本身的值。但是，该属性的类型必需遵循 NSCopying协议。在 Swift 中，有引用类型和值类型，NSCopying 只适用于引用类型，而值类型是自动复制的。
熟悉 Objective-C 朋友，应该知道 @property (nonatomic, copy) NSString *myString 的涵义，给 myString赋值时，会拷贝一份，他们的内存地址并不相同。在 Swift 中，NSCopying 就是做这样的事情。学习最好不要眼高手低，写一段代码熟悉特性。
// 基础类，辅助理解
class Foo : NSObject, NSCopying {
var bar = "bar"
// 只有遵循 NSCopying 协议的属性才可被 NSCopying 修饰
func copyWithZone(zone: NSZone) -> AnyObject {
let copy = Foo()
copy.bar = bar
return copy
}
}
class Test : NSObject {
// NSCopying 修饰 foo
@NSCopying var foo : Foo?
convenience override init() {
self.init(foo: nil)
}
init(foo : Foo?) {
self.foo = foo
super.init()
}
}
接下来看 NSCopying 如何发挥作用。
- 只有在初始化方法被调用之后，
NSCopying才会发挥作用，不然和普通的引用类型的属性没有区别，下面用两段类似的代码来说明。
let foo = Foo()
foo.bar = "initial"
let test = Test(foo: foo)
print(foo === test.foo) // true
foo.bar = "changed"
print(test.foo!.bar) // "changed"
let foo = Foo()
foo.bar = "initial"
let test = Test()
test.foo = foo
print(foo === test.foo) // false
foo.bar = "changed"
print(test.foo!.bar) // "initial"
- 访问属性时不会赋值一个值，再返回给调用者，用代码验证。
let foo = Foo()
foo.bar = "initial"
let test = Test()
test.foo = foo
foo.bar = "changed"
//在访问属性时，是没有 copy
let readFoo = test.foo!
print(readFoo === test.foo!) // true
readFoo.bar = "changed"
print(test.foo!.bar) // "changed"
使用场景是想用引用类型，在合适的时候又能像值类型那样深复制赋值。不过不建议这样，会增加应用的复杂度，如非要这么做，请深入思考。
写在最后
觉得 Swift 的特性很有意思，也有很多，我会在 Part 2 继续介绍。在学习这么细节的知识时，跑操场（Playground）是很有帮助的，建议读者们也跑跑操场，理解更加深刻。
在分享过程中，我关注这些特性的应用场景是什么，不仅要懂知识点，也要知道最佳使用模式。读者在阅读时候如果想到更多的应用场景，请留下你的评论，感谢。
