iOS-Swift-可选链、协议

一. 可选链（Optional Chaining）

如果可选项为nil，调用方法、下标、属性失败，结果为nil
如果可选项不为nil，调用方法、下标、属性成功，结果会被包装成可选项
如果结果本来就是可选项，不会进行再次包装

class Car { var price = 0 }
class Dog { var weight = 0 }
class Person {
    var name: String = ""
    var dog: Dog = Dog()
    var car: Car? = Car()
    func age() -> Int? { 18 }
    func eat() { print("Person eat") }
    subscript(index: Int) -> Int { index }
}

var person: Person? = Person()
//这样强制解包有风险，如果person是nil，使用nil调用方法会报错
var age1 = person!.age() // Int 
//age是Int?类型的，不会进行再次包装
var age2 = person?.age() // Int? 
var name = person?.name // String?
var index = person?[6] // Int?

func getName() -> String { "jack" }
// 如果person是nil，不会调用getName()
person?.name = getName()

如何判断可选项调用方法是否成功？

if let _ = person?.eat() { // ()?
    print("eat调用成功")
} else {
    print("eat调用失败")
}

Swift里面，如果方法调用没有返回值就相当于返回一个空元祖()，所以可以根据是否返回空元祖来判断方法是否调用成功

多个?链接在一起就称为可选链，如果链中任何一个节点是nil，那么整个链就会调用失败：

var dog = person?.dog // Dog?
var weight = person?.dog.weight // Int?
var price = person?.car?.price // Int?

可选项不会进⾏再次包装：

var num1: Int? = 5
//num1本来就是Int?，就算再加个?结果还是Optional(10)类型
num1? = 10 // Optional(10)  

var num2: Int? = nil
//由于num2是Int?类型的，如果num2是空，后面的赋值操作就不会执行了
num2? = 10 // nil

可选项不会进⾏再次包装，除⾮你给他指定类型：

var num1: Int? = 5
var num2: Int?? = 10
print(num2) //Optional(Optional(10))

字典通过key获取的值都是可选类型，可选类型使用的时候要加?

//字典
var scores = ["Jack": [86, 82, 84], "Rose": [79, 94, 81]]
//通过字典的key获取值有可能获取失败，所以结果是可选类型的数组
scores["Jack"]?[0] = 100
//可选类型的数组通过下标访问成员需要加？
scores["Rose"]?[2] += 10
scores["Kate"]?[0] = 88

var dict: [String : (Int, Int) -> Int] = [
      "sum" : (+),
      "difference" : (-)
]
//返回的函数是个可选类型，函数调用的时候也要加?
var result = dict["sum"]?(10, 20)  // Optional(30)

二. 协议（Protocol）

1. 协议简介

协议可以用来定义方法、属性、下标的声明

protocol Drawable {
    func draw() //方法声明
    var x: Int { get set } //属性声明
    var y: Int { get } 
    subscript(index: Int) -> Int { get set } //下标声明
}

协议可以被枚举、结构体、类遵守（多个协议之间用逗号隔开）

protocol Test1 {}
protocol Test2 {}
protocol Test3 {}
class TestClass : Test1, Test2, Test3 {}

1. 协议中定义方法时不能有默认参数值
2. 默认情况下，协议中定义的内容必须全部都实现
3. 也有办法办到只实现部分内容，以后的课程会讲到

2. 协议中的属性

1. 协议中定义属性时必须用var关键字(因为属性可能通过计算属性来实现，将来返回什么不确定)
2. 实现协议时的属性权限要不小于协议中定义的属性权限
3. 协议中属性定义成get set，可以用var存储属性或者get set计算属性去实现
4. 协议中定义成get，用任何属性(let y、只有get的计算属性、有get set的计算属性)都可以实现

如下类遵守Drawable协议：

protocol Drawable {
    func draw() //方法声明
    var x: Int { get set } //属性声明，必须用var
    var y: Int { get } 
    subscript(index: Int) -> Int { get set } //下标
}

//做法1：
class Person : Drawable {
    var x: Int = 0
    let y: Int = 0
    func draw() {
        print("Person draw")
    }
    subscript(index: Int) -> Int {
        set {}
        get { index }
    }
}

//做法2：
class Person : Drawable {
    var x: Int {
        get { 0 }
        set {}
    }
    var y: Int { 0 }
    func draw() { print("Person draw") }
    subscript(index: Int) -> Int {
        set {}
        get { index }
    }
}

3. 一些关键字

• static、class

为了保证枚举、结构体、类通用，协议中必须用static定义类型方法、类型属性、类型下标。
但是，具体使用的时候如果是类，还是可以用class的。

protocol Drawable {
    static func draw()
}

class Person1 : Drawable {
    class func draw() {
        print("Person1 draw")
    }
}

class Person2 : Drawable {
    static func draw() {
        print("Person2 draw")
    }
}

• mutating

只有将协议中的实例方法标记为mutating，才允许枚举、结构体的具体实现修改自身内存，在实现的时候，枚举、结构体需要加mutating，类不用加mutating。

protocol Drawable {
    mutating func draw()
}

class Size : Drawable {
    var width: Int = 0
    func draw() {
        width = 10
    }
}

struct Point : Drawable {
    var x: Int = 0
    //只有在协议中先加上mutating，在枚举、结构体中实现的时候才可以在这里加mutating
    mutating func draw() { 
        x = 10
    }
}

4. 初始化器

• init

协议中还可以定义初始化器init，非final类实现时必须加上required

protocol Drawable {
    init(x: Int, y: Int)
}

class Point : Drawable {
    required init(x: Int, y: Int) {}
}

final class Size : Drawable {
    init(x: Int, y: Int) {}
}

如果从协议实现的初始化器，刚好是重写了父类的指定初始化器，那么这个初始化必须同时加required、override

protocol Livable {
    init(age: Int)
}

class Person {
    init(age: Int) {}
}

//required来自协议，override来自父类
class Student : Person, Livable {
    required override init(age: Int) {
        super.init(age: age)
    }
}

• init、init?、init!

init：非可失败初始化器
init?：可失败初始化器
init!：可失败初始化器(隐式解包)

协议中定义的init?、init!，可以用init、init?、init!去实现
协议中定义的init，可以用init、init!去实现

protocol Livable {
    init()
    init?(age: Int)
    init!(no: Int)
}

class Person : Livable {
    required init() {}
    // required init!() {}
    
    required init?(age: Int) {}
    // required init!(age: Int) {}
    // required init(age: Int) {}
    
    required init!(no: Int) {}
    // required init?(no: Int) {}
    // required init(no: Int) {}
}

5. 协议中的其他操作

• 协议继承

一个协议可以继承其他协议

protocol Runnable {
    func run()
}

protocol Livable : Runnable {
    func breath()
}

class Person : Livable {
    func breath() {}
    func run() {}
}

• 协议组合

协议组合，可以将协议和类组合起来(最多只能包含一个类类型)

protocol Livable {}
protocol Runnable {}
class Person {}

// 接收Person或者其子类的实例
func fn0(obj: Person) {}
// 接收遵守Livable协议的实例
func fn1(obj: Livable) {}
// 接收同时遵守Livable、Runnable协议的实例
func fn2(obj: Livable & Runnable) {}
// 接收同时遵守Livable、Runnable协议、并且是Person或者其子类的实例
func fn3(obj: Person & Livable & Runnable) {}

typealias RealPerson = Person & Livable & Runnable
// 接收同时遵守Livable、Runnable协议、并且是Person或者其子类的实例
func fn4(obj: RealPerson) {}

6. 一些常用协议

• CaseIterable

让枚举遵守CaseIterable协议，可以实现遍历枚举值，CaseIterable协议源码如下：

public protocol CaseIterable {

    /// A type that can represent a collection of all values of this type.
    associatedtype AllCases : Collection where Self == Self.AllCases.Element

    /// A collection of all values of this type.
    static var allCases: Self.AllCases { get }
}

enum Season : CaseIterable {
    case spring, summer, autumn, winter
}

let seasons = Season.allCases
print(seasons.count) // 4

for season in seasons {
    print(season) // spring summer autumn winter
}

• CustomStringConvertible

遵守CustomStringConvertible、CustomDebugStringConvertible协议，都可以自定义实例的打印字符串，协议源码如下：

public protocol CustomStringConvertible {
    var description: String { get }
}

public protocol CustomDebugStringConvertible {
    var debugDescription: String { get }
}

class Person : CustomStringConvertible, CustomDebugStringConvertible {
    var age = 0
    var description: String { "person_\(age)" }
    var debugDescription: String { "debug_person_\(age)" }
}
    
var person = Person()
print(person) // person_0
debugPrint(person) // debug_person_0

1. print调用的是CustomStringConvertible协议的description
2. debugPrint、po调用的是CustomDebugStringConvertible协议的debugDescription

CustomDebugStringConvertible协议.png

7. 类型相关关键字

• Any、AnyObject

Swift提供了两种特殊的类型：Any、AnyObject
Any：可以代表任意类型（枚举、结构体、类，也包括函数类型） AnyObject：可以代表任意类类型（在协议后面写上: AnyObject代表只有类能遵守这个协议，在协议后面写上: class也代表只有类能遵守这个协议）

var stu: Any = 10
stu = "Jack"
stu = Student()

// 创建1个能存放任意类型的数组
// var data = Array<Any>()
var data = [Any]()
data.append(1)
data.append(3.14)
data.append(Student())
data.append("Jack")
data.append({ 10 })

• is、as?、as!、as

is用来判断是否为某种类型，as用来做强制类型转换

as?、as!、as的区别：

1. as?和as!都代表可选类型
2. as?表示可能强转成功也可能强转失败
3. as!表示强转之后进行隐式解包
4. 百分百可以强转成功就使用as

protocol Runnable { func run() }
class Person {}
class Student : Person, Runnable {
    func run() {
        print("Student run")
    }
    func study() {
        print("Student study")
    }
}

var stu: Any = 10
print(stu is Int) // true 是否是Int
stu = "Jack"
print(stu is String) // true 是否是String
stu = Student()
print(stu is Person) // true 是否是Person及其子类
print(stu is Student) // true 是否是Student及其子类
print(stu is Runnable) // true 是否是遵守Runnable协议的类

var stu: Any = 10
(stu as? Student)?.study() // 没有调用study
//第一个?代表强制转换可能成功可能失败，第二个?代表可选类型调用方法必须加?

stu = Student()
(stu as? Student)?.study() // Student study
(stu as! Student).study() // Student study
(stu as? Runnable)?.run() // Student run

var data = [Any]()
data.append(Int("123") as Any) //百分百可以转换成功就使用as 

var d = 10 as Double //百分百可以转换成功就使用as
print(d) // 10.0

注意可选链：
(stu as? Student)?.study() 第一个?代表强制转换可能成功可能失败，第二个?代表可选类型调用方法必须加?

(stu as? Student)!.study() 
(stu as! Student).study() 
上面两种写法完全等价，都代表隐式解包，但是上面两种写法有风险：一旦强制解包失败会报错

• X.self、X.Type、AnyObject、AnyClass

1. X.self是一个元类型(metadata)的指针，metadata存放着类型相关信息(就是以前我们说的，对象堆空间前8字节存放的类型相关的那个指针)
2. X.self属于X.Type类型
3. X.self有点类似于OC的X.class
4. AnyObject代表任意类类型
5. AnyClass就是AnyObject.Type，代表任意类的元类型

class Person {}
class Student : Person {
    static var age = 0
}
var perType: Person.Type = Person.self
var stuType: Student.Type = Student.self
perType = Student.self //可以赋值 
print(Person.self) //Person
print(Student.self) //Student
print(perType) //Person
print(stuType) //Student

var anyType: AnyObject.Type = Person.self
anyType = Student.self  //可以赋值 
print(anyType) //Person
print(anyType) //Person

public typealias AnyClass = AnyObject.Type //任意类的元类型
var anyType2: AnyClass = Person.self //可以赋值 
anyType2 = Student.self  //也可以赋值 

var per1 = Person()
var per1Type = type(of: per1)  //返回的就是Person.self
print(Person.self) //Person
print(type(of: per1)) //Person
print(type(of: per1) == Person.self) // true

补充1：下面两行完全一样(MJ老师通过查看汇编得出的结论)

Person.age = 10 //通过类型访问age
Person.self.age = 10 //通过元类型访问age

补充2：type(of: per1) == Person.self

//接收一个实例，告诉你这个实例是什么类型，返回的是X.Type类型
//Swift把它定性为函数，但它本质不是函数调用，是直接取出per1对象的前8个字节赋值给左边
var per1Type = type(of: per1)  //返回的就是Person.self

• Self

self代表方法调用者
Self代表当前类型

class Person {
    var age = 1
    static var count = 2
    func run() {
        print(self.age) // 1
        print(Self.count) // 2
    }
}

Self一般用作返回值类型，限定返回值跟方法调用者必须是同一类型(也可以作为参数类型)，有点类似于OC的instancetype

protocol Runnable {
    func test() -> Self //限定返回值跟方法调用者必须是同一类型
}
class Person : Runnable {
    required init() {} //必须是required
    func test() -> Self { 
        type(of: self).init() //使用元类型调用init()
    } 
}
class Student : Person {}
    
var p = Person()
// Person
print(p.test())
    
var stu = Student()
// Student
print(stu.test())

8. 元类型的应用

• 根据元类型创建实例

X.self有点类似于OC的X.class

class Animal { required init() {} } //确保子类都有init()
class Cat : Animal {}
class Dog : Animal {}
class Pig : Animal {}

//传入元类型，创建出实例放到数组中返回
func create(_ clses: [Animal.Type]) -> [Animal] {
    var arr = [Animal]()
    for cls in clses {
        arr.append(cls.init()) //元类型，调用init()
    }
    return arr
}
    
print(create([Cat.self, Dog.self, Pig.self]))

上面代码“arr.append(cls.init())”，通过元类型调用init()，和我们通常写的Animal()是一样的，如下：

//通过窥探汇编可知，下面几行完全一样的
var a1 = Animal()
var a2 = Animal.self()
var a3 = Animal.init()
var a4 = Animal.self.init()
甚至：
var a5 = type(of:a2).init() //type(of:a2)就是拿到Animal.self

他们本质都是调用init()
Animal是类型，Animal.self是元类型，只不过很多时候Animal.self和Animal可以相互取代(如果要求传入的就是元类型就不能取代)

• Swift中使用Runtime的一些函数

Swift虽然没有Runtime，但是一些纯Swift的类也可以使用Runtime的一些函数，因为Swift实现了这些函数

import Foundation
class Person {
    var age: Int = 0
}
class Student : Person {
    var no: Int = 0
}
//至少占用多少字节
print(class_getInstanceSize(Student.self)) // 32
//获取父类
print(class_getSuperclass(Student.self)!) // Person
//获取父类
print(class_getSuperclass(Person.self)!) // Swift._SwiftObject

从结果可以看得出来，Swift还有个隐藏的基类：Swift._SwiftObject
可以参考Swift源码：https://github.com/apple/swift/blob/master/stdlib/public/runtime/SwiftObject.h