一看Swift官方文档（一）

2016-11-25 本文已影响94人 IAMDAEMON

上次在群里问了个 \self ` = self ` 的语法，有人说这个文档里就有，瞬间觉得应该好好从文档开始学起，于是就有了这个系列。一看先过一遍文档记录笔记，二看将文档里比较常用和重要的特性具体讲解，不确定是否有三看这个东西了。（慢慢填坑）

基础部分

类型标注

可以在一行中定义多个同样类型的变量，并在最后一个变量名后添加类型标注:
var red, green, blue: Double

一般来说，很少需要写类型标注，只要我们在声明一个常量/变量的时候赋了一个初始值，Swift会推断出这个常量/变量的类型

数值型字面量

十进制，没有前缀
二进制，0b
八进制，0o
十六进制，0x

数值字面量可以通过增加额外的 0 和 _ 来增强可读性:

let paddedDouble = 000123.456    
let oneMillion = 1_000_000   
let justOverOneMillion = 1_000_000.000_000_1

类型别名

类型别名(type aliases)就是给现有类型定义另一个名字。你可以使用 typealias 关键字来定义类型别名。

typealias AudioSample = UInt16  
var maxAmplitudeFound = AudioSample.min 
// maxAmplitudeFound 现在是 0

元组

let http404Error = (404, "Not Found")

元组分解：

赋值给常量/变量

let (statusCode, statusMessage) = http404Error 
print("The status code is \(statusCode)")
// 输出 "The status code is 404"
print("The status message is \(statusMessage)") 
// 输出 "The status message is Not Found"

使用`_`忽略部分元组值

let (justTheStatusCode, _) = http404Error 
print("The status code is \(justTheStatusCode)") 
// 输出 "The status code is 404"

使用下标

print("The status code is \(http404Error.0)")
// 输出 "The status code is 404"
print("The status message is \(http404Error.1)") 
// 输出 "The status message is Not Found"

给元素命名

let http200Status = (statusCode: 200, description: "OK")

print("The status code is \(http200Status.statusCode)")
// 输出 "The status code is 200"
print("The status message is \(http200Status.description)")
// 输出 "The status message is OK"

可选类型

nil 不能用于非可选的常量和变量。

Swift 的 nil 和 Objective-C 中的 nil 并不一样。

在 Objective-C 中， nil 是一个指向不存在对象的指针。
在 Swift 中， nil 不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选状态都可以被设置为 nil ，不只是对象类型。

错误处理

在函数声明时添加 throws

func canThrowAnError() throws {   
    // 这个函数有可能抛出错误
}

在表达式中前置 try 关键字

do {
    try canThrowAnError() 
    // 没有错误消息抛出
} catch {
    // 有一个错误消息抛出
}

基本运算符

空合运算符

a ?? b
如果a包含值就进行解封，否则返回默认值b

如果 a 为非空值( non-nil )，那么值 b 将不会被计算。这也就是所谓的短路求值。

字符串和字符

使用字符

characters

遍历获取每个字符的值

for character in "Dog!?".characters {
    print(character)
}
// D
// o
// g
// !
// ?

字符串插值

let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)" 
// message 是 "3 times 2.5 is 7.5"

集合类型

创建带有默认值的数组

var threeDoubles = Array(repeating: 0.0, count: 3)

数组的遍历

如果我们同时需要每个数据项的值和索引值，可以使用 enumerated() 方法来进行数组遍历。

for (index, value) in shoppingList. enumerated() {
    print("Item \(String(index + 1)): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

可哈希化

数组、集合、字典需要遵循 Hashable 协议

字典遍历

使用元组遍历字典

for (airportCode, airportName) in airports {
    print("(airportCode): (airportName)")
}
// YYZ: Toronto Pearson
// LHR: London Heathrow

控制流

switch不存在隐式的贯穿

与C和OC不同，在swift中，当匹配的 case 分支中的代码执行完毕后，程序会终止 switch 语句，因此，不需要在 case 分支显式的使用 break

区间匹配

在swift中，case 分支的模式也可以是一个值的区间。

值绑定

case 分支允许将匹配的值绑定到一个临时的常量或变量，并且在case分支体内使用

let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
    print("on the x-axis with an x value of \(x)")
case (0, let y):
    print("on the y-axis with a y value of \(y)")
case let (x, y):
    print("somewhere else at (\(x), \(y))")
}
// 输出 "on the x-axis with an x value of 2"

where

case 分支的模式可以使用 where 语句来判断额外的条件。

贯穿

swift的switch是会提早终止的，不像C和OC中的switch，如果要像C语言标准中的switch语句特性一样，需要加入fallthrough关键字

let integerToDescribe = 5
var description = "The number \(integerToDescribe) is"
switch integerToDescribe {
case 2, 3, 5, 7, 11, 13, 17, 19:
    description += " a prime number, and also"
    fallthrough
default:
    description += " an integer."
}
print(description)
// 输出 "The number 5 is a prime number, and also an integer."

注意: fallthrough 关键字不会检查它下一个将会落入执行的 case 中的匹配条件。 fallthrough 简单地使代码继续连接到下一个 case 中的代码，这和 C 语言标准中的 switch 语句特性是一样的。

带标签的语句

当使用嵌套循环体时，可以使用标签来标记一个循环体或条件语句

gameLoop: while square != finalSquare {
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    switch square + diceRoll {
    case finalSquare:
        // 骰子数刚好使玩家移动到最终的方格里，游戏结束。
        break gameLoop
    case let newSquare where newSquare > finalSquare:
          // 骰子数将会使玩家的移动超出最后的方格，那么这种移动是不合法的，玩家需要重新掷骰子
        continue gameLoop
    default:
        // 合法移动，做正常的处理 square += diceRoll
        square += board[square]
    }
}
print("Game over!")

提前退出

使用guard let 进行条件判断并提前退出

func greet(person: [String: String]) {
    guard let name = person["name"] else {
        return 
     }
    print("Hello \(name)")
    guard let location = person["location"] else {
        print("I hope the weather is nice near you.")
        return 
    }
    print("I hope the weather is nice in \(location).")
}
greet(["name": "John"])
// 输出 "Hello John!"
// 输出 "I hope the weather is nice near you." greet(["name": "Jane", "location": "Cupertino"]) // 输出 "Hello Jane!"
// 输出 "I hope the weather is nice in Cupertino."

检测API的可用性

if #available(iOS 10, macOS 10.12, *) {
    // 在 iOS 使用 iOS 10 的 API, 在 macOS 使用 macOS 10.12 的 API
} else {
    // 使用先前版本的 iOS 和 macOS 的 API
}

函数

函数参数与返回值

一个函数的返回值可以用 _ 进行忽略
可以返回一个元组
可选元组返回类型

可选元组类型如 (Int, Int)? 与元组包含可选类型如 (Int?, Int?) 是不同的.可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。

可变参数
一个可变参数(variadic parameter)可以接受零个或多个值。
通过在变量类型名后面加入( ... )的方式来定义可变参数。

一个函数最多只能拥有一个可变参数。

输入输出参数
在参数定义前使用 inout 关键字来定义一个输入输出参数。

输入输出参数不能有默认值，而且可变参数不能用 inout 标记。

输入输出参数和返回值是不一样的。输入输出参数是函数对函数体外产生影响的另一种方式。

函数类型

var mathFunction: (Int, Int) -> Int = addTwoInts

定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值得函数’，并让这个新变量指向 addTwoInts 函数

函数类型可以作为函数参数
函数类型可以作为函数的返回类型

函数体里可以嵌套函数

闭包

全局函数是一个有名字但不会捕获任何值的闭包
嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包

闭包表达式的一般语法

 { (parameters) -> returnType in
     statements
}

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
     return s1 > s2
})

根据上下文推断类型

实际上，通过内联闭包表达式构造的闭包作为参数传递给函数或方法时，总是能够推断出闭包的参数和返回值类型。这意味着闭包作为函数或者方法的参数时，你几乎不需要利用完整格式构造内联闭包。

 reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )

单表达式闭包隐式返回

单行表达式闭包可以通过省略 return 关键字来隐式返回单行表达式的结果

reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )

参数名称缩写

Swift 自动为内联闭包提供了参数名称缩写功能，你可以直接通过$0, $1, $2 来顺序调用闭包的参数，以此类推。

in 关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成

reversedNames = names.sorted(by: { $0 > $1 } )

运算符方法

Swift 的 String 类型定义了关于大于号(>)的字符串实现，其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值。

reversedNames = names.sorted(by: >)

尾随闭包

如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。
尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
在使用尾随闭包时，你不用写出它的参数标签

reversedNames = names.sorted() { $0 > $1 }

如果闭包表达式是函数或方法的唯一参数，则可以把 () 省略掉:

reversedNames = names.sorted { $0 > $1 }

值捕获

为了优化，如果一个值不会被闭包改变，或者在闭包创建后不会改变，Swift 可能会改为捕获并保存一份对值的拷贝。 Swift 也会负责被捕获变量的所有内存管理工作，包括释放不再需要的变量。

闭包是一个引用类型

无论你将函数或闭包赋值给一个常量还是变量，你实际上都是将常量或变量的值设置为对应函数或闭包的引用。

逃逸闭包

当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。
通过在参数名之前标注 @escaping ，用来指明这个闭包是允许“逃逸”出这个函数的。
将一个闭包标记为 @escaping 意味着你必须在闭包中显式地引用 self

自动闭包

自动闭包是一种自动创建的闭包，用于包装传递给函数作为参数的表达式。这种闭包不接受任何参数，当它被调用的时候，会返回被包装在其中的表达式的值。
自动闭包让你能够延迟求值，因为直到你调用这个闭包，代码段才会被执行。

过度使用 autoclosures 会让你的代码变得难以理解。上下文和函数名应该能够清晰地表明求值是被延迟执行的。