Swift最酷炫的七大功能

转自：http://www.csdn.net/article/2014-07-03/2820507-7-cool-features-in-swift/1

摘要：Swift语言中有哪些让iOS和OS X开发者颇为兴奋的部分？与Ruby、C++、Objective-C语言等语言相比，Swift又有哪些优势？本文作者在花费大量时间对Swift进行研究之后，总结出了Swift最为酷炫的七大功能。

本文作者Andrew Wagner是一名资深的iOS和Web开发者，在Swift面世之后，他花费了许多的时间来研究Swift，在文章中，他不仅分享了Swift语言中让iOS和OS X开发者颇为兴奋的部分，还将其与Ruby、C++、Objective-C语言进行比较，总结出了Swift最为酷炫的七大功能。

1. 支持扩展结构和字面量

Swift中我最喜欢的一点就是可以扩展结构，这对于向现有结构中添加函数可谓大有裨益。对我来说，最好的例子就是它能够实现向支持返还矩形类Rectangle中心点的CGRect添加一个中心法：

[cpp]  view plain copy

1. extension CGRect {  
2.     var center : CGPoint {  
3.         return CGPoint(  
4.             x: self.origin.x + self.size.width / 2.0,  
5.             y: self.origin.y + self.size.height / 2.0  
6.         )  
7.     }  
8. }  

我不得不使用大量的Rectangle中心点，而如果我可以利用name来取代繁杂的数学计算，就能够让代码的意图显得更加清晰明了。

此外，Swift还支持扩展字面量。在Ruby中，有一个名为repeat的非常有用的整数方法。基本上你可以使用块来对一个整数调用repeat，即使重复定义整数也可被执行。然而在Swift中，一切就简单得多：

[cpp]  view plain copy

1. extension Int {  
2.     func repeat(block : () -> ()) {  
3.         for i in 0..self {  
4.             block()  
5.         }  
6.     }  
7. }  

接着，你就可以像这样使用它：

[cpp]  view plain copy

1. 3.repeat {  
2.     // called 3 times  
3.     println("hello")  
4. }  

注：如果唯一参数为闭包，则可省略括号。

2. 更加灵活的枚举

Objective-C的枚举语法着实欠佳，而Swift中的枚举则更加灵活，你可以定义Swift的枚举存储任何类型的相关值，例如，网络请求：

[cpp]  view plain copy

1. struct NetRequest {  
2.     enum Method {  
3.         case GET  
4.         case POST(String)  
5.     }  
6.     var URL : String  
7.     var method : Method  
8. }  
9. var getRequest = NetRequest(URL: "http://drewag.me", method: .GET)  
10. var postRequest = NetRequest(URL: "http://drewag.me", method: .POST("{\"username\": \"drewag\"}"))  

GET请求并不具备请求主体，但POST却具备。在方法枚举中，如果没有一个潜在闲置的成员变量，则可以直接定义POST内容主体。

关于这点，最好的例证就是Swift的Optional。Swift编译器能够给予我们许多语法上的甜头，但落到实处，当你像这样定义一个可选字符串时：var myString : String?，编译器会将其转换为var myString : Optional<String>。定义Optional：

[cpp]  view plain copy

1. enum Optional {  
2.     case None  
3.     case Some(T)  
4. }  

3. 更为强大的泛型

集合在Objective-C中使用的都是最通用的泛型类，这就意味着开发者可以将任何值带入一个包含混合对象的集合当中，但却会造成集合类型模糊。这也是我所认为的C++比Objective-C更好的一个地方，C++有允许定义具备诸如vector<int>等特定类型的集合的Templates。Swift则借用了极为相似的语法，和可根据自我需求定义写出灵活可重用的函数及类型的泛型（Generics）代码。

接下来，让我们来看一下不仅省时更能避免Bug出现的泛型的一个简单示例：

[cpp]  view plain copy

1. class Word {  
2.     enum PartOfSpeech {  
3.         case Noun, Pronoun, Verb  
4.     }  
5.     var value : String  
6.     var partOfSpeech : PartOfSpeech  
7.     init(_ value: String, _ partOfSpeech : PartOfSpeech) {  
8.         self.value = value  
9.         self.partOfSpeech = partOfSpeech  
10.     }  
11. }  
12. var sentence = [Word("I", .Pronoun), Word("ran", .Verb), Word("home", .Noun)]  
13.     class Word {  
14.     enum PartOfSpeech {  
15.         case Noun, Pronoun, Verb  
16.     }  
17.     var value : String  
18.     var partOfSpeech : PartOfSpeech  
19.     init(_ value: String, _ partOfSpeech : PartOfSpeech) {  
20.         self.value = value  
21.         self.partOfSpeech = partOfSpeech  
22.     }  
23. }  
24. var sentence = [Word("I", .Pronoun), Word("ran", .Verb), Word("home", .Noun)]  
25. sentence.append("quickly") // Cannot convert the expression's type '()' to type 'Word'  
26. sentence[0].lowercaseString // Could not find member 'lowercaseString'  
27. sentence[0].value.lowercaseString  

4. 不同类型多重函数

在Swift中，当定义一个函数时，你可以定义一个或多个有名字和类型的值，作为函数的输入，也可以定义某种类型的值作为函数执行结束的输出。这对于定义可适用于各种类型但需要不同实现的函数来说绝对是如虎添翼。

[cpp]  view plain copy

1. func mathmaticallyAdd(a : Int, b : Int) -> Int {  
2.     return a + b;  
3. }  
4. func mathmaticallyAdd(a : String, b : String) -> String {  
5.     let aNum = a.bridgeToObjectiveC().intValue  
6.     let bNum = b.bridgeToObjectiveC().intValue  
7.     return "\(aNum + bNum)"  
8. }  
9. mathmaticallyAdd(2, 7) // returns 9  
10. mathmaticallyAdd("2", "7") // returns “9”  

在上面的代码段中，无缘无故地定义了mathmaticallyAddInts和mathmaticallyAddStrings两个不同的函数，因为其用意很清楚，只需mathmaticallyAdd即可，那这样就会显得过于繁琐冗长。定义使用Int，函数可以只使用+操作符，然而，在字符串实现中，该函数必须首先将字符串转换为整数

5. 属性监视器

在Objective-C中，很多情况下我都会重写属性setter，以便我能在执行某个操作前后对值进行设置。如果我不想将属性设置为atomic的话，那么我就需要引用代码来充当实际值分配到我想要执行的那个操作上，这样实在是太笨拙不堪了。

反观Swift，它拥有一种内置的机制，能够在移除对样板代码的需求任务完成前后进行监控并响应，这项功能称之为属性监视器（Property Observers）。你可以为属性添加一个willSet或（和）一个didSet监视器，willSet在设置新的值之前调用，而didSet则是在新的值被设置之后立即调用。

[cpp]  view plain copy

1. class MyView : UIView {  
2.     var aSubview : UIView {  
3.         didSet {  
4.             oldValue.removeFromSuperview()  
5.             self.addSubview(aSubview)  
6.         }  
7.     }  
8.     init(frame: CGRect) {  
9.         self.aSubview = UIView()  
10.         super.init(frame: frame)  
11.     }  
12. }  

willSet监视器会将新的属性值作为固定参数传入，在willSet的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，而其默认名称用newValue表示。同样，didSet监视器也会将旧的属性值作为参数传入，可以为该参数命名或直接使用默认参数名oldValue。

6. 优雅的闭包占用列表

尽管Swift的内存管理仍然采用自动引用计数，但其对于语法却有着极大的改善。在Swift中，无需在块以外声明weak或unsafe_unretained变量，你可以定义一个闭包应该如何使用捕获列表来捕获常量或变量。

[cpp]  view plain copy

1. class FilePickerController : UIViewController {  
2.     var onDidPickFileWithPath : ((path : String) -> ())?  
3. }  
4. class DocumentViewController : UIViewController {  
5.     var filePicker : FilePickerController?  
6.     var content : String?  
7.     init(fileAtURL URL: NSURL) {  
8.         super.init(nibName: nil, bundle: nil)  
9.         var request = NSURLRequest(URL: URL)  
10.         // weak: Have self automatically set to nil if it is deallocated  
11.         NSURLConnection.sendAsynchronousRequest(request, queue: nil) { [weak self]  
12.             (response, data, error) in  
13.             if let actualSelf = self {  
14.                 // Captures an owning reference "actualSelf" so interacting with it in this  
15.                 // block is safe  
16.                 actualSelf.content = NSString(data: data, encoding: NSUTF8StringEncoding)  
17.             }  
18.         }  
19.     }  
20.     func presentFilePicker() {  
21.         if !filePicker {  
22.             filePicker = FilePickerController();  
23.             // unowned: Don't worry about the nil case if you know it will never happen  
24.             filePicker!.onDidPickFileWithPath = { [unowned self]  
25.                 (path : String) in  
26.                 self.content = NSString.stringWithContentsOfFile(path) as? String  
27.             }  
28.         }  
29.         self.presentViewController(filePicker!, animated: true, completion: nil)  
30.     }  
31. }  

Swift提供了一种颇为优雅的方法来解决循环强引用所存在的问题，称之为闭包占用列表（Closuer Capture List）。在上段代码中，除了可以初始化URL的DocumentViewController之外，我还定义了一个FilePickerController类。当用户选择一个文件时，它便会提供一个闭包成员，而DocumentViewController则有一个方法来呈现该文件并处理用户选择文件的操作。此时，如果该闭包强烈捕获self，则将产生循环强引用。

这种情况下，我明白只要有DocumentViewController，闭包也就会永远存在，所以我可以通过[unowned self]使用无主引用来解决循环强引用，这比Objective-C可要干净得多了。

7. 构造过程更安全

在使用Objective-C编写程序时，我常常会犯一个错误，总是要我抓狂地花上好几分钟去调试它。这个问题非常普遍，就是在我想加载内容进去的一个类中，有一个可变数组，为了能够被添加进去，首先需要初始化数组，但我却老是会忘记。

而在Swift中，编辑器将会处于两方面的原因截获它，其一便是你必须对取值为空的属性进行处理，在定义一个构造器之后，如果你留下任何未初始化的成员变量，编译器便会显示错误，这将节省我大量的时间，如下：

[cpp]  view plain copy

1. class FileSystemItem {  
2.     var path : String  
3.     init(path : String) {  
4.         self.path = path  
5.     }  
6. }  
7. class Directory : FileSystemItem {  
8.     var contents : FileSystemItem[]  
9.     init(path : String) {  
10.         self.contents = [] // required  
11.         super.init(path: path) // required  
12.     }  
13.     func loadContents() {  
14.         // ...  
15.         // self.contents.append(file)  
16.         // ...  
17.     }  
18. }  

在Objective-C中有一个名为指定构造器（Designated Initializers）的概念，每个类都应该有一个将全部类都初始化在安全状态的构造器，而其他构造器则应该调用一个指定构造器来确保类良好，但很遗憾这在Objective-C中并不是强制执行的。而Swift则将其融入编译器，这就意味着Directory类必须调用init(path)构造器，否则将显示错误，而在path没有被定义的情况下，该类将无法实现，当类想要获得更大的继承时，便显得尤为重要。

现在，您还可以进入Swift的mobilehub主页进行资源分享和讨论。