Objective-C开发者眼中的Swift: 那些激动人心的新功能

我们会在 AVOS Cloud Blog 上持续地发布 Swift 相关的文章。AVOS Cloud 的 Swift SDK 也会很快推出，请大家关注。在转载本文时请务必保持完整性并在开头提供出处链接。

本文翻译自 http://www.raywenderlich.com/73997/swift-language-highlights

如果你和我一样，周一早上坐下来准备好好看看苹果的Keynote，兴奋地准备开始尝试一些新的API，结果你听到最多的是一门新的语言：Swift！你突然被告知，这不是Objective-C的扩展，而是一门完完全全新的语言。你是会激动呢，还是高兴，抑或头脑一片空白？

Swift将会完全改变我们写iOS和Mac应用的方式，在这片文章里，我概括了这门语言的一些要点，并和Objective-C里面相应部分做了对比。

注意：这不是Swift的入门读物，苹果已经发布了一本很全面的 Swift Programming Language，我强烈建议你先读它。这篇文章只会讨论一些特别cool、值得玩味的知识点。

类型

第一个重大的事情是Swift提供了类型推断(type inference)。如果语言本身可以推断类型，那么开发者就再也不必声明每一个变量的类型了。编译器可以搞定这件事，如下面的例子，编译器可以自动把变量类型设为String：

// automatically inferred
var name1 = "Matt"
// explicit typing (optional in this case)
var name2: String = "Matt"

与类型推断相伴而来的，Swift提供了类型安全的保证(type safety)。在Swift中，编译器（大部分情况如此，偶有例外）知道一个对象的完整类型，这让它可以做决定来怎么编译代码。

这和Objective-C是大相径庭的，Objective-C是一门非常动态的语言，在编译期对象的类型并不完全清楚，部分原因是因为，你可以在运行时给既存的类型增加新的方法、增加一个完整的新类、甚至改变一个实例的类型。

让我们看一个具体的例子，下面的Objective-C代码：

Person *matt = [[Person alloc] initWithName: @"Matt Galloway"];
[matt sayHello];

当编译器看到sayHello被调用的时候，它能够检查头文件里面是否有这个方法的声明，如果没有则编译会出错，但是它能做的仅此而已。这通常情况下是足够了，能够用来发现问题最先出现的地方，以及出现的打字错误。但是因为动态性，编译器不知道sayHello是否会在运行时被修改或者一直存在。譬如，它可能是某个协议的一个可选方法（记住 respondsToSelector: 检查）。

因为不是强类型的，所以Objective-C编译器能做的就比较有限，无法在方法调用的时候进行一些优化。众所周知，方法调用都是通过objc_msgSend来动态dispatch的，你应该在backtrace里看到过。对这个函数而言，选择器的实现会经过查找和跳转两步，我们不可否认这会增加额外开销和复杂度。

我们再来看看Swift怎样完成同样的事情：

var matt = Person(name: "Matt Galloway");
matt.sayHello()

在Swift中，编译器知道更多类型信息，它能确切地知道sayHello在哪里被定义。因此，它能做一些优化而直接跳转到方法的实现入口，而不必经由动态dispatch。在其他语言中，可能会通过vtable来进行dispatch，这会比Objective-C采用的动态dispatch代价稍小一些，C++的虚函数就是这样做的。

在Swift中，编译器能提供更多帮助。他能阻止模糊类型带来的bug，也能通过编译优化让你的代码跑得更快。

泛型

另一个重大的功能就是泛型。如果你对C++比较熟悉，那你可能觉得泛型(generic)和模板(templates)比较像。因为Swift有严格的类型限制，你声明一个函数的时候，对于它的参数必须指明确定的类型。但有时候你对于不同的数据类型，可能都需要相似的功能。

一个例子是通常非常有用的数据结构Pair，你需要将一对值存放在一起。对于整数，你可以这么干：

struct IntPair {
    let a: Int!
    let b: Int!
    init(a: Int, b: Int) {
        self.a = a
        self.b = b
    }
    func equal() -> Bool {
        return a == b
    }
}
let intPair = IntPair(a: 5, b: 10)
intPair.a   // 5
intPair.b   // 10
intPair.equal()  // false

看起来还比较有用。但是现在你想让它也能用在浮点数上，你可能就需要再定义一个FloatPair的类，这看起来就有点丑陋了。这时候泛型就能派上用场了，与再定义一个新的类相比，你也可以：

struct Pair {
    let a: T!
    let b: T!
    init(a: T, b: T) {
        self.a = a
        self.b = b
    }
    func equal() -> Bool {
        return a == b
    }
}
let pair = Pair(a: 5, b: 10)
pair.a  // 5
pair.b  // 10
pair.equal()  // false

let floatPair = Pair(a: 3.14159, b: 2.0)
floatPair.a   // 3.14159
floatPair.b   // 2.0
floatPair.equal() // false

这就相当有用了！可能这还不够清楚说明你现在为什么要使用这一功能，但是相信我：机会无限！你很快就会在你的代码中用到它了。

容器

你应该已经明白并且喜欢使用NSArray,NSDictionary以及他们的可修改版本了，现在你会看到他们在Swift中的等价物。幸运的是，他们非常相像，你可以这样来声明一个数组和字典：

let array = [1, 2, 3, 4]
let dictinary = ["dog": 1, "elephant": 2]

这对你来说应该再熟悉不过，只是有些许差异：在Objective-C中，只要你愿意，数组和字典中可以放入任何类型的对象，但是在Swift里面，数字和字典必须指定数据类型，这都是通过前面所讲的泛型实现的。

上面的两个变量也可以这样定义，带上类型信息（记住：尽管你不必这么做）：

let array: Array = [1, 2, 3, 4]
let dictinary: Dictionary = ["dog": 1, "elephant": 2]

注意看在定义哪些类型可以放入容器时，泛型的使用。对于数组还有一个简略的形式，看起来可读性更好，但本质上是做同样的事情：

let array: Int[] = [1, 2, 3, 4]

注意：现在会禁止任何Int之外的实例加入这个数组。这听起来不那么方便，但是毋庸置疑地有用：你的API再也不用长篇累牍地解释它返回的数组中会保存什么内容，或者一个属性里面能够保存什么内容，你可以把这些问题交给编译器，由它来进行前期的错误检查和优化，是更明智的做法。

可变性

Swift中的容器的一个有意思的地方就是它的可变性。与Objective-C不一样，Array和Dictionary并不存在一个可变版本，你只能通过let和var来区分它们。对于那些还没有读过原书，或者还未深入Swift的读者（我建议你们读一下，尽快！），只需要知道let用来声明常量，var用来声明变量。let有点类似于C/C++/Objective-C中的const。
用let声明的容器无法改变它的大小，也就是说不能调用追加和删除方法，如果你这样做，就会得到类似错误：

let array = [1, 2, 3]
array.append(4)
// error: immutable value of type 'Array' only has mutating members named 'append'

这同样适用于字典类。这导致编译器可以推导集合的性质并做适当优化。比如，如果大小不能改变，那么已经保存的值就永远不用考虑重新分配以接纳新值。所以，对于不会发生变化的集合对象，总是使用let来声明是一种很好地做法。

字符串

Objective-C中的字符串是众所周知的难用，就算只是连接字符串，代码也是非常冗长，例如：

Person *person = ...;
 
NSMutableString *description = [[NSMutableString alloc] init];
[description appendFormat:@"%@ is %i years old.", person.name, person.age];
if (person.employer) {
  [description appendFormat:@" They work for %@.", person.employer];
} else {
  [description appendString:@" They are unemployed."];
}

这种代码太啰嗦了，里面包含了太多与目的无关的字符。同样的事情Swift里面做起来就是这样：

var description = ""
description += "\(person.name) is \(person.age) years old."
if person.employer {
    description += " They work for \(person.employer)."
} else {
    description += " They are unemployed."
}

清晰许多！注意格式化一个字符串的方法，你现在也可以通过+=操作符来连接简单连接两个字符串，这都简洁太多，并且，也没有可变、不可变两种字符串存在。

Swift另一个非常好的增强是字符串比较。你应该知道，Objective-C中使用==操作符并不能比较两个字符串是否相等，你必须使用isEqualToString:这个方法，这是因为==只是比较两个指针是否相等。Swift抛弃了这些概念，让你直接通过==操作符来直接比较内容是否相等，这也意味着字符串也可以用到switch语句中，下一节会介绍更多相关内容。

最后一则好消息就是Swift原生支持所有Unicode字符，你可以在字符串中使用任何Unicode代码点，甚至在函数名和变量名中，如果你愿意，你可以给一个函数命名为（pile of poo!）。

对Unicode支持的另一个非常方便的地方，就是提供了内建方法，来计算一个字符串的真实长度。一旦支持全范围的Unicode字符，字符串长度的计算就不再是一件简单的事情。在UTF8字符串里，你不能把字节数当成字符串长度，因为有些字符会占用超过一个字节的空间。在Objective-C中，NSString总是按照UTF16来计算长度，把每两个字节当成一个字符，但技术上说这并不总是正确的，因为有些Unicode字符会占用2个以上的字节。

幸运的是，Swift提供了一个非常方便的函数来计算代码点的真实个数，这就是名叫countElements的顶级函数。你可以像这样来使用它：

var poos = "a9"
countElements(poos) // 2

但这也并不是对所有情况都成立，它仅仅只统计了一下Unicode代码点的个数，并没有考虑引起字符变化的特殊情形。例如，你可以加一个元音符号到一个前缀字符上，这时候countElements会认为是两个字符，而实际上看起来只有一个字符：

var eUmlaut = "e\u0308" // ë
countElements(eUmlaut) // 2

说一千道一万，我想你肯定会赞成，相比Objective-C，Swift中的字符串好用太多！

Switch语句

我想讲的最后一件事情就是switch语句，与Objective-C相比，Swift对它做了彻底的改进。这是一件很有意思的事情，因为涉及到一些东西，如果不从根本上打破Objective-C是C的严格超集这一事实，就无法加入到Objective-C中去。

第一个让人兴奋的点是switch可以用到字符串上了，这可能是你以前想做但做不到的。在Objective-C中，你只能通过大量的if语句和isEqualToString组合来达到类似效果，例如：

if ([person.name isEqualToString:@"Matt Galloway"]) {
  NSLog(@"Author of an interesting Swift article");
} else if ([person.name isEqualToString:@"Ray Wenderlich"]) {
  NSLog(@"Has a great website");
} else if ([person.name isEqualToString:@"Tim Cook"]) {
  NSLog(@"CEO of Apple Inc.");
} else {
  NSLog(@"Someone else);
}

这样的代码可读性太差，并且有太多的字符要敲入。而同样的事情，在Swift中则：

switch person.name {
  case "Matt Galloway":
    println("Author of an interesting Swift article")
  case "Ray Wenderlich":
    println("Has a great website")
  case "Tim Cook":
    println("CEO of Apple Inc.")
  default:
    println("Someone else")
}

除了字符串上的switch之外，还有一些有意思的地方需要注意。这里没有任何break，这是因为case并不会一直执行下去，碰到下一个case的时候自动就退出了，这样可以减少好多不小心引发的Bug！

下面的switch语句可能会让你头脑发蒙，请做好准备：

switch i {
case 0, 1, 2:
    println("Small")
case 3...7:
    println("Medium")
case 8..10:
    println("Large")
case _ where i % 2 == 0:
    println("Even")
case _ where i % 2 == 1:
    println("Odd")
default:
    break
}

首先，这里出现了一个break语句。这是因为switch需要完全穷举，比如需要处理所有分支。在这里，我们默认是什么都不做，所以使用break来明确声明这一意图。

其次，这里有...和..，这两个用来定义范围的操作符。前一个表示闭区间（包含最右边的边界值），而后一个则表示开区间（不包含最右边的边界值），这将会带来难以置信的便利。

最后，可以直接把case的分支变量作为计算的输入。以上为例，如果一个数字不在0-10范围内，那么对于偶数会打印“Even”，而对于奇数则会打印出“Odd”。神奇到爆，有没有！

接下来

希望这篇文章能让你初尝Swift的滋味，也能让你明白后面蕴藏了多少宝藏，但是还有更多事情要做，我强烈赞成你去读一下苹果公司的书，看看其他文档，以帮助你来深入学习这门语言——你迟早需要这么做！