官文：从今天开始开发iOS应用（Swift）第一章1~3节纯中文

《Start developing iOS APPs today：官文iOS开发新手引导》

————————————————————————————————————————————————————————————

第一章 Learn the Essentials of Swift：Swift概述

文档中的所有代码都使用XCode的Playground工具进行演示。

Playground允许用户同自己的代码进行实时交互。通过Playground，用户可以快速对自己的代码功能进行验证。

所以，利用它可以快速掌握Swift的基本概念。

1.1 Learning Objectives：要点一览

经过本文的学习，您将能够：

1. 区分Swift中的常量（Constant）和变量（Variable）；
2. 知道何时需要进行显式类型声明；
3. 了解使用optional以及optional binding的优势之处；
4. 知道optional和隐式解包optional的区别；
5. 明白条件语句和循环语句的作用；
6. 知道switch语句的用法，以及它同二元选择的不同；
7. 使用where语句为条件语句增加额外的条件限制；
8. 知道函数、方法及初始化器的不同之处；
9. 知道类、结构体和枚举之间的不同；
10. 知道如何使用继承（inheritance）和协议（protocol），以及它们背后的基本原理；
11. 知道如何使用Xcode的快速帮助来确定变量隐式类型以及额外信息；
12. 了解如何导入和使用UIKit框架。

1.2 Basic Types：基本数据类型

1.2.1 常量和变量：

常量：指的是值在定义时指定，并且运行时保持不变的量。

变量：指的是值可以随意改变的量。

一个常量也被称为不可变量（immutable），即它的值在运行时不能被改变；而变量则被称为可变量。

如果确定一个值在代码中不会被改变，则可以将它定义为一个常量。

1.2.2 常量和变量的定义

在Swift中，用let关键字来定义常量，用var关键字来定义变量：

var myVariable = 42     //定义一个变量myVariable，值为42
myVariable = 50         //改变myVariable的值成50
let myConstant = 42     //定义一个常量myConstant，值为42

1.2.3 类型推断

Swift中所有的常量或变量都有自己的数据类型，但并不是每次都需要进行显式类型声明。在实际中，可以直接为变量或常量提供一个值，然后由编译器来推断它的数据类型。上面的代码中，编译器推断myVariable的类型为integer，因为它是由一个整型数据初始化而来的，这个由编译器确定量值类型的过程被称为类型推断（type inference）。并且一旦常量或变量拥有类型，便无法再次修改。

如果用于初始化的值无法提供足够的类型信息（或者没有在定义变量的时候对其进行初始化），此时就必须显式指定类型：

let implicitInteger = 70    //常量类型为integer
let implicitDouble = 70.0   //常量类型为double
let explicitDouble: Double = 70     //显式指定类型为double，即使用于初始化这个常量的数为一个整型数

1.2.4 类型转换

Swift中不会进行隐式类型转换。如果你想将一个值转换为其他类型，需要显式地进行类型转换。下面的代码中将一个整型转换为一个字符串类型：

let label = "The width is "
let width = 94
let widthLabel = label + String(width)  //将width转换为字符串类型，并连接到label字符串的尾部

还有一种简单的方法可以实现上面代码中的功能：将数值写在括号内，然后再加上“\”前导。这个方法被称为字符串插值法（string interpolation）：

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."   //I have 3 apples.
let fruitSummary = "I have \(apples + oranges) pieces of fruit."    //I have 8 pieces of fruit.

1.2.5 可选类型（optionals）

使用可选类型来表示那些值可能是nil的量。可选类型量或含有值，或包含nil（即无值）。在变量类型之后添加一个问号“?”表示可选类型：

let optionalInt: Int? = 9

1.2.6 可选类型解包（unwrap）

为获取可选类型量的值，需要对其进行解包（unwrap，对应封包wrap），在后面将学习如何对可选类型量进行解包操作（unwrapping）。这里有一个最为直接的解包办法，就是使用强制解包操作符“!”，需要注意被解包的可选类型量值必须非空：

let actualInt: Int = optionalInt!   //对optionalInt解包后，将其赋值给actualInt

可选类型在Swift中使用十分普遍，尤其是在尝试类型转换时：

var myString = "7"
//possibleInt的声明自动为：var possibleInt : Int?
var possibleInt = Int(myString)     //possibleInt值为7
//若将myString改变为无法转换成整型的值，则possibleInt为nil
myString = "banana"
possibleInt = Int(myString)     //possibleInt值为nil

代码中，possibleInt的值为7，因为myString字符串里为“7”。但是如果你改变myString的值，让它无法转换为整型，那么possibleInt的值就会是nil。（这样的好处是不用考虑myString是否可以转换为整型，编程更加灵活）

1.2.7 数组（Array）

数组：是一个包含多个元素的有序集合。

数组可以对自己内部的所有元素进行追踪。使用方括号“[]”建立数组，如果想访问数组中某个元素，则在方括号内指定元素下标进行访问，并且，数组起始下标为0：

//定义数组ratingList
var ratingList = ["Poor", "Fine", "Good", "Excellent"]
//修改第二个元素为OK
ratingList[1] = "OK"
//打印数组
ratingList

可以使用初始化器（initializer）语法建立一个空数组（之后会学习更多关于初始化器的相关内容）：

// 建立一个空数组，元素类型为String
let emptyArray = [String]()

1.2.7 隐式已解包可选类型（implicitly unwrapped optional）

隐式已解包可选类型：指的是不需要每次访问都进行解包操作的可选类型。

隐式已解包可选类型假定该类型量的值一旦初始化后就一直都是非空。

使用“!”代替”?”进行定义：

var implicitlyUnwrappedOptionalInt: Int!

实际使用时很少自定义隐式已解包可选类型，它们更多地被用在界面接口和源代码之间的连接追踪中。

1.3 Control Flow：流程控制

Swift中有两类流程控制语句：条件语句，如if或switch。循环语句，如for in以及while。(废话未翻)

1.3.1 条件语句：

let number = 23

if number < 10
{
    print("The number is small")
}
else if number > 100
{
    print("The number is pretty big")
}
else
{
    print("The number is between 10 and 100")
}

1.3.2 语句嵌套

下面代码中在if-else中嵌套了一个for-in语句(for in 语句按顺序遍历集合中每一个元素)：

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores
{
    if score > 50
    {
        teamScore += 3
    }
    else
    {
        teamScore += 1
    }
}
print(teamScore)

1.3.3 可选绑定

在if中使用可选绑定（optional binding）来判断可选类型量中是否包含有值：

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
//let name = optionalName，若optionalName不空，则条件为真
if let name = optionalName
{
    greeting = "Hello, \(name)"
}

如果可选类型的值为nil，则条件为假。反之，则将可选类型变量optionalName解包并赋值给常量name。

1.3.4 where语句

利用where语句，可以在单一if条件判断中绑定多个值，即利用where可以扩展条件语句的判断范围。下面的例子中，只有当绑定的所有值和所有条件都真时才执行if后面的语句块内容：

var optionalHello: String? = "Hello"
//当optionalHello非空，且hello的前缀为H，并且optionalName非空，才为真
if let hello = optionalHello where hello.hasPrefix("H"), let name = optionalName
{
    greeting = "\(hello), \(name)"
}

1.3.5 switch语句

switch语句支持任意类型数据的判断，以及多种比较操作：并不局限于整型和判等测试。下面的例子中对vegetable字符串进行判断，匹配相应条件：

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."
}

需要注意的是：每一个switch都必须有一个default。

在switch语句中同样可以使用where来添加更多判断条件。并且不同于if，如果有逗号分隔的多个条件，则只要任意一个条件满足，就执行对于语句。

当执行完匹配的case后，程序会自动退出switch语句（不用再break了）。

另外，switch语句必须拥有一个default分支。

1.3.6 循环区间

可以使用区间（Range）来表示循环下标。使用半开区间操作符“..<”指定下标范围：

var firstForLoop = 0
for i in 0..<4 {
    firstForLoop += i
}
print(firstForLoop)

半开区间操作符中不包含上界，即上面的例子中0..<4，实际是从0到3循环4次。如果需要包含范围的上界，则可以使用闭区间操作符“…”。

var secondForLoop = 0
for _ in 0...4 {
    secondForLoop += 1
}
print(secondForLoop)

上面的代码中循环区间为0到4，共5次循环。下划线“_”表示一个通配符，即当你不需要使用特定循环变量的时候，就可以用下划线代替特定循环变量。