作者:COSMIN PUPĂZĂ,原文链接,原文日期:2016/06/29
译者:saitjr;校对:Cee;定稿:CMB

Apple 在 WWDC 上已将 Swift 3 整合进了 Xcode 8 beta 中,并会在今年晚些时候发布 Swift 3 的正式版。这是 Swift 在开源和支持 Mac OS X 与 Linux 之后的首个版本。如果你在去年 11 月关注了 Swift 进化史 和已经启动的 IBM 沙盒 项目,那你应该知道 Swift 确实改动很多。甚至可以确定你在 Xcode 8 上根本无法编译既有项目。

Swift 3 的改动归结下来主要有两点:

  • 移除了在 Swift 2.2 就已经弃用的特性
  • 语言现代化问题

让我们从移除特性讲起,毕竟这点能容易理解,而且在 Xcode 7.3 的时候我们遇到了相关警告。

++-- 操作符

自增自减是来源于 C 的操作符,作用是对变量直接进行 +1-1 的操作:

var i = 0
i++
++i
i--
--i

然而,在我们要选择使用哪一种操作符进行运算的时候,事情就变得复杂起来。无论是自增还是自减,都对应着两种写法:写在在变量之前,还是在变量之后。它们的底层实现其实都是有返回值的函数,是否使用返回值取决于对运算符的重载。

这可能会吓跑初学者,所以苹果移除了该特性——取而代之的是复合加法运算(+=)与减法运算(-=):

var i = 0
i += 1
i -= 1

当然,你也可以使用普通的加法运算(+)与减法运算(-),虽然复合式运算符写起来要短一点:

i = i + 1
i = i - 1

延伸阅读:如果你想要了解更多该变更背后的故事,请阅读 Chris Lattner 对移除 ++-- 的看法

C 风格的 for 循环已成历史

其实自增自减运算符用得最多的地方,还是在 for 循环部分。移除该运算符意味着 for 循环的特性也随之远去了,因为在 for-in 的世界中,循环控制语句与范围限制用不上该操作符。

如果你有一定编程背景,那么输出 1 到 100 的数,你可能会这样写:

for (i = 1; i <= 10; i++) {
print(i)
}

在 Swift 3 中,已经不允许这种写法了,而应该写为(注意闭区间范围的写法):

for i in 1...10 {
print(i)
}

或者,你也可以使用 for-each 加闭包的写法(更多循环相关信息请看):

(1...10).forEach {
print($0)
}

延伸阅读:如果你想要了解更多该变更背后的故事,请阅读 Erica Sadun 对移除 C 风格循环的看法

移除函数参数的 var 标记

如果不需要在函数内部对参数进行修改的话,函数参数通常都定义为常量。然而,在某些情况下,定义成变量会更加合适。在 Swift 2 中,你可以用 var 关键字来将函数参数标记为变量。一旦参数用 var 来标记,就会生成一份变量的拷贝,如此便能在方法内部对变量进行修改了。

下面是一个求两个数的最大公约数的例子(如果想到回到高中数学课堂再学习一遍,请移步):

func gcd(var a: Int, var b: Int) -> Int {
if (a == b) {
return a
}
repeat {
if (a > b) {
a = a - b
} else {
b = b - a
}
} while (a != b)
return a
}

这个算法的逻辑很简单:如果两个数相等,则返回其中一个的值。否则,做大小比较,大的数减去小的数之后,将差值赋值给大的数,然后再将两个数作比较,为止它们相等为止,最终返回其中一个的值。正如你所看到的,通过将 ab 标记为变量,才能在函数体里对两个数进行修改。

Swift 3 不在允许开发者这样来将参数标记为变量了,因为开发者可能会在 varinout 纠结不已。所以最新的 Swift 版本中,就干脆移除了函数参数标记 var 的特性。

如此,想要用 Swift 3 来写上面的 gcd 函数,就要另辟蹊径了。你需要在函数内部创建临时变量来存储参数:

func gcd(a: Int, b: Int) -> Int {
if (a == b) {
return a
}
var c = a
var d = b
repeat {
if (c > d) {
c = c - d
} else {
d = d - c
}
} while (c != d)
return c
}

延伸阅读:如果你想要了解更多该变更背后的故事,请阅读决定移除 var 的想法

函数参数标签的一致性

函数的参数列表底层实现其实是元组,所以只要元组结构和函数参数列表相同,你可以直接用元组来代替参数列表。就拿刚才的 gcd() 函数来说,你可以这样调用:

gcd(8, b: 12)

你也可以这样调用:

let number = (8, b: 12)
gcd(number)

正如你所看到的,在 Swift 2 中,第一个参数无需带标签,而从第二个参数开始,就必须要带标签了。

这个语法对初学者来说可能会造成困惑,所以,要进行统一标签设计。在 Swift 3 中,函数的调用要像下面这样:

gcd(a: 8, b: 12)

即使是第一个参数,也必须带上标签。如果不带,Xcode 8 会直接报错。

你对这修改的第一个反应可能是:「我哔!那我代码改动得多大啊!」是的,这简直是成吨的伤害。所以苹果又给出了一种不用给第一个参数带标签的解决方案。在第一个参数前面加上一个下划线:

func gcd(_ a: Int, b: Int) -> Int {
...
}

但是这样做,事情又仿佛回到了原点——第一个参数不用带标签了。使用这种方式,应该能一定程度上降低 Swift 2 迁移到 Swift 3 上的痛苦。

延伸阅读:如果你想要了解更多该变更背后的故事,请阅读函数标签一致性的一些想法

Selector 不再允许使用 String

让我们来创建一个按钮,并给它添加一个点击事件(不需要界面支持,直接使用 playground 就行):

// 1
import UIKit
import XCPlayground
// 2
class Responder: NSObject {
func tap() {
print("Button pressed")
}
}
let responder = Responder()
// 3
let button = UIButton(type: .System)
button.setTitle("Button", forState: .Normal)
button.addTarget(responder, action: "tap", forControlEvents: .TouchUpInside)
button.sizeToFit()
button.center = CGPoint(x: 50, y: 25)
// 4
let frame = CGRect(x: 0, y: 0, width: 100, height: 50)
let view = UIView(frame: frame)
view.addSubview(button)
XCPlaygroundPage.currentPage.liveView = view

让我们一步一步分析下上面的代码:

  1. 导入 UIKitXCPlayground 框架——需要创建一个按钮,并在 playground 的 assistant editor 中进行显示。

    注意:你需要在 Xcode 菜单栏上的 View -> Assistant Editor -> Show Assistant Editor 来开启 assistant editor。

  2. 创建点击的触发事件,能在用户点击按钮时,触发绑定的事件——这需要基类为 NSObject,因为 selector 仅对 Objective-C 的方法有效。

  3. 声明按钮,并配置相关属性。

  4. 声明视图,给定合适的大小,将按钮添加到视图上,最后显示在 playground 的 assistant editor 中。

让我们来看下给按钮添加事件的代码:

button.addTarget(responder, action: "tap", forControlEvents: .TouchUpInside)

这里按钮的 selector 还是写的字符串。如果字符串拼写错了,那程序会在运行时因找不到相关方法而崩溃。

为了解决编译期间的潜在问题,Swift 3 将字符串 selector 的写法改为了 #selecor()。这将允许编译器提前检查方法名的拼写问题,而不用等到运行时。

button.addTarget(responder, action: #selector(Responder.tap), for: .touchUpInside)

延伸阅读:如果你想要了解更多该变更背后的故事,请阅读 Doug Gregor 的观点

以上就是关于移除特性的全部内容。接下来,让我们来看看语言现代化的一些亮点。

不再是 String 的 key-path 写法

这个特性和上一个很相似,但是这是用在键值编码(KVC)与键值观察(KVO)上的:

class Person: NSObject {
var name: String = ""
init(name: String) {
self.name = name
}
}
let me = Person(name: "Cosmin")
me.valueForKeyPath("name")

首先创建了 Person 类,这是 KVC 的首要条件。然后用指定的构造器初始化一个 me,最后通过 KVC 来修改 name。同样,如果 KVC 中的键拼写错误,这一切就白瞎了 🙁。

幸运的是,Swift 3 中就不会再出现这个情况了。字符串的 key-path 写法被替换为了 #keyPath()

class Person: NSObject {
var name: String = ""
init(name: String) {
self.name = name
}
}
let me = Person(name: "Cosmin")
me.value(forKeyPath: #keyPath(Person.name))

延伸阅读:如果你想要了解更多该变更背后的故事,请阅读 David Hart 的观点

Foundation 去掉 NS 前缀

我们先来看看有 NS 前缀时的写法,下面是一个典型的 JSON 解析例子(如果对 NS 前缀的前世今生感兴趣,请移步):

let file = NSBundle.mainBundle().pathForResource("tutorials", ofType: "json")
let url = NSURL(fileURLWithPath: file!)
let data = NSData(contentsOfURL: url)
let json = try! NSJSONSerialization.JSONObjectWithData(data!, options: [])
print(json)

以上代码使用了 Foundation 相关类来对文件中的 JSON 数据进行解析:NSBundle -> NSURL -> NSData -> NSJSONSerialization。

在 Swift 3 中,将移除 NS 前缀,所以,解析流程变成了:Bundle -> URL -> Data -> JSONSerialization。

let file = Bundle.main().pathForResource("tutorials", ofType: "json")
let url = URL(fileURLWithPath: file!)
let data = try! Data(contentsOf: url)
let json = try! JSONSerialization.jsonObject(with: data)
print(json)

延伸阅读:关于命名约定的变化,你可以查看 Tony Parker 与 Philippe Hausler 的观点

M_PI 还是 .pi

下面是一个已知半径求圆周长的例子:

let r = 3.0
let circumference = 2 * M_PI * r
let area = M_PI * r * r

在旧版本的 Swift 中,我们使用 M_PI 常量来表示 π。而在 Swift 3 中,π 整合为了 Float,Double 与 CGFloat 三种形式:

Float.pi
Double.pi
CGFloat.pi

所以上面求圆周长的例子,在 Swift 3 中应该写为:

let r = 3.0
let circumference = 2 * Double.pi * r
let area = Double.pi * r * r

根据类型推断,我们可以将类型前缀移除。更为精简的版本如下:

let r = 3.0
let circumference = 2 * .pi * r
let area = .pi * r * r

GCD

Grand Central Dispatch(GCD)多用于解决网络请求时,阻塞主线程的 UI 刷新问题。这是用 C 写的,并且 API 对初学者也并不友好,甚至想要创建个基本的异步线程也不得不这样写:

let queue = dispatch_queue_create("Swift 2.2", nil)
dispatch_async(queue) {
print("Swift 2.2 queue")
}

Swift 3 取消了这种冗余的写法,而采用了更为面向对象的方式:

let queue = DispatchQueue(label: "Swift 3")
queue.async {
print("Swift 3 queue")
}

延伸阅读:更多相关信息,请查看 Matt Wright 的观点

更 Swift 范的 Core Graphics

Core Graphics 是一个相当强大的绘图框架,但是和 GCD 一样,它依然是 C 风格的 API:

let frame = CGRect(x: 0, y: 0, width: 100, height: 50)
class View: UIView {
override func drawRect(rect: CGRect) {
let context = UIGraphicsGetCurrentContext()
let blue = UIColor.blueColor().CGColor
CGContextSetFillColorWithColor(context, blue)
let red = UIColor.redColor().CGColor
CGContextSetStrokeColorWithColor(context, red)
CGContextSetLineWidth(context, 10)
CGContextAddRect(context, frame)
CGContextDrawPath(context, .FillStroke)
}
}
let aView = View(frame: frame)

上面代码,首先创建了 view 的 frame,然后创建一个继承自 UIViewView 类,重写 drawRect() 方法来重绘 view 的内容。

在 Swift 3 中,有不同的实现方式——对当前画布上下文解包,之后的所有绘制操作就都基于解包对象了:

let frame = CGRect(x: 0, y: 0, width: 100, height: 50)
class View: UIView {
override func draw(_ rect: CGRect) {
guard let context = UIGraphicsGetCurrentContext() else {
return
}
let blue = UIColor.blue().cgColor
context.setFillColor(blue)
let red = UIColor.red().cgColor
context.setStrokeColor(red)
context.setLineWidth(10)
context.addRect(frame)
context.drawPath(using: .fillStroke)
}
}
let aView = View(frame: frame)

注意:在 view 调 drawRect() 方法之前,上下文均为 nil,所以使用 guard 关键字来处理(更多关于上下文的介绍,请移步)。

动词与名词的命名约定

是时候介绍些英语语法相关的更改了🙂!Swift 3 将方法分为了两大类:一类是返回一个确切的值的方法,就像是名词;一类是处理一些事件的,就像是动词。

来看看这个输出 10 到 1 的例子:

for i in (1...10).reverse() {
print(i)
}

我们使用了 reverse() 方法来反向数组。Swift 3 中,改为用名词来做方法名——为它加上了 ed 后缀:

for i in (1...10).reversed() {
print(i)
}

在元组中,最常见的输出数组内容的方式是:

var array = [1, 5, 3, 2, 4]
for (index, value) in array.enumerate() {
print("\(index + 1) \(value)")
}

Swift 3 中,同样对相关的 enumerate() 方法名做出了名词性的修改——同样加上了 ed 后缀:

var array = [1, 5, 3, 2, 4]
for (index, value) in array.enumerated() {
print("\(index + 1) \(value)")
}

另外一个例子是数组排序。下面是将数组升序排列的例子:

var array = [1, 5, 3, 2, 4]
let sortedArray = array.sort()
print(sortedArray)

Swift 3 中将 sort() 方法修改为了 sorted()

var array = [1, 5, 3, 2, 4]
let sortedArray = array.sorted()
print(sortedArray)

再让我们来看看直接对数组进行排序,而不是用中间量来接收是怎样的。在 Swift 2 中,你会像下面这样写:

var array = [1, 5, 3, 2, 4]
array.sortInPlace()
print(array)

我们使用了 sortInPlace() 方法来对可变数组进行排序。Swift 3 中,认为这种没有返回值,仅仅是处理排序的操作应该是动词行为。所以,应该使用了一个很基本的动词来描述这种操作——将 sortInPlace() 重命名为了 sort()

var array = [1, 5, 3, 2, 4]
array.sort()
print(array)

延伸阅读:更多关于命名约定的信息,请查看 API 设计手册

更 Swift 范的 API

Swift 3 采用了更具有哲理性 API 设计方式——移除不必要的单词。所以,如果某些词是多余的,或者是能根据上下文推断出来的,那就直接移除:

  • XCPlaygroundPage.currentPage 改为 PlaygroundPage.current
  • button.setTitle(forState) 改为 button.setTitle(for)
  • button.addTarget(action, forControlEvents) 改为 button.addTarget(action, for)
  • NSBundle.mainBundle() 改为 Bundle.main()
  • NSData(contentsOfURL) 改为 URL(contentsOf)
  • NSJSONSerialization.JSONObjectWithData() 改为 JSONSerialization.jsonObject(with)
  • UIColor.blueColor() 改为 UIColor.blue()
  • UIColor.redColor() 改为 UIColor.red()

枚举成员

Swift 3 将枚举成员当做属性来看,所以使用小写字母开头而不是以前的大写字母:

  • .System 改为 .system
  • .TouchUpInside 改为 .touchUpInside
  • .FillStroke 改为 .fillStroke
  • .CGColor 改为 .cgColor

@discardableResult

在 Swift 3 中,如果没有接收某方法的返回值,Xcode 会报出警告。如下:

在上面的代码中,printMessage 方法返回了一条信息给调用者。但是,这个返回值并没有被接收。这可能会存在潜在问题,所以编译器在 Swift 3 中会给你报警告。

这种情况下,并不一定要接收返回值来消除警告。还可以通过给方法声明 @discardableResult 来达到消除目的:

override func viewDidLoad() {
super.viewDidLoad()
printMessage(message: "Hello Swift 3!")
}
@discardableResult
func printMessage(message: String) -> String {
let outputMessage = "Output : \(message)"
print(outputMessage)
return outputMessage
}

总结

以上便是 Swift 3 做出的所有更改。新版本另这门语言变得越来越优雅。当然同时也包含了很多会对你既有代码造成影响的修改。希望这篇文章能更好的帮助你理解这些变更,同时也希望能在 Swift 项目版本迁移方面能帮到你。

文章的所有代码我都放在了这个 Playground 中,我已经在 Xcode 8 beta 版本中进行了测试。所以,请确保使用 Xcode 8 来进行编译。

有任何问题,欢迎告知。Happy coding!🙂

本文由 SwiftGG 翻译组翻译,已经获得作者翻译授权,最新文章请访问 http://swift.gg

文章目录
  1. 1. ++ 与 -- 操作符
  2. 2. C 风格的 for 循环已成历史
  3. 3. 移除函数参数的 var 标记
  4. 4. 函数参数标签的一致性
  5. 5. Selector 不再允许使用 String
  6. 6. 不再是 String 的 key-path 写法
  7. 7. Foundation 去掉 NS 前缀
  8. 8. M_PI 还是 .pi
  9. 9. GCD
  10. 10. 更 Swift 范的 Core Graphics
  11. 11. 动词与名词的命名约定
  12. 12. 更 Swift 范的 API
  13. 13. 枚举成员
  14. 14. @discardableResult
  15. 15. 总结