Swift语言入门之旅 （翻译自《The Swift Programming Language》电子书）

关于Swift

　　Swift是为IOS和OSX应用制定的新编程语言，吸取C和Objective-C语言的精粹，但不损失与C语言的兼容性。Swift采用安全编程模型、加入了各种现代编程语言特性，使得该语言更易被掌握、更具扩展性，用起来更有趣。Swift语言的奠基石是已经成熟的、并为大家所喜爱的Cocoa和Cocoa Touch框架，新语言使大家可以尽情畅想新软件开发的机遇。

　　Swift沉积了多年的研发成果，苹果公司为提供高效Swift语言编译器、调试器和基础架构打下了坚实基础。我们使用Automatic Reference Counting（ARC）技术简化内存管理。我们的框架设计，建立在Cocoa稳固的基础框架上。已经彻底完成了标准化和现代化的改进。Objective-C的改进支持了块定义，集合语法、模块，使语言框架合理集成了现代语言技术。要感谢前人的基础工作，使我们现在能够向大家介绍苹果公司未来的软件开发语言。

　　对Objective-C开发者来说，Swift是比较容易上手的，它采用和Objective-C类似的参数命名规则和强大的动态对象模型。它提供无缝的使用Cocoa框架和与Objective-C代码混合即用的互操作特性。构建在这些基础上，Swift语言带来了许多新的特性、也重新集成了过程式语言和面向对象语言功能。

　　对新学习编程的人来说，Swift语言是门友好的语言。一门作为工业前沿的系统编程语言，Swift语言能够象脚本语言一样易于表述和理解。它支持“playgrounds”技术，作为一项革新功能，开发者可以使用它进行Swift的即时运行和直观地看到结果，而不用从头重新编译运行程序。

　　Swift集成了现代计算机语言的智慧，汇入了苹果公司软件研发的精粹。Swift编译器针对性能进行了优化，而语言本身也针对现有的开发环境进行了优化，功能和性能得到平衡和发展。它能够设计小到“hello world”程序、大到操作系统级别的程序。所有这一切使swift语言对开发者和苹果公司来说都将更有吸引力。

　　使用Swift语言编写iOS和OS X应用将非常愉悦，它将继续发展新的语言特性、包含更多功能。我们对Swift的发展雄心勃勃，也迫不及待地将这个工具送给大家去使用、去创造。

Swift入门之旅

　　学习一门新的计算机语言，传统来说都是从编写一个在屏幕上打印“Hello world”的程序开始的。那在Swift，我们使用一句话来实现它：

println("Hello, world")

　　如果你编写过C或者Objective-C语言，Swift中的这个语法看起来便很熟悉，这句话却是一个完整的程序。你无须为了得到输入/输出或字符串处理去导入一个独立的功能库。编写全局代码通常用于程序的进入点。你不需要写一个main函数，你也不需要为每个语句写个逗号作为结尾。

　　这个入门之旅将给你足够的信息去开始编写Swift代码，你可以实现许多的编程任务。这个过程中如果你有些内容不理解也不要担心，我们将在本书的其他章节细节处为您解释。

批注：

　　为了更好的体验开发，请在Xcode中使用playground编辑这个章节的代码。Playgrounds允许你在一边编辑代码的同时看到代码的即时运行结果。

简单赋值：

用于你把一个常量和变量作为成变量。常量的值不必每次都传给编译器，但你必须提前赋个数值给它。就是说常量可以赋值一次而多处引用。

var myVariable = 42

myVariable = 50

let myConstant = 42

相同的类型才能进行常量和变量的赋值，但是，你不用每次都显式地定义类型，编译器可以自动判断。创建常量或变量的时候顺便赋值可以让编译器知道它属于什么类型。上面的例子，编译器指定myVariable变量属于整数类型，因为它用一个整数进行初始化。

如果初始值不能表达足够的类型信息（或没有初始值），则在变量后面加一个冒号和指定的类型。

let implicitInteger = 70

let implicitDouble = 70.0

let explicitDouble: Double = 70

练习：

显式创建一个值为4的浮点类型的常量

赋值不会自动隐式地变成另外一种类型，如果你需要把一个赋值变更到另外一种类型，你需要显式地创建目标类型的实例。

let label = "The width is "

let width = 94

let widthLabel = label + String(width)

练习：

试着把最后一行的字符串转换声明去掉，看看会出什么错误？

这里有更简便的方法把数值包含在字符串里面：把数值写在括号里面，把斜杠写在括号前面，示例如下：

let apples = 3

let oranges = 5

let appleSummary = "I have \(apples) apples."

let fruitSummary = "I have \(apples + oranges) pieces of fruit."

试验：

在字符串中使用 \()包含一个浮点计算结果，同时也包含对某个人的名字和祝词。

使用方括号([])创建数组和字典，然后在方括号中使用索引下标存取各元素的值。

var

shoppingList = ["catfish", "water", "tulips", "blue paint"]

shoppingList[1] = "bottle of water"

var occupations = [

"Malcolm": "Captain",

"Kaylee": "Mechanic",

]

occupations["Jayne"] = "Public Relations"

我们使用初始化语法来创建空数组和字典

let emptyArray = String[]()

let emptyDictionary = Dictionary<String, Float>()

如果能推断指定类型，你可以写一个空数组[]和空字典[:]- 例如： 当你设置一个新给变量或传值给函数的参数的时候。

shoppingList = [] // 购物和放置各种东西.

控制流：

使用if和switch来创建一个条件选择逻辑，使用 for-in , for,while,和do-while来创建循环，大括号里面放置在条件或循环变量是可选的内容，而方括号在声明主体中则是必备项。

let individualScores = [75, 43, 103, 87, 12]

var teamScore = 0

for score in individualScores {

if score > 50 {

teamScore += 3

} else {

teamScore += 1

}

}

teamScore

在一个if的语句中，条件值必须是布尔表达式，所以象这样的代码是会出错的:if score{...}, score不会隐式地返回零值。

你可以一起使用if和let语句赋值，但有可能赋值是空的，这些值代表它是可选的。一个可选值可以是包含实际值或是一个代表数值是空值的nil值。在类型声明后面加上一个问号代表这个定义的数值是可空的。

var optionalString: String? = "Hello"

optionalString == nil

var optionalName: String? = "John Appleseed"

var greeting = "Hello!"

if let name = optionalName {

greeting = "Hello, \(name)"

}

试验：

将optionalName设置为nil. 请看那个输出祝福语句的结果有什么变化？判断optionName是空值时加上其他子句设置输出不同的祝语。

如果可选值是nil,条件判断为假，大括号中的代码也将不会被执行。如果可选项不是nil的话，数值将被赋值给let后面指定的变量，同时，在后面的大括号中的代码中，该变量将是可以访问得到的。

开关语句(switch)支持所有的的类型和丰富多样的各式比较，他们并不是只限定于整数或只是测试它是否相等。

let vegetable = "red pepper"

switch vegetable {

case "celery":

let vegetableComment = "Add some raisins and make ants on a log."

case "cucumber", "watercress":

let vegetableComment = "That would make a good tea sandwich."

case let x where x.hasSuffix("pepper"):

let vegetableComment = "Is it a spicy \(x)?"

default:

let vegetableComment = "Everything tastes good in soup."

}

试验：

请尝试去掉这个最后这个默认的default case选项，看看会得到什么错误。

当执行完对应的case分支代码后，程序将退出switch语句，不再接着遍历下一个case，所以也不用在每个case分支的结尾声明跳转出switch。你可以使用for-in来遍历所有的字典里面的分项。

l

largest

试验：

和程序里面检查最大数字的变量相类似，在程序中加入另外一个变量跟踪哪类的数字是最大的。

我们使用while语句以重复一个代码块的执行，直到条件变化而退出。循环的条件可以放置在语句块的最后面，只要语句执行到最后就可以击发判断。

var n = 2

while n < 100 {

n = n * 2

}

n

var m = 2

do {

m = m * 2

} while m < 100

m

你可以在循环中使用一个循环指标，使用两个点 (“..”) 来隔开起始值和终值表述它范围或者明确定义它的起始值，终止条件或步进值，下面是两个相同功能的循环语句。

var firstForLoop = 0

for i in 0..3 {

firstForLoop += i

}

firstForLoop

var secondForLoop = 0

for var i = 0; i < 3; ++i {

secondForLoop += 1

}

secondForLoop

使用两个点号表示循环指标不包含终点值，使用三个点号表示循环指标包含终点值。

函数和闭包：

使用func来定义一个函数。给出函数名字和在括号中指出参数后我们就可以访问一个函数，同时我们在定义函数的输入参数的名字类型和输出的类型之间使用“->”来隔开。

func greet(name: String, day: String) -> String {

return "Hello \(name), today is \(day)."

}

greet("Bob", "Tuesday")

试验：

移除名称为day 的输入参数，加入一个参数，使函数返回今天的特殊祝福语句。

使用元组来表达函数返回多个值

func getGasPrices() -> (Double, Double, Double) {

return (3.59, 3.69, 3.79)

}

getGasPrices()

函数同样也可以输入可变数量的参数组

func sumOf(numbers: Int...) -> Int {

var sum = 0

for number in numbers {

sum += number

}

return sum

}

sumOf()

sumOf(42, 597, 12)

试验：

编写一个函数用于计算它的输入函数的平均值。

函数可以嵌套。嵌套函数可以使用调用它的上级函数的变量。 如果代码太长或太复杂，您可以使用嵌套函数来优化代码。

func returnFifteen() -> Int {

var y = 10

func add() {

y += 5

}

add()

return y

}

returnFifteen()

函数是优先级最高的类型，它可以使函数用另外一个函数作为返回值。

func makeIncrementer() -> (Int -> Int) {

func addOne(number: Int) -> Int {

return 1 + number

}

return addOne

}

var increment = makeIncrementer()

increment(7)

函数可以把另外一个函数作为参数。

func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {

for item in list {

if condition(item) {

return true

}

}

return false

}

func lessThanTen(number: Int) -> Bool {

return number < 10

}

var numbers = [20, 19, 7, 12]

hasAnyMatches(numbers, lessThanTen)

函数是一个特例的闭包，你可以使用大括号包含一段没有名字的代码闭包。输入参数和输出参数之间应使用in语法隔开函数的主体。

numbers.map({

(number: Int) -> Int in

let result = 3 * number

return result

})

试验：

请重写上面的代码段判断输入值为奇数则返回零值。

你有几个更简练的方法编写代码闭包，当闭包的类型是确定的，比如是一个回调或代理代码，你可以忽略输入参数的类型或返回的类型。单个语句的代码闭包隐含地返回语句的值（不须return）。

numbers.map({ number in 3 * number })

你可以使用位置编号引用参数值而不是使用它的名字，这样写有利于我们编写非常短的代码闭包。 一个代码闭包可以在函数圆括号后面传给函数作为最后一个输入参数。

sort([1, 5, 3, 12, 2]) { $0 > $1 }

对象和类：

类名

我们使用class语法定义类，类的属性和定义和普通定义一个变量或常量一样没有区别，但属性要定义在类的定义块里面，类的方法和函数亦然。

class Shape {

var numberOfSides = 0

func simpleDescription() -> String {

return "A shape with \(numberOfSides) sides."

}

}

实验：

在上面的类定义中使用let语法增加一个常量属性，增加另外一个带有一个参数的方法。

创建类的实例就是在类名后面加上一对圆括号。 使用点语法存储这个类实例的属性和程序方法。

var shape = Shape()

shape.numberOfSides = 7

var shapeDescription = shape.simpleDescription()

这个版本的shape类看起来好象缺少了什么东西：一段初始化类实例的程序，那么我们使用init函数来创建一个。

class NamedShape {

var numberOfSides: Int = 0

var name: String

init(name: String) {

self.name = name

}

func simpleDescription() -> String {

return "A shape with \(numberOfSides) sides."

}

}

注意我们使用self修饰符来区别类的name属性和构造函数的name输入参数。创建一个类的实例，参数传给类的构造函数就象调用普通函数一样。类中所有的属性需要附于指定值，可以在定义的时候赋值，比如上面代码中的numberOfSides，也可以在类实例初始化过程中赋值，比如上文的name。

我们使用deinit来创建一个析构过程，当你准备释放对象，需要执行一些精理的代码你会用到它。

子类的命名是在其继承的父类名字后面加上一个冒号和它的名字。不是所有类都需要继承自标准根类。你可以在子类中定义一个与父类同名的方法，使用override保留字定义和覆盖它。如果没有使用override而重名覆盖父类的方法。编译器侦测和给出错误 。如果使用了override但却没有实际覆盖父类的任何方法的话，编译器也将侦测到。

class Square: NamedShape {

var sideLength: Double

init(sideLength: Double, name: String) {

self.sideLength = sideLength

super.init(name: name)

numberOfSides = 4

}

func area() -> Double {

return sideLength * sideLength

}

override func simpleDescription() -> String {

return "A square with sides of length \(sideLength)."

}

}

let test = Square(sideLength: 5.2, name: "my test square")

test.area()

test.simpleDescription()

实验：

编写一个NamedShape的子类，命名为Circle，使用半径值和名字作为构造函数的参数。和上面的代码类似，实现Circle类的area和describe方法。

类属性除了存储，我们还可以定义的getter和setter，即写入的方法和读取的方法。

class EquilateralTriangle: NamedShape {

var sideLength: Double = 0.0

init(sideLength: Double, name: String) {

self.sideLength = sideLength

super.init(name: name)

numberOfSides = 3

}

var perimeter: Double {

get {

return 3.0 * sideLength

}

set {

sideLength = newValue / 3.0

}

}

override func simpleDescription() -> String {

return "An equilateral triagle with sides of length \(sideLength)."

}

}

var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")

triangle.perimeter

triangle.perimeter = 9.9

triangle.sideLength

在周长的setter设置方法上，用于更新的数值默认为newValue，你可以提供显式的名字在set符号后面的圆括号中。

请注意 EquilateralTriangle类的构造函数有以下三个步骤的内容：

1、初始化继承后的各子类属性。

2、调用父类的构造函数。

3、更新父类定义的属性值、完成所有其他初始化工作，比如调用其他方法，其他getter和setter读取与设置方法都可以在这里实现。

如果你不需要计算属性的值，而是要在代码运行之前或设置新数值之后执行其他代码，那就要使用willSet和didSet。例如下面的类定义中实现正方形的边与等边三角形相同的边长。

class TriangleAndSquare {

var triangle: EquilateralTriangle {

willSet {

square.sideLength = newValue.sideLength

}

}

var square: Square {

willSet {

triangle.sideLength = newValue.sideLength

}

}

init(size: Double, name: String) {

square = Square(sideLength: size, name: name)

triangle = EquilateralTriangle(sideLength: size, name: name)

}

}

var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")

triangleAndSquare.square.sideLength

triangleAndSquare.triangle.sideLength

triangleAndSquare.square = Square(sideLength: 50, name: "larger square")

triangleAndSquare.triangle.sideLength

类的方法有一个与函数不同的地方。函数的参数只能在函数内使用，而方法可以调用你本地的变量（除了方法的第一个参数名）。方法的参数名字在方法里面是不变的，你可以定义它的别名，在方法体内代替默认的参数名使用。

class Counter {

var count: Int = 0

func incrementBy(amount: Int, numberOfTimes times: Int) {

count += amount * times

}

}

var counter = Counter()

counter.incrementBy(2, numberOfTimes: 7)

当你需要使用可选值的时候，你也可将问号附加在方法，属性名字之前。如果问号前的值是nil空值，所有的在问号之后的都被忽略，整个表达式都将置空(nil)。不为空值的话，该值将解包，所有的在问号之后的值将生效和附值。对于整个表达式来说，以上两种情况使整个表达式的值变成可选值。

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")

let sideLength = optionalSquare?.sideLength

枚举和结构:

使用enum来创建枚举。就象类和其他命名类型一样，枚举能包含存储枚举值的方法定义。

enum Rank: Int {

case Ace = 1

case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten

case Jack, Queen, King

func simpleDescription() -> String {

switch self {

case .Ace:

return "ace"

case .Jack:

return "jack"

case .Queen:

return "queen"

case .King:

return "king"

default:

return String(self.toRaw())

}

}

}

let ace = Rank.Ace

let aceRawValue = ace.toRaw()

实验：

写一个通过对比枚举的裸数值来对比它的序列值的函数。

在上文的示例程序中，枚举的裸值类型是整数，所以你只要指定好第一个枚举的裸值，其他剩余的数值将按序存放，当然你也可以使用字符串和浮点数值作为枚举的裸值类型。

你可以使用toRaw和fromRaw函数转换枚举的裸值和它的序列值。

if let convertedRank = Rank.fromRaw(3) {

let threeDescription = convertedRank.simpleDescription()

}

枚举的成员值是一个可调用的实际值，不是裸数据的别名。除非裸数据没有可读性，你无需提供名字的转换。

enum Suit {

case Spades, Hearts, Diamonds, Clubs

func simpleDescription() -> String {

switch self {

case .Spades:

return "spades"

case .Hearts:

return "hearts"

case .Diamonds:

return "diamonds"

case .Clubs:

return "clubs"

}

}

}

let hearts = Suit.Hearts

let heartsDescription = hearts.simpleDescription()

试验：

添加一个color方法到suit枚举中，对应spades和clubs返回”black”，对应hearts和diamonds返回”red”

注意这里的两种hearts枚举成员引用的方式： 当对hearts常量附值的时候，枚举成员suit.hearts是使用枚举全名，因为常量没有显式指定类型（所以无法判断是否来自枚举）。而在switch里面，枚举使用简写的.Hearts就可以访问主要是因数它的self已指向suit类型。所以你只要确定所属的类型就可以对成员进行简写式的访问。

使用struct来创建结构。结构支持很多和类一样的行为，包括方法和构造函数。两者之间最重要的区别是结构使用拷贝方式传值，而类使用引用方式传值。

struct Card {

var rank: Rank

var suit: Suit

func simpleDescription() -> String {

return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"

}

}

let threeOfSpades = Card(rank: .Three, suit: .Spades)

let threeOfSpadesDescription = threeOfSpades.simpleDescription()

试验：

Add a method to Card that creates a full deck of cards, with one card of each combination of rank and suit.

枚举成员的实例可以有对应的数值，名字相同的枚举成员可以有不同值。你可以在创建它们的时候再给予不同的值。枚举的别名数值和裸值是不同的：裸值对所有的枚举实例来说都是相同值，你可以在定义枚举的时候就提供裸值。

例如，我们写一个服务器程序提供获取太阳的升起和日落的时间计算功能，程序返回计算结果或返回计算错误信息，程序如下

enum ServerResponse {

case Result(String, String)

case Error(String)

}

let success = ServerResponse.Result("6:00 am", "8:09 pm")

let failure = ServerResponse.Error("Out of cheese.")

switch success {

case let .Result(sunrise, sunset):

let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."

case let .Error(error):

let serverResponse = "Failure... \(error)"

}

试验：

为ServerResponse和 switch添加第三个case。

请注意代码中经过switch判断，从ServerResponse返回的surise和sunset times的过程机制。

协议和扩展：

我们使用protocol关键字定义协议

protocol ExampleProtocol {

var simpleDescription: String { get }

mutating func adjust()

}

类、枚举和结构可以采用和声明协议(protocols)。

class SimpleClass: ExampleProtocol {

var simpleDescription: String = "A very simple class."

var anotherProperty: Int = 69105

func adjust() {

simpleDescription += " Now 100% adjusted."

}

}

var a = SimpleClass()

a.adjust()

let aDescription = a.simpleDescription

struct SimpleStructure: ExampleProtocol {

var simpleDescription: String = "A simple structure"

mutating func adjust() {

simpleDescription += " (adjusted)"

}

}

var b = SimpleStructure()

b.adjust()

let bDescription = b.simpleDescription

试验：

编写一个遵守这个protocol的枚举类型。

注意上文程序中使用mutating关键字在SimpleStructure结构中对方法进行修改（结构是静态的）。而 SimpleClass类不需要使用 mutating关键字修饰 adjust 主要是因为类中就可以进行类的修改（类是动态的）。

使用extension对现有的类型添加新功能，比如新的方法或计算属性。你可以使用extension对定义在其他地方的类型添加协议，甚至是你从其他的框架和库导入的类。

extension Int: ExampleProtocol {

var simpleDescription: String {

return "The number \(self)"

}

mutating func adjust() {

self += 42

}

}

7.simpleDescription

试验：

为Double类型添加了个absoluteValue属性作为对该类型的扩展。

你可以和使用其他命名类型一样使用协议，比如你创建一个不同类的对象实例集合，但又实现自相同的协议。

当你继承协议，你可以存储它的属性数值，但直接调用它的方法将会报错（协议方法需要在继承中另外实现）。

let protocolValue: ExampleProtocol = a

protocolValue.simpleDescription

// protocolValue.anotherProperty // Uncomment to see the error

虽然protocolValue是 ExampleProtocol的实例，而 ExampleProtocol有一个继承类叫SimpleClass，但编译把它当然是独立的解释ExampleProtocol的类型，并不是对协议的扩展，你不能在独立实例化ExampleProtocol的ProtocolValue中调用它的方法和属性。

泛型

在一对尖括号之间的命名代表泛化的类型或函数

func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {

var result = ItemType[]()

for i in 0..times {

result += item

}

return result

}

repeat("knock", 4)

你可以编写泛化后的函数和方法，也可以编写泛化类、泛化枚举、结构。

// Reimplement the Swift standard library's optional type

enum OptionalValue<T> {

case None

case Some(T)

}

var possibleInteger: OptionalValue<Int> = .None

possibleInteger = .Some(100)

在类名后面使用where命令来指定类型必须满足的条件，比如下面的代码是要实现一个协议接口，需要满足where规定的两个类型约束条件。

func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {

for lhsItem in lhs {

for rhsItem in rhs {

if lhsItem == rhsItem {

return true

}

}

}

return false

}

anyCommonElements([1, 2, 3], [3])

试验：

修改anyCommonElements函数，实现把两个序列的共同元素组成数组并返回。

在简单的情况下，你可以忽略where命令简单把protocol或类名写在冒号后面。编写 <T: Equatable>是和 <T where T: Equatable>.相等同的。