断言

例

1

NSAssert(self.finishedBlock != nil, @"图片下载完成的回调(finishedBlock)不能为空");

可选类型可以让你判断值是否存在，你可以在代码中优雅地处理值缺失的情况。然而，在某些情况下，如果值缺失或者值并不满足特定的条件，你的代码可能没办法继续执行。这时，你可以在你的代码中触发一个断言（assertion）来结束代码运行并通过调试来找到值缺失的原因。

使用断言进行调试

断言会在运行时判断一个逻辑条件是否为true。从字面意思来说，断言“断言”一个条件是否为真。你可以使用断言来保证在运行其他代码之前，某些重要的条件已经被满足。如果条件判断为true，代码运行会继续进行；如果条件判断为false，代码运行停止，你的应用被终止。

如果你的代码在调试环境下触发了一个断言，比如你在 Xcode 中构建并运行一个应用，你可以清楚地看到不合法的状态发生在哪里并检查断言被触发时你的应用的状态。此外，断言允许你附加一条调试信息。

你可以使用全局assert函数来写一个断言。向assert函数传入一个结果为true或者false的表达式以及一条信息，当表达式为false的时候这条信息会被显示：

1
2
3

let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// 因为 age < 0，所以断言会触发

在这个例子中，只有age >= 0为true的时候，即age的值非负的时候，代码运行才会继续。如果age的值是负数，就像代码中那样，age >= 0为false，断言被触发，结束应用。

断言信息如果不需要，可以被省略，就像这样：

1

assert(age >= 0)

何时使用断言

当条件可能为假时使用断言，但是最终一定要保证条件为真，这样你的代码才能继续运行。断言的适用情景：

整数类型的下标索引被传入一个自定义下标脚本实现，但是下标索引值可能太小或者太大。
需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。
一个可选值现在是nil，但是后面的代码运行需要一个非nil值。
请参考下标脚本和函数。

注意：
断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而，在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。

Swift控制流: 如何理解 if let 与guard?

if let 和 guard 只是语法糖，没有也可以，但有了可以使得代码更简洁方便。要理解 if let 和 guard，不妨设想假如没有这两者，代码会怎么写。

if let

1
2
3
4
5
6
7
8

func doSomething(str: String?)
{
    let v: String! = str
    if v != nil
    {
        // use v to do something
    }
}

Swift 中因为有optional, 经常需要判断是否为空。假如没有if let，大致写成上面的样子，有了 if let, 可以改写成:

1
2
3
4
5
6
7

func doSomething(str: String?)
{
    if let v = str
    {
        // use v to do something
    }
}

上面两段代码的控制流是一样的。对照着，可以看出if let的写法更加简洁方便。

guard

假如 if 中出现的代码很长，我们写代码时可以将错误情况先返回。比如：

1
2
3
4
5
6
7
8
9
10

func doSomething(str: String?)
{
    let v: String! = str
    if v == nil
    {
        return
    }
    // use v to do something
}

这样做可以避免过多的嵌套。上面代码实在太常见了，swift也提供一个guard这个语法糖，用guard可以改写成：

1
2
3
4
5
6

func doSomething(str: String?)
{
    guard let v = str else { return }
    // use v to do something
}

上面两段代码的控制流是一样的。也可以看出guard的写法更加简洁方便。

if满足条件需要return时就可以用guard，所有guard使用场景都可以用if来替代。为啥后来特意加了guard特性，那就是guard的可读性强

可选项的定义

Optional也是Objective-C没有的数据类型，是苹果引入到Swift语言中的全新类型，它的特点就和它的名字一样：可以有值，也可以没有值，当它没有值时，就是nil。此外，Swift的nil也和Objective-C有些不一样，在Objective-C中，只有对象才能为nil，而在Swift里，当基础类型（整形、浮点、布尔等）没有值时，也是nil，而不是一个初始值，没有初始值的值，是不能使用的，这就产生了Optional类型。定义一个Optional的值很容易，只需要在类型后面加上问号(?)就行了，如：

1

var str: String?

一个Optional值和非Optional值的区别就在于：Optional值未经初始化虽然为nil，但普通变量连nil都没有：

1
2
3
4
5
6

//未被初始化，但是是一个Optional类型，为nil
var str: String?
str //输出nil
//未被初始化，也不是Optional类型
var str2: String
str2    //使用时出错

可选项的拆包

显式拆包

Optional类型的值不能被直接使用，当需要用时要显式拆包，以表明我知道这个Optional是一定有值的：

1
2

var str: String? = "Hello World!"
str! //Hello World!

对比拆包前后，对str的输出：

1
2
3

var str: String? = "Hello World!"
str     //{Some "Hello World!"}
str!    //Hello World!

之所以要拆包使用，是因为Optional类型其实是一个枚举：

1
2
3
4
5
6
7
8
9
10
11

enum Optional<T> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)
    init()
    init(_ some: T)
    /// Haskell's fmap, which was mis-named
    func map<U>(f: (T) -> U) -> U?
    func getMirror() -> MirrorType
    static func convertFromNilLiteral() -> T?
}

当Optional没有值时，返回的nil其实就是Optional.None，即没有值。除了None以外，还有一个Some，当有值时就是被Some包装的真正的值，所以我们拆包的动作其实就是将Some里面的值取出来。
有没有似曾相识的感觉？Java里面也有泛型。

隐式拆包

除了显式拆包，Optional还提供了隐式拆包，通过在声明时的数据类型后面加一个感叹号(!)来实现：

1
2

var str: String! = "Hello World!"
str //Hello World!

可以看到没有使用(?)进行显式的折包也得到了Some中的值，这个语法相当于告诉编译器：在我们使用Optional值前，这个Optional值就会被初始化，并且总是会有值，所以当我们使用时，编译器就帮我做了一次拆包。如果你确信你的变量能保证被正确初始化，那就可以这么做，否则还是不要尝试为好。

另外：在上面可以看到，Optional其实就是一个枚举，然后给它指定一个类型就行了，所以下面这两种方法都能声明一个Optional值：

1
2

var str: String! = "Hello World!"
var str2: Optional<String>

Optional Binding

在说Optional Binding之前，我想先说下Xcode6 Beta5在这一版中的一个小变化：在Xcode6 Beta5之前，如果是一个Optional值，可以直接放到条件判断语句中，如：

1
2
3
4
5
6

var str: String? = "Hello World!"
if str {
    "not nil"
} else {
    "nil"
}

如果不是nil，则右边的Playground会显示“not nil”；反之则显示“nil”，但是至Xcode6 Beta5开始，这样就不能通过编译器了，你需要用下面这种方式来代替：

1
2
3
4
5
6

var str: String? = "Hello World!"
if str != nil {
    "not nil"
} else {
    "nil"
}

看似合理，但是在某种情况下会非常不爽难过，比如你在str != nil条件成真后接着在上下文中使用str，会被要求进行拆包，我们以一个Int类型的Optional来做示例：

1
2
3
4
5
6
7

var count: Int?
count = 100
if count != nil {
    "count is " + String(count!)    //count is 100
} else {
    "nil"
}

我在把count强转成String的时候被要求拆包了，这是因为count本身是一个Optional的类型，为了避免在条件判断语句后执行一次或更多次的拆包，Swift引进了Optional Binding，我们就可以这样做：

1
2
3
4
5
6
7

var count: Int?
count = 100
if let validCount = count {
    "count is " + String(validCount)    //count is 100
} else {
    "nil"
}

通过在条件判断语句中（如if、while等）把Optional值直接给一个临时常量，Swift会自动检测Optional是否包含值，如果包含值，会隐式的拆包并给那个临时常量，在接下来的上下文中就能直接使用这个临时常量了，这样是不是就觉得很爽呢微笑

注：在Optional Binding中，除了以常量的方式去接收拆包的值之外，也能以一个变量的形式去接收，但相信在大多数情况下我们只是使用那个值就行了，并不会去改变它。

Swift 1.2 新语法：

在if let 中可以使用条件判断了：

1
2
3
4
5
6
7
8
9

var a: NSString?
a = "test"
if let b = a {
    b
}
if true, let b = a where b == "test" {
    "true"
}

如果a 不是”test”，则不会打印出”true”。

Optional Chaining

Optional Chaining对Swift来说是很基本但又必不可少的东西，相对于简单类型(Int、String等)来说，Optional更主要的应用场景是在复杂对象上，当一个对象包含另一个对象，同时这两个对象都有可能为nil的情况下才是Optional派上用场的地方，在Objective-C里，向nil发消息得到的就是一个nil，但是Swift不能在nil上直接调用方法或属性，同时为了方便我们使用，从而引入了Optional类型，可是这还不够，我们做一个简单的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Person {
    var pet: Pet?
}
class Pet {
    var name: String
    
    var favoriteToy: Toy?
    
    init (name: String) {
        self.name = name
    }
}
class Toy {
    var name: String
    
    init (name: String) {
        self.name = name
    }
}

一个Person对象代表一个人，这个人可能有一个宠物，宠物会有它自己的名字，而且宠物可能会有自己喜爱的玩具，按照前面提到的知识，我们要首先判断这个人有没有宠物，然后再判断他的宠物有没有喜爱的玩具，然后才能得到这个玩具的名称，利用Optional Binding，我们写出来的可能就像这样：

1
2
3
4
5
6
7
8

let jackon = Person()
jackon.pet = Pet(name: "Max")
jackon.pet?.favoriteToy = Toy(name: "Ball")
if let pet = jackon.pet {
    if let toy = pet.favoriteToy {
        toy.name
    }
}

这里用到了两个if，因为pet和toy对象都可能为nil，我们需要预防每一个可能为nil的对象，如果这个对象再复杂一点，那if也就更多了，而使用Optional Chaining的话，写出来的就像这样：

1
2
3
4
5
6

let jackon = Person()
jackon.pet = Pet(name: "Max")
jackon.pet?.favoriteToy = Toy(name: "Ball")
if let toy = jackon.pet?.favoriteToy {
    toy.name
}

当一个Optional值调用它的另一个Optional值的时候，Optional Chaining就形成了，基本上，Optional Chaining就是总是返回一个Optional的值，只要这个Chaining中有一个值为nil，整条Chaining就为nil，和Objective-C的向nil发消息类似。
有一点很有趣，就是Optional Chaining除了能将属性返回的类型变为Optional外，连方法的返回值都能强制变为Optional，哪怕这个方法没有返回值，但是别忘了，Void也算是一个类型：

1

typealias Void = ()

如果我们的Pet类有一个玩玩具的play方法的话，就可以这样来判断是否会调用成功：

1
2
3

if let p: Void = jackon.pet?.play() {
    "play is called"
}

使用Optional Chaining，能使我们的代码变得更加可读，同时更加简洁。

类型别名

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

当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。假设你正在处理特定长度的外部资源的数据：

1

typealias AudioSample = UInt16

定义了一个类型别名之后，你可以在任何使用原始名的地方使用别名：

1
2

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

本例中，AudioSample被定义为UInt16的一个别名。因为它是别名，AudioSample.min实际上是UInt16.min，所以会给maxAmplitudeFound赋一个初值0。

Bool值

Swift 有一个基本的布尔（Boolean）类型，叫做Bool。布尔值指逻辑上的（logical），因为它们只能是真或者假。Swift 有两个布尔常量，true和false：

1
2

let orangesAreOrange = true
let turnipsAreDelicious = false

当你编写条件语句比如if语句的时候，布尔值非常有用：

1
2
3
4
5
6

if turnipsAreDelicious {
    println("Mmm, tasty turnips!")
} else {
    println("Eww, turnips are horrible.")
}
// 输出 "Eww, turnips are horrible."

条件语句，例如if，请参考控制流。

如果你在需要使用Bool类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误：

1
2
3
4

let i = 1
if i {
    // 这个例子不会通过编译，会报错
}

然而，下面的例子是合法的：

1
2
3
4

let i = 1
if i == 1 {
    // 这个例子会编译成功
}

i == 1的比较结果是Bool类型，所以第二个例子可以通过类型检查。类似i == 1这样的比较，请参考基本操作符。

和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误并保证这块代码的意图总是清晰的。

声明常量,变量以及类型标注

常量和变量必须在使用前声明，用let来声明常量，用var来声明变量。下面的例子展示了如何用常量和变量来记录用户尝试登录的次数：

1
2

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

这两行代码可以被理解为：

“声明一个名字是maximumNumberOfLoginAttempts的新常量，并给它一个值10。然后，声明一个名字是currentLoginAttempt的变量并将它的值初始化为0.”

在这个例子中，允许的最大尝试登录次数被声明为一个常量，因为这个值不会改变。当前尝试登录次数被声明为一个变量，因为每次尝试登录失败的时候都需要增加这个值。

你可以在一行中声明多个常量或者多个变量，用逗号隔开：

1

var x = 0.0, y = 0.0, z = 0.0

注意：
如果你的代码中有不需要改变的值，请使用let关键字将它声明为常量。只将需要改变的值声明为变量。

类型标注

当你声明常量或者变量的时候可以加上类型标注（type annotation），说明常量或者变量中要存储的值的类型。如果要添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。

这个例子给welcomeMessage变量添加了类型标注，表示这个变量可以存储String类型的值：

1

var welcomeMessage: String

声明中的冒号代表着“是…类型”，所以这行代码可以被理解为：

“声明一个类型为String，名字为welcomeMessage的变量。”

“类型为String”的意思是“可以存储任意String类型的值。”

welcomeMessage变量现在可以被设置成任意字符串：

1

welcomeMessage = "Hello"

Swift单例的写法

需要对单例的属性做修改

1
2
3
4
5
6
7
8
9
10

static let shareInstance: HTTPClient = {
    let afn = HTTPClient()
    
    // 设置网络请求的 content-type: text/plain
    
    afn.responseSerializer.acceptableContentTypes?.insert("text/plain")
    
    return afn
}()

不需要对单例的属性做修改

1

static let sharedInstance = TCPManager()

从事新工作之后,记录自己的所获所得