A Swift Tour

发表于 分类于 本文字数： 4.4k

原文：https://docs.swift.org/swift-book/GuidedTour/GuidedTour.html

Hello World

1
2
print("Hello, world!")
// Prints "Hello, world!"

以上是一个完整程序

从中可以看出 swift 的特点有：

  • 不需要引入库就能够输入输出
  • 不需要 main 函数，写在全局作用域的代码即作为程序入口点
  • 每行代码不需要结束符

该教程以完成一个个任务的形式带你熟悉 swift 这门语言

简单量

使用 let 定义一个常量，var定义一个变量。

1
2
3
var myVariable = 42
myVariable = 50
let myConstant = 42

swift 是有类型语言，但不一定总是需要书写出类型，编译器可以通过初值推算出变量的类型

如果需要手动指定类型，将类型写在变量名之后：

1
2
3
let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70

一种类型的量不会自动转换成另外一种类型，只能手动转换

1
2
3
let label = "The width is "
let width = 94
let widthLabel = label + String(width)

可以将变量的值插入字符串中

1
2
3
4
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

用三引号书写多行字符串

1
2
3
4
let quotation = """
I said "I have \(apples) apples."
And then I said "I have \(apples + oranges) pieces of fruit."
"""

使用方括号创建和访问列表和字典

1
2
3
4
5
6
7
8
var fruits = ["strawberries", "limes", "tangerines"]
fruits[1] = "grapes"

var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

调用 append 向数组添加元素

1
2
fruits.append("blueberries")
print(fruits)

要创建空列表或字典，使用初始化语法

1
2
let emptyArray: [String] = []
let emptyDictionary: [String: Float] = [:]

在向变量赋值或向函数传值等类型可知的时候，可以用[]创建空列表，[;]创建空字典。

流程控制

使用 if 或 switch 执行条件判断，使用 for-in, while, repeat-while 构建循环，条件表达式和循环变量可以用小括号括起来，也可以不括

1
2
3
4
5
6
7
8
9
10
11
let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
print(teamScore)
// Prints "11"

if

if 语句的条件表达式必须是一个布尔表达式，像 if score { ... } 这样的语句是错误的。

组合使用 if 和 let 来处理可为空的量，可为空的量可以表示正常的值或 nil，当它为 nil 时，表示缺少正常的值，在类型的后面写上 ? 来创建一个可为空的量

1
2
3
4
5
6
7
8
9
var optionalString: String? = "Hello"
print(optionalString == nil)
// Prints "false"

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}

如果 optionalName 不为 nil，将其值赋值给在分支内可用的 name，执行分支，否则，不执行分支

使用 ?? 运算符为可为空变量设置默认值，表达式 A ?? B 中，如果 A 的值为 nil，则表达式的值为默认值 B

1
2
3
let nickname: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickname ?? fullName)"

在 if 语句中处理可为空量时，也可以省略创建一个局部变量（常量？）的过程，在分支中直接访问原变量。

1
2
3
if let nickname {
    print("Hey, \(nickname)")
}

switch

switch 支持任意数据类型，和多种比较运算

1
2
3
4
5
6
7
8
9
10
11
12
let vegetable = "red pepper"
switch vegetable {
case "celery":
    print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
default:
    print("Everything tastes good in soup.")
}
// Prints "Is it a spicy red pepper?"

let 可以在模式中使用，将匹配模式的值赋值给给定常量。

switch 执行完匹配的 case 会自动退出，swift 不需要 break 关键字手动退出

for-in

可以用 for-in 迭代字典中的键值对，字典是无序容器，因此迭代的顺序是任意的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (_, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest)
// Prints "25"

while

while循环在指定条件满足时循环，而 repeat…while 循环至少循环一次。

1
2
3
4
5
6
7
8
9
10
11
12
13
var n = 2
while n < 100 {
    n *= 2
}
print(n)
// Prints "128"

var m = 2
repeat {
    m *= 2
} while m < 100
print(m)
// Prints "128"

使用 ..<，每次循环可以得到一个下标，..<产生的下标不包含上限，而...包含上限。

1
2
3
4
5
6
var total = 0
for i in 0..<4 {
    total += i
}
print(total)
// Prints "6"

函数和闭包

函数

使用 func 关键字定义函数

1
2
3
4
func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")

可以在函数参数名前面声明参数的标签，如果不声明，参数标签默认为参数名，如果声明为’_’, 则表示不使用标签

1
2
3
4
func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

可以以元组形式从函数返回多个值，元组的元素可以用下标或名字访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[0]
    var max = scores[0]
    var sum = 0

    for score in scores {
        if score > max {
            max = score
        } else if score < min {
            min = score
        }
        sum += score
    }

    return (min, max, sum)
}
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
print(statistics.sum)
// Prints "120"
print(statistics.2)
// Prints "120"

闭包

函数内可以嵌套函数，内层函数可以访问外层函数定义的变量。

1
2
3
4
5
6
7
8
9
func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()

函数是一等公民，一个函数可以返回另外一个函数作为返回值。

1
2
3
4
5
6
7
8
func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)

函数可以接受另一个函数作为它的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
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(list: numbers, condition: lessThanTen)

函数实际上也是一种形式的闭包，闭包可以访问闭包被定义的作用域内存在的变量、函数等，而无关闭包在哪个作用域被执行。

匿名闭包

使用花括号可以定义匿名闭包，使用 in 关键字分隔函数签名和函数体

1
2
3
4
numbers.map({ (number: Int) -> Int in
    let result = 3 * number
    return result
})

在闭包类型可知时，例如在将闭包作为参数传递的情形，可以省略闭包的参数类型、返回值类型

单语句闭包默认返回它仅有那条语句的值

1
2
3
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
// Prints "[60, 57, 21, 36]"

作为函数最后一个参数传入的闭包，可以书写在函数调用的小括号之后。

1
WindowGroup () { ContentView() }

如果闭包是函数仅有的参数，你可以省略调用函数的一对小括号

1
WindowGroup { ContentView() }

你可以用参数序号代替参数名访问闭包的参数，这在书写小闭包时尤其方便。

1
2
3
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
// Prints "[20, 19, 12, 7]"

类和对象

使用 class 关键字定义类，类成员变量的定义方法与常规定义变量和常量的方法相同。

函数和方法的定义方式也没有什么不同。

1
2
3
4
5
6
class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

实例化

在类名后书写一对小括号创建类的实例，使用点号访问实例的属性和方法。

1
2
3
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

类中特殊的 init 函数为类的构造函数，在创建类的实例时会自动调用一次。

1
2
3
4
5
6
7
8
9
10
11
12
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 访问实例本身。

类中每个成员变量都需要初值，可以在成员变量定义时或构造函数中赋初值。

deinit 函数为类的析构函数，析构函数在实例销毁时被调用。

子类

在类名后声明父类名称来创建子类，在 swift 中，不要求一个类至少继承一个父类。

在子类中，使用 override 关键字覆盖父类中同名方法。子类中存在名称与父类方法完全一致的方法而没有标记为 override 将视为错误，同样，一个标记了 override 的子类方法事实上没有覆盖任何一个父类方法也是错误的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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()

getter, setter

除了基本的成员变量型属性，你还可以定义 getter，setter 型属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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 triangle with sides of length \(sideLength)."
    }
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
// Prints "9.3"
triangle.perimeter = 9.9
print(triangle.sideLength)
// Prints "3.3000000000000003"

在属性的 setter 函数中，新值的默认变量名为 newValue，也可以在 set 后自定义新值变量名。

在 EquilateralTriangle 类的构造函数中，我们需要注意语句顺序

  • 初始化子类定义的成员变量
  • 调用父类的构造函数
  • 修改父类定义的属性。任何用到方法，getter、setter的初始化工作也可以在此刻完成

willSet, didSet

如果你希望属性在修改前后执行一段代码，可以使用 willSet，didSet 关键字。属性在构造函数外产生任何修改时，都将执行这段代码。例如，下面的例子可以确保，它 triangle 的 sideLength 总是和 square 的 sideLength 相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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")
print(triangleAndSquare.square.sideLength)
// Prints "10.0"
print(triangleAndSquare.triangle.sideLength)
// Prints "10.0"
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)
// Prints "50.0"

可为空安全性

针对可为空的对象，可以在方法调用、属性访问、下标索引等操作前插入 ?，如果 ? 前的值为 nil，所有 ? 后面的操作都会忽略，整个表达式的结果也将是 nil。否则，将在非 nil 的值上执行操作。无论是哪种情况，整个表达是的结果类型都是可为空的。

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

枚举和结构

枚举

使用 enum 关键字创建枚举，枚举可以拥有成员函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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.rawValue)
        }
    }
}
let ace = Rank.ace
let aceRawValue = ace.rawValue

默认情况下，枚举元素的值从 0 开始依次递增。你也可以显式为元素赋值去改变这个行为，被赋值元素后的其他元素将在该元素的基础上递增。上例中，枚举 Rank 的原始类型是 Int，还可以使用字符串和浮点型作为原始类型。枚举元素的 .rawValue 属性可以访问原始值。

使用 init?(rawValue:) 将一个原始类型的值转换为枚举元素，如果对应元素存在，则返回，否则返回 nil

1
2
3
if let convertedRank = Rank(rawValue: 3) {
    let threeDescription = convertedRank.simpleDescription()
}

枚举元素并不是它原始值的另一种写法，它是实际存在的值。如果无法为枚举找到有意义的原始值，也可以不提供它们。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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()

访问枚举元素，除了使用全限定名外，例如上例的 Suit.hearts。在枚举类型已知时，如上例 switch 语句中，还可以仅使用点号+枚举元素名。

动态原始值

通常，枚举元素的原始值在定义时就决定下来了。这意味着，所有枚举元素的实例都具有相同的原始值。

还有一种选择是让原始值与每个枚举元素的实例关联，枚举元素的值是在实例化那一刻决定的，因此，枚举元素的每个实例都可以拥有不同的值，可以想象实例的值是以属性的形式存储在枚举元素实例上的。

如下例，欲从服务器取得日出和日落时间，服务器或返回正确的信息，或返回错误原因

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
enum ServerResponse {
    case result(String, String)
    case failure(String)
}

let success = ServerResponse.result("6:00 am", "8:09 pm")
let failure = ServerResponse.failure("Out of cheese.")

switch success {
case let .result(sunrise, sunset):
    print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
case let .failure(message):
    print("Failure...  \(message)")
}
// Prints "Sunrise is at 6:00 am and sunset is at 8:09 pm."

以上示例，请注意值的取出方法。

结构

使用 struct 关键字创建结构，结构和类相似，最重要区别之一是结构的实例总是拷贝传递的，而类实例则总是引用传递的。

1
2
3
4
5
6
7
8
9
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()

并发

使用 async 关键字标记一个函数可以异步运行

1
2
3
4
5
6
func fetchUserID(from server: String) async -> Int {
    if server == "primary" {
        return 97
    }
    return 501
}

用 await 关键字标记一个对异步函数的调用。

1
2
3
4
5
6
7
func fetchUsername(from server: String) async -> String {
    let userID = await fetchUserID(from: server)
    if userID == 501 {
        return "John Appleseed"
    }
    return "Guest"
}

用 async let 调用异步函数，让它与其他异步代码并行运行

使用它的返回值时，写上 await

1
2
3
4
5
6
func connectUser(to server: String) async {
    async let userID = fetchUserID(from: server)
    async let username = fetchUsername(from: server)
    let greeting = await "Hello \(username), user ID \(userID)"
    print(greeting)
}

在同步代码中使用 Task 调用异步代码，不需要等待它返回。

1
2
3
4
Task {
    await connectUser(to: "primary")
}
// Prints "Hello Guest, user ID 97"

协议和扩展

协议

使用 protocol 关键字定义协议

1
2
3
4
protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}

类，枚举，结构都可以去适配协议

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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

上例，SimpleStructure 中 adjust 方法被标记为 mutating 是因为方法需要修改结构成员，而类的定义中不需要 mutating 是因为类成员函数总是可以修改类成员。

扩展

使用 extension 扩展现有类型功能。比如：可以利用扩展让类型符合协议，不论类型是定义在哪里的。

1
2
3
4
5
6
7
8
9
10
extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
}
print(7.simpleDescription)
// Prints "The number 7"

错误处理

Error

可以用任何适配 Error 协议的类型表示错误。

1
2
3
4
5
enum PrinterError: Error {
    case outOfPaper
    case noToner
    case onFire
}

使用 throw 关键字抛出错误，使用 throws 关键字标记一个函数会抛出错误。

如果在函数中抛出错误，函数的执行立即终止，调用该函数的地方需要处理抛出的错误。

1
2
3
4
5
6
func send(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == "Never Has Toner" {
        throw PrinterError.noToner
    }
    return "Job sent"
}

do-catch

有多种方法处理错误，其一是 do-catch，在 do 块中，用 try 标记可能会抛出错误的调用，在 catch 块中，抛出的错误被自动命名为 error，你也可以指定其他名字。

1
2
3
4
5
6
7
do {
    let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
    print(printerResponse)
} catch {
    print(error)
}
// Prints "Job sent"

catch块可有多个，在 catch 后声明要匹配的模式，用以捕获具体的错误。

1
2
3
4
5
6
7
8
9
10
11
do {
    let printerResponse = try send(job: 1440, toPrinter: "Gutenberg")
    print(printerResponse)
} catch PrinterError.onFire {
    print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
    print("Printer error: \(printerError).")
} catch {
    print(error)
}
// Prints "Job sent"

try?

接下来，你也可以使用 try? 将结果表示为可为空值，如果函数抛出错误，抛出的错误会被忽略，结果为nil，如果没抛出错误，结果为函数返回值

1
2
let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")

defer

使用 defer 声明要在函数返回前运行的代码，即使函数抛出错误也一样会运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]

func fridgeContains(_ food: String) -> Bool {
    fridgeIsOpen = true
    defer {
        fridgeIsOpen = false
    }

    let result = fridgeContent.contains(food)
    return result
}
fridgeContains("banana")
print(fridgeIsOpen)
// Prints "false"

泛型

使用一对尖括号定义泛型参数

1
2
3
4
5
6
7
8
func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
    var result: [Item] = []
    for _ in 0..<numberOfTimes {
        result.append(item)
    }
    return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

可以定义泛型的函数、方法、类、枚举、结构

1
2
3
4
5
6
7
// Reimplement the Swift standard library's optional type
enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)

类型参数限制

在代码块前书写 where 子句声明对泛型参数的要求，例如，要求泛型参数必须符合某协议，要求两个类型相同，要求某参数必须是一个父类的子类

1
2
3
4
5
6
7
8
9
10
11
12
13
func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
    where T.Element: Equatable, T.Element == U.Element
{
    for lhsItem in lhs {
        for rhsItem in rhs {
            if lhsItem == rhsItem {
                return true
            }
        }
    }
    return false
}
anyCommonElements([1, 2, 3], [3])

在书写时，<T: Equatable> 等同于 <T> ... where T: Equatable。

扩展阅读