iOSTips

KO | EN

gitlite — search

#llm #golang #go #android #machine-learning #rust #docker #macos #java #windows #vue #awesome-list #pytorch #mcp

(★ 467)

记录iOS（Swift）开发中的一些知识点、小技巧

iOSTips 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# iOSTips(๑•̀ㅂ•́)و✧

[![Language: Swift 5.0](https://img.shields.io/badge/language-swift5.0-f48041.svg?style=flat)](https://developer.apple.com/swift)
![Platform: iOS 12](https://img.shields.io/badge/platform-iOS-blue.svg?style=flat)

## 1.SwiftTips 
记录iOS开发中的一些知识点

[1.常用的几个高阶函数](#1)  
[2.高阶函数扩展](#2)  
[3.优雅的判断多个值中是否包含某一个值](#3)  
[4.Hashable、Equatable和Comparable协议](#4)  
[5.可变参数函数](#5)  
[6.where关键字](#6)  
[7.switch中判断枚举类型,尽量避免使用default](#7)  
[8.iOS9之后全局动态修改StatusBar样式](#8)  
[9.使用面向协议实现app的主题功能](#9)  
[10.swift中多继承的实现](#10)  
[11.华丽的TableView刷新动效](#11)  
[12.实现一个不基于Runtime的KVO](#12)  
[13.实现多重代理](#13)   
[14.自动检查控制器是否被销毁](#14)  
[15.向控制器中注入代码](#15)  
[16.给Extension添加存储属性](#16)  
[17.用闭包实现按钮的链式点击事件](#17)  
[18.用闭包实现手势的链式监听事件](#18)  
[19.用闭包实现通知的监听事件](#19)  
[20.AppDelegate解耦](#20)  
[21.常见的编译器诊断指令](#21)  
[22.最后执行的defer代码块](#22)  
[23.定义全局常量](#23)  
[24.使用Codable协议解析JSON](#24)  
[25.dispatch_once替代方案](#25)  
[26.被废弃的+load()和+initialize()](#26)  
[27.交换方法 Method Swizzling](#27)    
[28.获取View的指定子视图](#28)  
[29.线程安全: 互斥锁和自旋锁(10种)](#29)  
[30.可选类型扩展](#30)  
[31.更明了的异常处理封装](#31)  
[32.关键字static和class的区别](#32)  
[33.在字典中用KeyPaths取值](#33)    
[34.给UIView顶部添加圆角](#34)    
[35.使用系统自带气泡弹框](#35)  
[36.给UILabel添加内边距](#36)  
[37.给UIViewController添加静态Cell](#37)  
[38.简化使用UserDefaults](#38)  
[39.给TabBar上的按钮添加动画](#39)  
[40.给UICollectionView的Cell添加左滑删除](#40)  
[41.基于NSLayoutAnchor的轻量级AutoLayout扩展](#41)  
[42.简化复用Cell的代码](#42)    
[43.正则表达式的封装](#43)  
[44.自定义带动画效果的模态框](#44)  
[45.利用取色盘获取颜色](#45)  
[46.第三方库的依赖隔离](#46)  
[47.给App的某个功能添加快捷方式](#47)  
[48.给UITableView添加空白页](#48)  
[49.线程保活的封装](#49)  
[50.GCD定时器](#50)  
[51.命名空间及应用](#51)  
[52.数据绑定的封装](#52)  
[53.基于CSS样式的富文本](#53)  
[54.阴影视差效果的封装](#54)  
[55.使用协调器模式管理控制器](#55)  
[56.判断字符串是否为空](#56)  
[57.避免将字符串硬编码在代码中](#57)  
[58.恢复非正常终止的应用状态](#58)  
[59.清晰的错误处理类型Result](#59)  
[60.插件化子控制器](#60)  
[61.ExpressibleBy协议集:通过字面量实例化对象](#61)  
[62.插件化TableView](#62)  
[63.自定义底部弹层控制器](#63)  
[64.UIAlertController的封装](#64)  
[65.自定义控制器构造方法](#65)   
[66.性能调优之像素对齐](#66)   
[67.可以做与运算的结构体](#67)

## 2.XcodeTips

记录使用Xcode工具的一些小技巧

[1.生成对外暴露的属性和方法](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#1)  
[2.显示Storyboard中控件之间的距离](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#2)  
[3.重命名当前文件中的方法名或变量名](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#3)  
[4.Storyboard中视图只覆盖不被添加](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#4)  
[5.锁定Storyboard中控件的约束](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#5)  
[6.多重光标操作](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#6)  
[7.断点对象预览](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#7)  
[8.Storyboard解耦](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#8)  
[9.获取app的启动日志](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#9)  
[10.模拟器录屏](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#10)   
[11.AutoLayout约束错误声音提示](https://github.com/DarielChen/iOSTips/blob/master/XcodeTips/XcodeTips.md#11)

<h2 id="1">1.常用的几个高阶函数</h2>

函数式编程在swift中有着广泛的应用,下面列出了几个常用的高阶函数.
#### 1. sorted
常用来对数组进行排序.顺便感受下函数式编程的多种姿势.

##### 1. 使用sort进行排序,不省略任何类型

```swift
let intArr = [13, 45, 27, 80, 22, 53]

let sortOneArr = intArr.sorted { (a: Int, b: Int) -> Bool in
    return a < b
}
// [13, 22, 27, 45, 53, 80]
```
##### 2. 编译器可以自动推断出返回类型,所以可以省略

```swift
let sortTwoArr = intArr.sorted { (a: Int, b: Int) in
    return a < b
}
// [13, 22, 27, 45, 53, 80]
```

##### 3. 编译器可以自动推断出参数类型,所以可以省略

```swift
let sortThreeArr = intArr.sorted { (a, b) in
    return a < b
}
// [13, 22, 27, 45, 53, 80]
```

##### 4. 编译器可以自动推断出参数个数,所以可以用$0,$1替代

```swift
let sortFourArr = intArr.sorted {
    return $0 < $1
}
// [13, 22, 27, 45, 53, 80]
```

##### 5. 如果闭包中的函数体只有一行,且需要有返回值,return可以省略

```swift
let sortFiveArr = intArr.sorted {
    $0 < $1
}
// [13, 22, 27, 45, 53, 80]
```

##### 6. 最简化: 可以直接传入函数`<`

```swift
let sortSixArr = intArr.sorted(by: <)
// [13, 22, 27, 45, 53, 80]
```

#### 2. map和compactMap
##### 1. map: 对数组中每个元素做一次处理.

```swift
let mapArr = intArr.map { $0 * $0 }
// [169, 2025, 729, 6400, 484, 2809]
```
##### 2. compactMap: 和map类似,但可以过滤掉nil,还可以对可选类型进行解包.

```swift
let optionalArr = [nil, 4, 12, 7, Optional(3), 9]
let compactMapArr = optionalArr.compactMap { $0 }
// [4, 12, 7, 3, 9]
```

#### 3. filter: 将符合条件的元素重新组合成一个数组

```swift
let evenArr = intArr.filter { $0 % 2 == 0 }
// [80, 22]
```

#### 4. reduce: 将数组中的元素合并成一个

```swift
// 组合成一个字符串
let stringArr = ["1", "2", "3", "*", "a"]
let allStr = stringArr.reduce("") { $0 + $1 }
// 123*a

// 求和
let sum = intArr.reduce(0) { $0 + $1 }
// 240
```
#### 5. 高阶函数可以进行链式调用.比如,求一个数组中偶数的平方和

```swift
let chainArr = [4, 3, 5, 8, 6, 2, 4, 7]

let resultArr = chainArr.filter {
                            $0 % 2 == 0
                        }.map {
                            $0 * $0
                        }.reduce(0) {
                            $0 + $1
                        }
// 136
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="2">2.高阶函数扩展</h2>

#### 1. map函数的实现原理

```swift
extension Sequence {
    
    // 可以将一些公共功能注释为@inlinable,给编译器提供优化跨模块边界的泛型代码的选项
    @inlinable
    public func customMap<T>(
        _ transform: (Element) throws -> T
        ) rethrows -> [T] {
        let initialCapacity = underestimatedCount
        var result = ContiguousArray<T>()
        
        // 因为知道当前元素个数,所以一次性为数组申请完内存,避免重复申请
        result.reserveCapacity(initialCapacity)
        
        // 获取所有元素
        var iterator = self.makeIterator()
        
        // 将元素通过参数函数处理后添加到数组中
        for _ in 0..<initialCapacity {
            result.append(try transform(iterator.next()!))
        }
        // 如果还有剩下的元素,添加进去
        while let element = iterator.next() {
            result.append(try transform(element))
        }
        return Array(result)
    }
}

```
map的实现无非就是创建一个空数组,通过for循环遍历将每个元素通过传入的函数处理后添加到空数组中,只不过swift的实现更加高效一点.

关于其余相关高阶函数的实现:[Sequence.swift
](https://github.com/apple/swift/blob/swift-4.2-branch/stdlib/public/core/Sequence.swift)

#### 2. 关于数组中用到的其他的一些高阶函数

```swift
class Pet {
    let type: String
    let age: Int
    
    init(type: String, age: Int) {
        self.type = type
        self.age = age
    }
}

var pets = [
            Pet(type: "dog", age: 5),
            Pet(type: "cat", age: 3),
            Pet(type: "sheep", age: 1),
            Pet(type: "pig", age: 2),
            Pet(type: "cat", age: 3),
            ]
```
###### 1. 遍历所有元素
```swift         
pets.forEach { p in
   print(p.type)
}
```
###### 2. 是否包含满足条件的元素
```swift
let cc = pets.contains { $0.type == "cat" }
```
###### 3. 第一次出现满足条件的元素的位置
```swift
let firstIndex = pets.firstIndex { $0.age == 3 }
// 1
```
###### 4. 最后一次出现满足条件的元素的位置
```swift
let lastIndex = pets.lastIndex { $0.age == 3 }
// 4
```
###### 5. 根据年龄从大到小进行排序
```swift
let sortArr = pets.sorted { $0.age < $1.age }
```
###### 6. 获取age大于3的元素
```swift
let arr1 = pets.prefix { $0.age > 3 }
// [{type "dog", age 5}]
```
###### 7. 获取age大于3的取反的元素
```swift
let arr2 = pets.drop { $0.age > 3 }
// [{type "cat", age 3}, {type "sheep", age 1}, {type "pig", age 2}, {type "cat", age 3}]

```
###### 8. 将字符串转化为数组
```swift
let line = "BLANCHE:   I don't want realism. I want magic!"

let wordArr = line.split(whereSeparator: { $0 == " " })
// ["BLANCHE:", "I", "don\'t", "want", "realism.", "I", "want", "magic!"]
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="3">3.优雅的判断多个值中是否包含某一个值</h2>

我们最常用的方式

```swift
let string = "One"

if string == "One" || string == "Two" || string == "Three" {
    print("One")
}
```
这种方式是可以,但可阅读性不够,那有啥好的方式呢?  
#### 1. 我们可以利用`contains`:

```swift
if ["One", "Two", "Three"].contains(where: { $0 == "One"}) {
	print("One")
}
```
#### 2. 自己手动实现一个`any`

##### 使用:
```swift

if string == any(of: "One", "Two", "Three") {
    print("One")
}

```

##### 实现:

```swift
func any<T: Equatable>(of values: T...) -> EquatableValueSequence<T> {
    return EquatableValueSequence(values: values)
}

struct EquatableValueSequence<T: Equatable> {
    static func ==(lhs: EquatableValueSequence<T>, rhs: T) -> Bool {
        return lhs.values.contains(rhs)
    }
    
    static func ==(lhs: T, rhs: EquatableValueSequence<T>) -> Bool {
        return rhs == lhs
    }
    
    fileprivate let values: [T]
}
```
这样做的前提是any中传入的值需要实现`Equatable`协议.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="4">4. Hashable、Equatable和Comparable协议</h2>

#### 1. Hashable  
实现Hashable协议的方法后我们可以根据`hashValue`方法来获取该对象的哈希值.  
字典中的value的存储就是根据key的`hashValue`,所以所有字典中的key都要实现Hashable协议.

```swift
class Animal: Hashable {
    
    var hashValue: Int {
        return self.type.hashValue ^ self.age.hashValue
    }
    
    let type: String
    let age: Int
    
    init(type: String, age: Int) {
        self.type = type
        self.age = age
    }
}

let a1 = Animal(type: "Cat", age: 3)
a1.hashValue
// 哈希值
```
#### 2. Equatable协议
实现Equatable协议后,就可以用`==`符号来判断两个对象是否相等了.

```swift
class Animal: Equatable, Hashable {
    
    static func == (lhs: Animal, rhs: Animal) -> Bool {
        if lhs.type == rhs.type && lhs.age == rhs.age{
            return true
        }else {
            return false
        }
    }
        
    let type: String
    let age: Int
    
    init(type: String, age: Int) {
        self.type = type
        self.age = age
    }
}

let a1 = Animal(type: "Cat", age: 3)
let a2 = Animal(type: "Cat", age: 4)

a1 == a2
// false
```
#### 3. Comparable协议
基于Equatable基础上的Comparable类型,实现相关的方法后可以使用`<`、`<=`、`>=`、`>` 等符号进行比较.

```swift
class Animal: Comparable {
    // 只根据年龄选项判断
    static func < (lhs: Animal, rhs: Animal) -> Bool {
        if lhs.age < rhs.age{
            return true
        }else {
            return false
        }
    }
    
    let type: String
    let age: Int
    
    init(type: String, age: Int) {
        self.type = type
        self.age = age
    }
}

let a1 = Animal(type: "Cat", age: 3)
let a2 = Animal(type: "Cat", age: 4)
let a3 = Animal(type: "Cat", age: 1)
let a4 = Animal(type: "Cat", age: 6)

// 按照年龄从大到小排序
let sortedAnimals = [a1, a2, a3, a4].sorted(by: <)
```
在日常开发中会涉及到大量对自定义对象的比较操作,所以`Comparable`协议的用途还是比较广泛的.

`Comparable`协议除了应用在类上,还可以用在**结构体**和**枚举**上.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="5">5.可变参数函数</h2>  
在定义函数的时候,如果参数的个数不确定时,需要使用可变参数函数.举个例子,对数组的求和.

```swift
// 常用的姿势
[2, 3, 4, 5, 6, 7, 8, 9].reduce(0) { $0 + $1 }
// 44

// 使用可变参数函数
sum(values: 2, 3, 4, 5, 6, 7, 8, 9)
// 44

// 可变参数的类型是个数组
func sum(values:Int...) -> Int {
    var result = 0
    values.forEach({ a in
        result += a
    })
    return result
}

```

应用:

```swift

// 给UIView添加子控件
let view = UIView()
let label = UILabel()
let button = UIButton()
view.add(view, label, button)

extension UIView {
    /// 同时添加多个子控件
    ///
    /// - Parameter subviews: 单个或多个子控件
    func add(_ subviews: UIView...) {
        subviews.forEach(addSubview)
    }
}

```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="6">6.where关键字</h2>

where的主要作用是用来做限定.

#### 1. `for`循环的时候用来做条件判断

```swift
// 只遍历数组中的偶数
let arr = [11, 12, 13, 14, 15, 16, 17, 18]
for num in arr where num % 2 == 0 {
    // 12 14 16 18
}
```

#### 2. 在`try` `catch`的时候做条件判断

```swift
enum ExceptionError:Error{
    case httpCode(Int)
}

func throwError() throws {
    throw ExceptionError.httpCode(500)
}

do{
    try throwError()
// 通过where添加限定条件
}catch ExceptionError.httpCode(let httpCode) where httpCode >= 500{
    print("server error")
}catch {
    print("other error")
}
```

#### 3. switch语句做限定条件

```swift
let student:(name:String, score:Int) = ("小明", 59)
switch student {
case let (_,score) where score < 60:
    print("不及格")
default:
    print("及格")
}
```

#### 4. 限定泛型需要遵守的协议

```swift
//第一种写法
func genericFunctionA<S>(str:S) where S:ExpressibleByStringLiteral{
    print(str)
}
//第二种写法
func genericFunctionB<S:ExpressibleByStringLiteral>(str:S){
    print(str)
}
```
#### 5. 为指定的类添加对应的协议扩展

```swift
// 为Numeric在Sequence中添加一个求和扩展方法
extension Sequence where Element: Numeric {
    var sum: Element {
        var result: Element = 0
        for item  in self {
            result += item
        }
        return result
    }
}

print([1,2,3,4].sum) // 10
```

#### 6. 为某些高阶函数的限定条件

```swift
let names = ["Joan", "John", "Jack"]
let firstJname = names.first(where: { (name) -> Bool in
    return name.first == "J"
})
// "Joan"
let fruits = ["Banana", "Apple", "Kiwi"]
let containsBanana = fruits.contains(where: { (fruit) in
    return fruit == "Banana"
})
// true
```

参考: [Swift where 关键字](https://www.jianshu.com/p/1546594b856b)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="7">7.switch中判断枚举类型,尽量避免使用default</h2>

通过`switch`语句来判断枚举类型,不使用`default`,如果后期添加新的枚举类型,而忘记在`switch`中处理,会报错,这样可以提高代码的健壮性.

```swift
enum State {        
    case loggedIn
    case loggedOut
    case startUI
}
    
func handle(_ state: State) {
    switch state {
    case .loggedIn:
         showMainUI()
    case .loggedOut:
        showLoginUI()
        
        // Compiler error: Switch must be exhaustive
    }
}

```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="8">8.iOS9之后全局动态修改StatusBar样式</h2>

#### 1. 局部修改StatusBar样式
最常用的方法是通过控制器来修改`StatusBar`样式

```swift
override var preferredStatusBarStyle: UIStatusBarStyle {
    return .lightContent
}
```
注意:如果当前控制器有导航控制器,需要在导航控制器中这样设置(如下代码),不然不起作用.

```swift
override var preferredStatusBarStyle: UIStatusBarStyle {
    return topViewController?.preferredStatusBarStyle ?? .default
}
```
这样做的好处是,可以针对不同的控制器设置不同的`StatusBar`样式,但有时往往会多此一举,略嫌麻烦,那如何全局统一处理呢?

#### 2. iOS9之前全局修改StatusBar样式
iOS9之前的做法比较简单,在`plist`文件中设置`View controller-based status bar appearance`为`NO`.

在需要设置的地方添加

```swift
UIApplication.shared.setStatusBarStyle(.default, animated: true)
```
这样全局设置`StatusBar`样式就可以了,但iOS9之后`setStatusBarStyle`方法被废弃了,苹果推荐使用`preferredStatusBarStyle`,也就是上面那种方法.
#### 3. iOS9之后全局修改StatusBar样式
我们可以用`UIAppearance`和导航栏的`barStyle`去全局设置`StatusBar`的样式.

- `UIAppearance`属性可以做到全局修改样式.
- 导航栏的`barStyle`决定了`NavigationBar`的外观,而`barStyle`属性改变会联动到`StatusBar`的样式.
	1. 当`barStyle = .default`,表示导航栏的为默认样式,`StatusBar`的样式为了和导航栏区分,就会变成**黑色**.
	2. 当`barStyle = .black`,表示导航栏的颜色为深黑色,`StatusBar`的样式为了和导航栏区分,就会变成**白色**.

这个有点绕,总之就是`StatusBar`的样式和导航栏的样式反着来.

具体实现:

```swift
@IBAction func segmentedControl(_ sender: UISegmentedControl) {
        
    switch sender.selectedSegmentIndex {
    case 0:
    	 // StatusBar为黑色,导航栏颜色为白色
        UINavigationBar.appearance().barStyle = .default
        UINavigationBar.appearance().barTintColor = UIColor.white
    default:
    	 // StatusBar为白色,导航栏颜色为深色
        UINavigationBar.appearance().barStyle = .black
        UINavigationBar.appearance().barTintColor = UIColor.darkNight
    }
    
    // 刷新window下的子控件
    UIApplication.shared.windows.forEach {
        $0.reload()
    }
}

extension UIWindow {
    func reload() {
        subviews.forEach { view in
            view.removeFromSuperview()
            addSubview(view)
        }
    }
}
```

#### 4. 怎么根据导航栏颜色自动修改StatusBar样式

在修改导航栏颜色的时候,判断下导航栏颜色的深浅

```swift
extension UIColor {
    func isDarkColor() -> Bool {
        var w: CGFloat = 0
        self.getWhite(&w, alpha: nil)
        return w > 0.5 ? false : true
    }
}
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="9">9.使用面向协议实现app的主题功能</h2>

#### 1. `UIAppearance`修改全局样式

做为修改全局样式的`UIAppearance`用起来还是很方便的,比如要修改所有`UILabel`的文字颜色.

```swift
UILabel.appearance().textColor = labelColor
```
又或者我们只想修改某个`CustomView`层级下的子控件`UILabel`

```swift
UILabel.appearance(whenContainedInInstancesOf: [CustomView.self]).textColor = labelColor
```

#### 2. 主题协议,以及实现

定义好协议中需要实现的属性和方法

```swift
protocol Theme {
    
    // 自定义的颜色
    var tint: UIColor { get }
    // 定义导航栏的样式,为了联动状态栏(具体见第9小点)
    var barStyle: UIBarStyle { get }
    
    var labelColor: UIColor { get }
    var labelSelectedColor: UIColor { get }
    
    var backgroundColor: UIColor { get }
    var separatorColor: UIColor { get }
    var selectedColor: UIColor { get }
    
    // 设置主题样式
    func apply(for application: UIApplication)
    
    // 对特定主题样式进行扩展
    func extend()
}
```
对协议添加`extension`,这样做的好处是,如果有多个结构体或类实现了协议,而每个结构体或类需要实现相同的方法,这些方法就可以统一放到`extension`中处理,大大提高了代码的复用率.  
如果结构体或类有着相同的方法实现,那么结构体或类的实现会**覆盖**掉协议的`extension`中的实现.

```swift
extension Theme {
    
    func apply(for application: UIApplication) {
        application.keyWindow?.tintColor = tint
        
        
        UITabBar.appearance().with {
            $0.barTintColor = tint
            $0.tintColor = labelColor
        }
        
        UITabBarItem.appearance().with {
            $0.setTitleTextAttributes([.foregroundColor : labelColor], for: .normal)
            $0.setTitleTextAttributes([.foregroundColor : labelSelectedColor], for: .selected)
        }

UINavigationBar.appearance().with {
            $0.barStyle = barStyle
            $0.tintColor = tint
            $0.barTintColor = tint
            $0.titleTextAttributes = [.foregroundColor : labelColor]
        }
        
       UITextView.appearance().with {
            $0.backgroundColor = selectedColor
            $0.tintColor = tint
            $0.textColor = labelColor
        }
        
        extend()
        
        application.windows.forEach { $0.reload() }
    }
    
    // ... 其余相关UIAppearance的设置
    
    
    // 如果某些属性需要在某些主题下定制,可在遵守协议的类或结构体下重写
    func extend() {
        // 在主题中实现相关定制功能
    }
}

```

#### 3. 对主题某些样式的自定义
Demo中白色主题的`UISegmentedControl`需要设置特定的颜色,我们可以在`LightTheme`的`extension`中重写`extend()`方法.

```swift
extension LightTheme {
    
    // 需要自定义的部分写在这边
    func extend() {
        UISegmentedControl.appearance().with {
            $0.tintColor = UIColor.darkText
            $0.setTitleTextAttributes([.foregroundColor : labelColor], for: .normal)
            $0.setTitleTextAttributes([.foregroundColor : UIColor.white], for: .selected)
        }
        UISlider.appearance().tintColor = UIColor.darkText
    }
}

```

#### 4. 主题切换
在设置完`UIAppearance`后需要对所有的控件进行刷新,这个操作放在`apply`方法中.具体实现

```swift
extension UIWindow {
    /// 刷新所有子控件
    func reload() {
        subviews.forEach { view in
            view.removeFromSuperview()
            addSubview(view)
        }
    }
}
```

[示例Demo](https://github.com/DarielChen/SwiftTips/tree/master/Demo/9.%E4%BD%BF%E7%94%A8%E9%9D%A2%E5%90%91%E5%8D%8F%E8%AE%AE%E5%AE%9E%E7%8E%B0app%E7%9A%84%E4%B8%BB%E9%A2%98%E5%8A%9F%E8%83%BD)  
[实现效果](https://github.com/DarielChen/SwiftTips/blob/master/Source/themeDemo.gif)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="10">10.swift中多继承的实现</h2>

#### 1. 实现过程
swift本身并不支持多继承,但我们可以根据已有的API去实现.

swift中的类可以遵守多个协议,但是只可以继承一个类,而值类型(结构体和枚举)只能遵守单个或多个协议,不能做继承操作.

多继承的实现:**协议的方法可以在该协议的`extension`中实现**

```swift
protocol Behavior {
    func run()
}
extension Behavior {
    func run() {
        print("Running...")
    }
}

struct Dog: Behavior {}

let myDog = Dog()
myDog.run() // Running...
```
无论是结构体还是类还是枚举都可以遵守多个协议,所以多继承就这么做到了.

#### 2. 通过多继承为`UIView`扩展方法

```swift
// MARK: - 闪烁功能
protocol Blinkable {
    func blink()
}
extension Blinkable where Self: UIView {
    func blink() {
        alpha = 1
        
        UIView.animate(
            withDuration: 0.5,
            delay: 0.25,
            options: [.repeat, .autoreverse],
            animations: {
                self.alpha = 0
        })
    }
}

// MARK: - 放大和缩小
protocol Scalable {
    func scale()
}
extension Scalable where Self: UIView {
    func scale() {
        transform = .identity
        
        UIView.animate(
            withDuration: 0.5,
            delay: 0.25,
            options: [.repeat, .autoreverse],
            animations: {
                self.transform = CGAffineTransform(scaleX: 1.5, y: 1.5)
        })
    }
}

// MARK: - 添加圆角
protocol CornersRoundable {
    func roundCorners()
}
extension CornersRoundable where Self: UIView {
    func roundCorners() {
        layer.cornerRadius = bounds.width * 0.1
        layer.masksToBounds = true
    }
}

extension UIView: Scalable, Blinkable, CornersRoundable {}

cyanView.blink()
 cyanView.scale()
 cyanView.roundCorners()
```

#### 3. 多继承钻石问题(Diamond Problem),及解决办法
请看下面代码

```swift
protocol ProtocolA {
    func method()
}

extension ProtocolA {
    func method() {
        print("Method from ProtocolA")
    }
}

protocol ProtocolB {
    func method()
}

extension ProtocolB {
    func method() {
        print("Method from ProtocolB")
    }
}

class MyClass: ProtocolA, ProtocolB {}
```
此时`ProtocolA`和`ProtocolB`都有一个默认的实现方法`method()`,由于编译器不知道继承过来的`method()`方法是哪个,就会报错.
> 💎钻石问题,当某一个类或值类型在继承图谱中有多条路径时就会发生.

解决方法:  
	1. 在目标值类型或类中重写那个发生冲突的方法`method()`.  
	2. 直接修改协议中重复的方法

相对来时第二种方法会好一点,所以多继承要注意,尽量避免多继承的协议中的方法的重复.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="11">11.华丽的TableView刷新动效</h2>

[先看效果](https://github.com/DarielChen/SwiftTips/blob/master/Source/TableViewRefreshAnimation2.gif
)(由于这个页面的内容有点多,我尽量不放加载比较耗时的文件)

#### 1. 简单的实现
我们都知道`TableView`的刷新动效是设置在`tableView(_:,willDisplay:,forRowAt:)`这个方法中的.

```swift
override func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    
    cell.alpha = 0
    UIView.animate(
        withDuration: 0.5,
        delay: 0.05 * Double(indexPath.row),
        animations: {
            cell.alpha = 1
    })
}      
```
这样一个简单的淡入效果就OK了.但这样做显然不够优雅,我们如果要在多个`TableView`使用这个效果该怎样封装呢?
#### 2. 使用工厂设计模式进行封装

##### 1. creator(创建者): `Animator`,用来传入参数,和设置动画

```swift
// Animation接收三个参数
typealias Animation = (UITableViewCell, IndexPath, UITableView) -> Void

final class Animator {
    private var hasAnimatedAllCells = false
    private let animation: Animation

init(animation: @escaping Animation) {
        self.animation = animation
    }

func animate(cell: UITableViewCell, at indexPath: IndexPath, in tableView: UITableView) {
        guard !hasAnimatedAllCells else {
            return
        }
        animation(cell, indexPath, tableView)
		// 确保每个cell动画只执行一次
        hasAnimatedAllCells = tableView.isLastVisibleCell(at: indexPath)
    }
}
```

##### 2. product（产品): `AnimationFactory`,用来设置不同的动画类型

```swift
enum AnimationFactory {
    
    static func makeFade(duration: TimeInterval, delayFactor: Double) -> Animation {
        return { cell, indexPath, _ in
            cell.alpha = 0
            
            UIView.animate(
                withDuration: duration,
                delay: delayFactor * Double(indexPath.row),
                animations: {
                    cell.alpha = 1
            })
        }
    }
    
    // ... 
}
```
将所有的动画设置封装在`Animation`的闭包中.

最后我们就可以在`tableView(_:,willDisplay:,forRowAt:)`这个方法中使用了

```swift
let animation = AnimationFactory.makeFade(duration: 0.5, delayFactor: 0.05)
let animator = TableViewAnimator(animation: animation)
animator.animate(cell: cell, at: indexPath, in: tableView)
```

动画相关的可以参考我之前写的文章  [猛击](https://www.jianshu.com/p/6af8a7a8a15a)  
[实现效果](http://pcb5zz9k5.bkt.clouddn.com/TableViewRefreshAnimation2.gif)  
[示例Demo](https://github.com/DarielChen/SwiftTips/tree/master/Demo/11.%E5%8D%8E%E4%B8%BD%E7%9A%84TableView%E5%88%B7%E6%96%B0%E5%8A%A8%E6%95%88)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="12">12.实现一个不基于Runtime的KVO</h2>

Swift并没有在语言层级上支持KVO,如果要使用必须导入`Foundation`框架, 被观察对象必须继承自`NSObject`,这种实现方式显然不够优雅.

KVO本质上还是通过拿到属性的set方法去搞事情,基于这样的原理我们可以自己去实现.

#### 1. 实现
话不多说,直接贴代码,新建一个`Observable`文件

```swift
public class Observable<Type> {
    
    // MARK: - Callback
    fileprivate class Callback {
        fileprivate weak var observer: AnyObject?
        fileprivate let options: [ObservableOptions]
        fileprivate let closure: (Type, ObservableOptions) -> Void
        
        fileprivate init(
            observer: AnyObject,
            options: [ObservableOptions],
            closure: @escaping (Type, ObservableOptions) -> Void) {
            
            self.observer = observer
            self.options = options
            self.closure = closure
        }
    }
    
    // MARK: - Properties
    public var value: Type {
        didSet {
            removeNilObserverCallbacks()
            notifyCallbacks(value: oldValue, option: .old)
            notifyCallbacks(value: value, option: .new)
        }
    }
    
    private func removeNilObserverCallbacks() {
        callbacks = callbacks.filter { $0.observer != nil }
    }
    
    private func notifyCallbacks(value: Type, option: ObservableOptions) {
        let callbacksToNotify = callbacks.filter { $0.options.contains(option) }
        callbacksToNotify.forEach { $0.closure(value, option) }
    }
    
    // MARK: - Object Lifecycle
    public init(_ value: Type) {
        self.value = value
    }
    
    // MARK: - Managing Observers
    private var callbacks: [Callback] = []
    
    
    /// 添加观察者
    ///
    /// - Parameters:
    ///   - observer: 观察者
    ///   - removeIfExists: 如果观察者存在需要移除
    ///   - options: 被观察者
    ///   - closure: 回调
    public func addObserver(
        _ observer: AnyObject,
        removeIfExists: Bool = true,
        options: [ObservableOptions] = [.new],
        closure: @escaping (Type, ObservableOptions) -> Void) {
        
        if removeIfExists {
            removeObserver(observer)
        }
        
        let callback = Callback(observer: observer, options: options, closure: closure)
        callbacks.append(callback)
        
        if options.contains(.initial) {
            closure(value, .initial)
        }
    }
    
    public func removeObserver(_ observer: AnyObject) {
        callbacks = callbacks.filter { $0.observer !== observer }
    }
}

// MARK: - ObservableOptions
public struct ObservableOptions: OptionSet {
    
    public static let initial = ObservableOptions(rawValue: 1 << 0)
    public static let old = ObservableOptions(rawValue: 1 << 1)
    public static let new = ObservableOptions(rawValue: 1 << 2)
    
    public var rawValue: Int
    
    public init(rawValue: Int) {
        self.rawValue = rawValue
    }
}

```
使用起来和KVO差不多.  
#### 2. 使用
需要监听的类

```swift
public class User {
    // 监听的属性需要是Observable类型
    public let name: Observable<String>
    
    public init(name: String) {
        self.name = Observable(name)
    }
}
```
使用

```swift
// 创建对象
let user = User(name: "Made")

// 设置监听
user.name.addObserver(self, options: [.new]) { name, change in
    print("name:\(name), change:\(change)")
}

// 修改对象的属性
user.name.value = "Amel"  // 这时就可以被监听到

// 移除监听
user.name.removeObserver(self)

```
> 注意: 在使用过程中,如果改变value, addObserver方法不调用,很有可能是Observer对象已经被释放掉了.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="13">13.实现多重代理</h2>

作为iOS开发中最常用的设计模式之一`Delegate`,只能是一对一的关系,如果要一对多,就只能使用`NSNotification`了,但我们可以有更好的解决方案,多重代理.

#### 1. 多重代理的实现过程

##### 1. 定义协议

```swift
protocol MasterOrderDelegate: class {
    func toEat(_ food: String)
}
```

##### 2. 定义一个类: 用来管理遵守协议的类

这边用了`NSHashTable`来存储遵守协议的类,`NSHashTable`和`NSSet`类似,但又有所不同,总的来说有这几个特点:  
	1. `NSHashTable`中的元素可以通过`Hashable`协议来判断是否相等.  
	2. `NSHashTable`中的元素如果是弱引用,对象销毁后会被移除,可以避免循环引用.

```swift
class masterOrderDelegateManager : MasterOrderDelegate {
    private let multiDelegate: NSHashTable<AnyObject> = NSHashTable.weakObjects()

init(_ delegates: [MasterOrderDelegate]) {
        delegates.forEach(multiDelegate.add)
    }
    
    // 协议中的方法,可以有多个
    func toEat(_ food: String) {
        invoke { $0.toEat(food) }
    }
    
    // 添加遵守协议的类
    func add(_ delegate: MasterOrderDelegate) {
        multiDelegate.add(delegate)
    }
    
    // 删除指定遵守协议的类
    func remove(_ delegateToRemove: MasterOrderDelegate) {
        invoke {
            if $0 === delegateToRemove as AnyObject {
                multiDelegate.remove($0)
            }
        }
    }
    
    // 删除所有遵守协议的类
    func removeAll() {
        multiDelegate.removeAllObjects()
    }

// 遍历所有遵守协议的类
    private func invoke(_ invocation: (MasterOrderDelegate) -> Void) {
        for delegate in multiDelegate.allObjects.reversed() {
            invocation(delegate as! MasterOrderDelegate)
        }
    }
}
```

##### 3. 其余部分

```swift
class Master {
    weak var delegate: MasterOrderDelegate?
    
    func orderToEat() {
        delegate?.toEat("meat")
    }
}

class Dog {
}
extension Dog: MasterOrderDelegate {
    func toEat(_ food: String) {
        print("\(type(of: self)) is eating \(food)")
    }
    
}

class Cat {
}
extension Cat: MasterOrderDelegate {
    func toEat(_ food: String) {
        print("\(type(of: self)) is eating \(food)")
    }
}

let cat = Cat()
let dog = Dog()
let cat1 = Cat()

let master = Master()
// master的delegate是弱引用,所以不能直接赋值
let delegate = masterOrderDelegateManager([cat, dog])
// 添加遵守该协议的类
delegate.add(cat1)
// 删除遵守该协议的类
delegate.remove(dog)

master.delegate = delegate
master.orderToEat()

// 输出
// Cat is eating meat
// Cat is eating meat
```

#### 2. 多重代理的应用场景
1. IM消息接收之后在多个地方做回调,比如显示消息,改变小红点,显示消息数.
2. `UISearchBar`的回调,当我们需要在多个地方获取数据的时候,类似的还有`UINavigationController`的回调等.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="14">14.自动检查控制器是否被销毁</h2>

检查内存泄漏除了使用`Instruments`,还有查看控制器`pop`或`dismiss`后是否被销毁,后者相对来说更方便一点.但老是盯着析构函数`deinit`看日志输出是否有点麻烦呢?

`UIViewController`有提供两个不知名的属性:

1. `isBeingDismissed`: 当modal出来的控制器被`dismiss`后的值为`true`.  
 2.  `isMovingFromParent`: 在控制器的堆栈中,如果当前控制器从父控制器中移除,值会变成`true`.

如果这两个属性都为`true`,表明控制器马上要被销毁了,但这是由ARC去做内存管理,我们并不知道多久之后被销毁,简单起见就设个2秒吧.

```swift
extension UIViewController {
    
    public func dch_checkDeallocation(afterDelay delay: TimeInterval = 2.0) {
        let rootParentViewController = dch_rootParentViewController
        
        if isMovingFromParent || rootParentViewController.isBeingDismissed {
            let disappearanceSource: String = isMovingFromParent ? "removed from its parent" : "dismissed"
            DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: { [weak self] in
                if let VC = self {
                    assert(self == nil, "\(VC.description) not deallocated after being \(disappearanceSource)")
                }
            })
        }
    }
    private var dch_rootParentViewController: UIViewController {
        var root = self
        while let parent = root.parent {
            root = parent
        }
        return root
    }
}
```
我们把这个方法添加到`viewDidDisappear(_:)`中

```swift
override func viewDidDisappear(_ animated: Bool) {
    super.viewDidDisappear(animated)
    
    dch_checkDeallocation()
}
```
如果发生循环引用,控制就不会被销毁,会触发`assert`报错.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="15">15.向控制器中注入代码</h2>

使用场景: 在某些控制器的`viewDidLoad`方法中,我们需要添加一段代码,用于统计某个页面的打开次数.

最常用的解决方案:   
在父类或者`extension`中定义一个方法,然后在需要做统计的控制器的`viewDidLoad`方法中调用刚刚定义好的方法.

或者还可以使用代码注入.
#### 1. 代码注入的使用

```swift
ViewControllerInjector.inject(into: [ViewController.self], selector: #selector(UIViewController.viewDidLoad)) {

// $0 为ViewController对象            
	// 统计代码...
}
```

#### 2.代码注入的实现

swift虽然是门静态语言,但依然支持OC的`runtime`.可以允许我们在静态类型中使用动态代码.代码注入就是通过`runtime`的交换方法实现的.

```swift
class ViewControllerInjector {
    
    typealias methodRef = @convention(c)(UIViewController, Selector) -> Void
    
    static func inject(into supportedClasses: [UIViewController.Type], selector: Selector, injection: @escaping (UIViewController) -> Void) {
        
        guard let originalMethod = class_getInstanceMethod(UIViewController.self, selector) else {
            fatalError("\(selector) must be implemented")
        }
        
        var originalIMP: IMP? = nil
        
        let swizzledViewDidLoadBlock: @convention(block) (UIViewController) -> Void = { receiver in
            if let originalIMP = originalIMP {
                let castedIMP = unsafeBitCast(originalIMP, to: methodRef.self)
                castedIMP(receiver, selector)
            }
            
            if ViewControllerInjector.canInject(to: receiver, supportedClasses: supportedClasses) {
                injection(receiver)
            }
        }
        
        let swizzledIMP = imp_implementationWithBlock(unsafeBitCast(swizzledViewDidLoadBlock, to: AnyObject.self))
        originalIMP = method_setImplementation(originalMethod, swizzledIMP)
    }
    
    
    private static func canInject(to receiver: Any, supportedClasses: [UIViewController.Type]) -> Bool {
        let supportedClassesIDs = supportedClasses.map { ObjectIdentifier($0) }
        let receiverType = type(of: receiver)
        return supportedClassesIDs.contains(ObjectIdentifier(receiverType))
    }
}
```
代码注入可以在不修改原有代码的基础上自定义自己所要的.相比继承,代码的可重用性会高一点,侵入性会小一点.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="16">16.给Extension添加存储属性</h2>

我们都知道`Extension`中可以添加计算属性,但不能添加存储属性.

对 我们可以使用`runtime`

```swift
private var nameKey: Void?
extension UIView {
    // 给UIView添加一个name属性
    var name: String? {
        get {
            return objc_getAssociatedObject(self, &nameKey) as? String
        }
        set {
            objc_setAssociatedObject(self, &nameKey, newValue, .OBJC_ASSOCIATION_COPY_NONATOMIC)
        }
    }
}
```

给分类添加常见的数据类型属性按照上面这种方式可以实现，但如果需要给分类添加自定义对象呢？按照上面的方式会报错，错误提示我们要在自定义对象中实现`copyWithZone`方法，如下代码所示

```swift
class CustomClass: NSObject, NSCopying {

func copy(with zone: NSZone? = nil) -> Any {
        return self
    }
}

private var customClassKey: Void?
extension UIView {
    
    var customObject: CustomClass? {
        get { return objc_getAssociatedObject(self, &customClassKey) as? CustomClass }
        set { objc_setAssociatedObject(self, &customClassKey, newValue, .OBJC_ASSOCIATION_COPY_NONATOMIC) }
    }
}
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="17">17.用闭包实现按钮的链式点击事件</h2>

#### 1. 通常姿势

通常按钮的点击事件我们需要这样写:

```swift
btn.addTarget(self, action: #selector(actionTouch), for: .touchUpInside)

@objc func actionTouch() {
    print("按钮点击事件")
}
```
如果有多个点击事件,往往还要写多个方法,写多了有没有觉得有点烦,代码阅读起来还要上下跳转.

#### 2. 使用闭包封装
##### 1. 实现

```swift
private var actionDictKey: Void?
public typealias ButtonAction = (UIButton) -> ()

extension UIButton {
    
    // MARK: - 属性
    // 用于保存所有事件对应的闭包
    private var actionDict: (Dictionary<String, ButtonAction>)? {
        get {
            return objc_getAssociatedObject(self, &actionDictKey) as? Dictionary<String, ButtonAction>
        }
        set {
            objc_setAssociatedObject(self, &actionDictKey, newValue, .OBJC_ASSOCIATION_COPY_NONATOMIC)
        }
    }
    
    // MARK: - API
    @discardableResult
    public func addTouchUpInsideAction(_ action: @escaping ButtonAction) -> UIButton {
        self.addButton(action: action, for: .touchUpInside)
        return self
    }
    
    @discardableResult
    public func addTouchUpOutsideAction(_ action: @escaping ButtonAction) -> UIButton {
        self.addButton(action: action, for: .touchUpOutside)
        return self
    }
    
    @discardableResult
    public func addTouchDownAction(_ action: @escaping ButtonAction) -> UIButton {
        self.addButton(action: action, for: .touchDown)
        return self
    }
    
    // ...其余事件可以自己扩展
    
    // MARK: - 私有方法
    private func addButton(action: @escaping ButtonAction, for controlEvents: UIControl.Event) {
        
        let eventKey = String(controlEvents.rawValue)

if var actionDict = self.actionDict {
            actionDict.updateValue(action, forKey: eventKey)
            self.actionDict = actionDict
        }else {
            self.actionDict = [eventKey: action]
        }

switch controlEvents {
        case .touchUpInside:
            addTarget(self, action: #selector(touchUpInsideControlEvent), for: .touchUpInside)
        case .touchUpOutside:
            addTarget(self, action: #selector(touchUpOutsideControlEvent), for: .touchUpOutside)
        case .touchDown:
            addTarget(self, action: #selector(touchDownControlEvent), for: .touchDown)
        default:
            break
        }
    }
    
    // 响应事件
    @objc private func touchUpInsideControlEvent() {
        executeControlEvent(.touchUpInside)
    }
    @objc private func touchUpOutsideControlEvent() {
        executeControlEvent(.touchUpOutside)
    }
    @objc private func touchDownControlEvent() {
        executeControlEvent(.touchDown)
    }
    
    @objc private func executeControlEvent(_ event: UIControl.Event) {
        let eventKey = String(event.rawValue)
        if let actionDict = self.actionDict, let action = actionDict[eventKey] {
            action(self)
        }
    }
}

```

##### 2. 使用

```swift
 btn
    .addTouchUpInsideAction { btn in
        print("addTouchUpInsideAction")
    }.addTouchUpOutsideAction { btn in
        print("addTouchUpOutsideAction")
    }.addTouchDownAction { btn in
        print("addTouchDownAction")
    }
```
##### 3. 实现原理
利用`runtime`在按钮的`extension`中添加一个字典属性,`key`对应的是事件类型,`value`对应的是该事件类型所要执行的闭包.然后再添加按钮的监听事件,在响应方法中,根据事件类型找到并执行对应的闭包.

链式调用就是不断返回自身.

有没有觉得如果这样做代码写起来会简洁一点呢?

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="18">18.用闭包实现手势的链式监听事件</h2>

和tips17中的按钮点击事件类似,手势也可以封装成链式闭包回调.

#### 1. 使用

```swift
view
    .addTapGesture { tap in
        print(tap)
    }.addPinchGesture { pinch in
        print(pinch)
    }
```

#### 2. 实现过程

```swift
public typealias GestureClosures = (UIGestureRecognizer) -> Void
private var gestureDictKey: Void?

extension UIView {
    private enum GestureType: String {
        case tapGesture
        case pinchGesture
        case rotationGesture
        case swipeGesture
        case panGesture
        case longPressGesture
    }

// MARK: - 属性
    private var gestureDict: [String: GestureClosures]? {
        get {
            return objc_getAssociatedObject(self, &gestureDictKey) as? [String: GestureClosures]
        }
        set {
            objc_setAssociatedObject(self, &gestureDictKey, newValue, .OBJC_ASSOCIATION_COPY_NONATOMIC)
        }
    }

// MARK: - API
    /// 点击
    @discardableResult
    public func addTapGesture(_ gesture: @escaping GestureClosures) -> UIView {
        addGesture(gesture: gesture, for: .tapGesture)
        return self
    }
    /// 捏合
    @discardableResult
    public func addPinchGesture(_ gesture: @escaping GestureClosures) -> UIView {
        addGesture(gesture: gesture, for: .pinchGesture)
        return self
    }
   	 // ...省略相关手势
   	 
    // MARK: - 私有方法
    private func addGesture(gesture: @escaping GestureClosures, for gestureType: GestureType) {
        let gestureKey = String(gestureType.rawValue)
        if var gestureDict = self.gestureDict {
            gestureDict.updateValue(gesture, forKey: gestureKey)
            self.gestureDict = gestureDict
        } else {
            self.gestureDict = [gestureKey: gesture]
        }
        isUserInteractionEnabled = true
        switch gestureType {
        case .tapGesture:
            let tap = UITapGestureRecognizer(target: self, action: #selector(tapGestureAction(_:)))
            addGestureRecognizer(tap)
        case .pinchGesture:
            let pinch = UIPinchGestureRecognizer(target: self, action: #selector(pinchGestureAction(_:)))
            addGestureRecognizer(pinch)
        default:
            break
        }
    }
    @objc private func tapGestureAction (_ tap: UITapGestureRecognizer) {
        executeGestureAction(.tapGesture, gesture: tap)
    }
    @objc private func pinchGestureAction (_ pinch: UIPinchGestureRecognizer) {
        executeGestureAction(.pinchGesture, gesture: pinch)
    }
   
    private func executeGestureAction(_ gestureType: GestureType, gesture: UIGestureRecognizer) {
        let gestureKey = String(gestureType.rawValue)
        if let gestureDict = self.gestureDict, let gestureReg = gestureDict[gestureKey] {
            gestureReg(gesture)
        }
    }
}
```

具体实现 [猛击](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/Extension/UIView%2BExtension.swift)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="19">19.用闭包实现通知的监听事件</h2>

#### 1. 使用

```swift
// 通知监听
self.observerNotification(.notifyName1) { notify in
    print(notify.userInfo)
}
// 发出通知
self.postNotification(.notifyName1, userInfo: ["infoKey": "info"])

// 移除通知
self.removeNotification(.notifyName1)
```

#### 2. 实现

```swift
public typealias NotificationClosures = (Notification) -> Void
private var notificationActionKey: Void?

// 用于存放通知名称
public enum NotificationNameType: String {
    case notifyName1
    case notifyName2
}

extension NSObject {
    private var notificationClosuresDict: [NSNotification.Name: NotificationClosures]? {
        get {
            return objc_getAssociatedObject(self, &notificationActionKey)
                as? [NSNotification.Name: NotificationClosures]
        }
        set {
            objc_setAssociatedObject(self, &notificationActionKey, newValue, .OBJC_ASSOCIATION_COPY_NONATOMIC)
        }
    }
    public func postNotification(_ name: NotificationNameType, userInfo: [AnyHashable: Any]?) {
        NotificationCenter.default.post(name: NSNotification.Name(name.rawValue), object: self, userInfo: userInfo)
    }
    public func observerNotification(_ name: NotificationNameType, action: @escaping NotificationClosures) {
        if var dict = notificationClosuresDict {
            guard dict[NSNotification.Name(name.rawValue)] == nil else {
                return
            }
            dict.updateValue(action, forKey: NSNotification.Name(name.rawValue))
            self.notificationClosuresDict = dict
        } else {
            self.notificationClosuresDict = [NSNotification.Name(name.rawValue): action]
        }
        NotificationCenter.default.addObserver(self, selector: #selector(notificationAction),
                                               name: NSNotification.Name(name.rawValue), object: nil)
    }
    public func removeNotification(_ name: NotificationNameType) {
        NotificationCenter.default.removeObserver(self)
        notificationClosuresDict?.removeValue(forKey: NSNotification.Name(name.rawValue))
    }
    @objc func notificationAction(notify: Notification) {
        if let notificationClosures = notificationClosuresDict, let closures = notificationClosures[notify.name] {
            closures(notify)
        }
    }
}
```
具体实现过程和tips17、tips18类似.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="20">20.AppDelegate解耦</h2>

作为iOS整个项目的核心`App delegate`,随着项目的逐渐变大,会变得越来越臃肿,一不小心代码就过了千行.

大型项目的`App delegate`体积会大到什么程度呢?我们可以参考下国外2亿多月活的`Telegram`的 [App delegate](https://github.com/peter-iakovlev/Telegram/blob/public/Telegraph/TGAppDelegate.mm).是不是吓一跳,4千多行.看到这样的代码是不是很想点击左上角的x.

是时候该给`App delegate`解耦了,目标: 每个功能的配置或者初始化都分开,各自做各自的事情.`App delegate`要做到只需要调用就好了.

#### 1.命令模式

> 命令模式: 发送方发送请求,然后接收方接受请求后执行,但发送方可能并不知道接受方是谁，执行的是什么操作,这样做的好处是发送方和接受方完全的松耦合，大大提高程序的灵活性.

##### 1. 定义好协议,把相关初始化配置代码分类

```swift
protocol Command {
    func execute()
}

struct InitializeThirdPartiesCommand: Command {
    func execute() {
        // 第三方库初始化代码
    }
}

struct InitialViewControllerCommand: Command {
    let keyWindow: UIWindow
    func execute() {
        // 根控制器设置代码
    }
}

struct InitializeAppearanceCommand: Command {
    func execute() {
        // 全局外观样式配置
    }
}

struct RegisterToRemoteNotificationsCommand: Command {
    func execute() {
        // 远程推送配置        
    }
}

```
##### 2. 管理者

```swift

final class StartupCommandsBuilder {
    private var window: UIWindow!
    
    func setKeyWindow(_ window: UIWindow) -> StartupCommandsBuilder {
        self.window = window
        return self
    }
    
    func build() -> [Command] {
        return [
            InitializeThirdPartiesCommand(),
            InitialViewControllerCommand(keyWindow: window),
            InitializeAppearanceCommand(),
            RegisterToRemoteNotificationsCommand()
        ]
    }
}
```

##### 3. `App delegate`调用

```swift
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        StartupCommandsBuilder()
            .setKeyWindow(window!)
            .build()
            .forEach { $0.execute() }
        
        return true
}
```

使用命令模式的好处是,如果要添加新的配置,设置完后只要加在`StartupCommandsBuilder`中就可以了.`App delegate`中不需要添加任何内容.

但这样做只能将`didFinishLaunchingWithOptions`中的代码解耦,`App delegate`中的其他方法怎样解耦呢?

#### 2.组合模式

> 组合模式: 可以将对象组合成树形结构来表现"整体/部分"层次结构. 组合后可以以一致的方法处理个别对象以及组合对象.

这边我们给`App delegate`每个功能模块都设置一个子类,每个子类包含所有`App delegate`的方法.

##### 1. 每个子模块实现各自的功能

```swift
// 推送
class PushNotificationsAppDelegate: AppDelegateType {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        print("推送配置")
        return true
    }
    
    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        print("推送相关代码...")
    }
    
    // 其余方法
}

// 外观样式
class AppearanceAppDelegate: AppDelegateType {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        print("外观样式配置")
        return true
    }
}

// 控制器处理
class ViewControllerAppDelegate: AppDelegateType {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        print("根控制器设置代码")
        return true
    }
}

// 第三方库
class ThirdPartiesConfiguratorAppDelegate: AppDelegateType {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        print("第三方库初始化代码")
        return true
    }

func applicationDidEnterBackground(_ application: UIApplication) {
        print("ThirdPartiesConfiguratorAppDelegate - applicationDidEnterBackground")
    }
    
    func applicationDidBecomeActive(_ application: UIApplication) {
        print("ThirdPartiesConfiguratorAppDelegate - applicationDidBecomeActive")
    }

}

```
##### 2. 管理者

```swift
typealias AppDelegateType = UIResponder & UIApplicationDelegate

class CompositeAppDelegate: AppDelegateType {
    private let appDelegates: [AppDelegateType]

init(appDelegates: [AppDelegateType]) {
        self.appDelegates = appDelegates
    }

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        appDelegates.forEach { _ = $0.application?(application, didFinishLaunchingWithOptions: launchOptions) }
        return true
    }

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        appDelegates.forEach { _ = $0.application?(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken) }
    }

func applicationDidEnterBackground(_ application: UIApplication) {
        appDelegates.forEach { _ = $0.applicationDidEnterBackground?(application)
        }
    }

func applicationDidBecomeActive(_ application: UIApplication) {
        appDelegates.forEach { _ = $0.applicationDidBecomeActive?(application)
        }
    }
}
```

##### 3. `App delegate`调用

```swift
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

var window: UIWindow?
    let appDelegate = AppDelegateFactory.makeDefault()

enum AppDelegateFactory {
        static func makeDefault() -> AppDelegateType {
            
            return CompositeAppDelegate(appDelegates: [
                PushNotificationsAppDelegate(),
                AppearanceAppDelegate(),
                ThirdPartiesConfiguratorAppDelegate(),
                ViewControllerAppDelegate(),
                ]
            )
        }
    }

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
         _ = appDelegate.application?(application, didFinishLaunchingWithOptions: launchOptions)
        return true
    }

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        appDelegate.application?(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken)
    }

func applicationDidBecomeActive(_ application: UIApplication) {
        appDelegate.applicationDidBecomeActive?(application)
    }

func applicationDidEnterBackground(_ application: UIApplication) {
        appDelegate.applicationDidEnterBackground?(application)
    }
}

```
`App delegate`解耦相比命令模式,使用组合模式可自定义程度会更高一点.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="21">21.常见的编译器诊断指令</h2>

swift标准库提供了很多编译器诊断指令,用于在编译阶段提前处理好相关事情.

下面列出了一些常见的编译器诊断指令:

##### 1. 代码中警告错误标识: #warning和#error
swift4.2中添加了这两个命令,再也不用在项目中自己配置错误和警告的命令了.

警告⚠️:

```swift
// Xcode会报一条黄色警告
#warning("此处逻辑有问题,明天再说")

// TODO
#warning("TODO: Update this code for the new iOS 12 APIs")
```
错误❌:

```swift
// 手动设置一条错误
#error("This framework requires UIKit!")
```

##### 2. #if - #endif 条件判断

```swift
#if !canImport(UIKit)
#error("This framework requires UIKit!")
#endif

#if DEBUG
#warning("TODO: Update this code for the new iOS 12 APIs")
#endif        
```

##### 3. #file、#function、#line
分别用于获取文件名,函数名称,当前所在行数,一般用于辅助日志输出.

自定义Log

```swift
public struct dc {
    
    /// 自定义Log
    ///
    /// - Parameters:
    ///   - message: 输出的内容
    ///   - file: 默认
    ///   - method: 默认
    ///   - line: 默认
    public static func log<T>(_ message: T, file: NSString = #file, method: String = #function, line: Int = #line) {
        #if DEBUG
        print("\(file.pathComponents.last!):\(method)[\(line)]: \(message)")
        #endif
    }
}
```

##### 4. #available和@available

一般用来判断当前代码块在某个版本及该版本以上是否可用.

```swift
if #available(iOS 8, *) {
    // iOS 8 及其以上系统运行
}

guard #available(iOS 8, *) else {
    return //iOS 8 以下系统就直接返回
}

@available(iOS 11.4, *)
func myMethod() {
    // do something
}
```

##### 5. 判断是真机还是模拟器

判断是真机还是模拟器我们常用的方式是通过`arch`

```swift
#if (arch(i386) || arch(x86_64))
    // this is the simulator
#else
    // this is a real device
#endif
```

推荐使用`targetEnvironment`来判断

```swift
#if targetEnvironment(simulator)
    // this is the simulator
#else
    // this is a real device
#endif
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="22">22.最后执行的defer代码块</h2>

`defer`这个关键字不是很常用,但有时还是很有用的.

具体用法,简而言之就是,`defer`代码块会在函数的return前执行.

```swift
func printStringNumbers() {
    defer { print("1") }
    defer { print("2") }
    defer { print("3") }
    
    print("4")
}
printStringNumbers() // 打印 4 3 2 1
```

下面列举几个常见的用途:

##### 1. try-catch

```swift
func foo() throws {
        
	defer {
	    print("two")
	}
	    
	do {
	    print("one")
	    throw NSError()
	    print("不会执行")
	}
	print("不会执行")
}

do {
    try foo()
} catch  {
    print("three")
}
// 打印 one two three
```
`defer`可在函数throw之后被执行,而如果将代码添加到`throw NSError()`底部和`do{}`底部都不会被执行.

##### 2. 文件操作

```swift
func writeFile() {
    let file: FileHandle? = FileHandle(forReadingAtPath: filepath)
    defer { file?.closeFile() }
    
    // 文件相关操作
}
```
这样一方面可读性好一点,另一方面不会因为某个地方throw了一个错误而没有关闭资源文件了.

##### 3. 避免忘记回调

```swift
func getData(completion: (_ result: Result<String>) -> Void) {
    var result: Result<String>?

defer {
        guard let result = result else {
            fatalError("We should always end with a result")
        }
        completion(result)
    }

// result的处理逻辑
}
```
`defer`中可以做一些result的验证逻辑,这样不会和result的处理逻辑混淆,代码清晰.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="23">23.定义全局常量</h2>

作为整个项目中通用的全局常量为了方便管理最好集中定义在一个地方.

下面介绍几种全局常量定义的姿势:

##### 1. 使用结构体

```swift
public struct Screen {
    static var width: CGFloat {
        return UIScreen.main.bounds.size.width
    }
    static var height: CGFloat {
        return UIScreen.main.bounds.size.height
    }
    static var statusBarHeight: CGFloat {
        return UIApplication.shared.statusBarFrame.height
    }
}

Screen.width  // 屏幕宽度
Screen.height // 屏幕高度
Screen.statusBarHeight // statusBar高度
```

好处是能比较直观的看出全局常量的定义逻辑,方便后面扩展.

##### 2. 使用没有case的枚举

正常情况下的`enum`都是与`case`搭配使用,如果使用了`case`就要实例化`enum`.其实也可以不写`case`.

```swift
public enum ConstantsEnum {
     static let width: CGFloat = 100
     static let height: CGFloat = 50
}

ConstantsEnum.width

let instance = ConstantsEnum()
// ERROR: 'ConstantsEnum' cannot be constructed because it has no accessible initializers
```
`ConstantsEnum`不可以实例化,会报错.

相比`struct`,使用枚举定义常量可以避免不经意间实例化对象.

##### 3. 使用extension
使用`extension`几乎可以为任何类型扩展常量.

例如,通知名称

```swift
extension Notification.Name {
    // 名称
    static let customNotification = Notification.Name("customNotification")
}

NotificationCenter.default.post(name: .customNotification, object: nil)
```

增加自定义颜色

```swift
extension UIColor {
    class var myGolden: UIColor {
        return UIColor(red: 1.000, green: 0.894, blue: 0.541, alpha: 0.900)
    }
}

view.backgroundColor = .myGolden
```

增加double常量

```swift
extension Double {
    public static let kRectX = 30.0
    public static let kRectY = 30.0
    public static let kRectWidth = 30.0
    public static let kRectHeight = 30.0
}

CGRect(x: .kRectX, y: .kRectY, width: .kRectWidth, height: .kRectHeight)
```

因为传入参数类型是确定的,我们可以把类型名省略,直接用点语法.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="24">24.使用Codable协议解析JSON</h2>

swift4.0推出的`Codable`协议用来解析JSON还是挺不错的.

##### 1. JSON、模型互相转化

```swift
public protocol Decodable { 
	public init(from decoder: Decoder) throws 
}
public protocol Encodable { 
	public func encode(to encoder: Encoder) throws 
} 
public typealias Codable = Decodable & Encodable
```
`Codable`是`Decodable`和`Encodable`这两个协议的综合,只要遵守了`Codable `协议,编译器就能帮我们实现好一些细节,然后就可以做编码和解码操作了.

```swift
public struct Pet: Codable {
    var name: String
    var age: Int
}

let json = """
    [{
        "name": "WangCai",
        "age": 2,
    },{
        "name": "xiaoHei",
        "age": 3,
    }]
    """.data(using: .utf8)!
    
// JSON -> 模型
let decoder = JSONDecoder()
do {
    // 对于数组可以使用[Pet].self
    let dogs = try decoder.decode([Pet].self, from: json)
    print(dogs)
}catch {
    print(error)
}
    
// 模型 -> JSON
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted // 美化样式
do {
    let data = try encoder.encode(Pet(name: "XiaoHei", age: 3))
    print(String(data: data, encoding: .utf8)!)
//      {
//          "name" : "XiaoHei",
//          "age" : 3
//      }
} catch {
    print(error)
}
```

##### 2. `Codable`做了哪些事情

下面我们重写系统的方法.

```swift
init(name: String, age: Int) {  
    self.name = name  
    self.age = age
}

// decoding 
init(from decoder: Decoder) throws { 
    let container = try decoder.container(keyedBy: CodingKeys.self)  
    let name = try container.decode(String.self, forKey: .name)  
    let age = try container.decode(Int.self, forKey: .age)  
    self.init(name: name, age: age) 
}

// encoding 
func encode(to encoder: Encoder) throws {  
    var container = encoder.container(keyedBy: CodingKeys.self)  
    try container.encode(name, forKey: .name)  
    try container.encode(age, forKey: .age) 
}

enum CodingKeys: String, CodingKey {  
    case name  
    case age
}
```

对于编码和解码的过程,我们都是创建一个容器,该容器有一个`keyedBy`的参数,用于指定属性和JSON中key两者间的映射的规则,因此我们传`CodingKeys`的类型过去,说明我们要使用该规则来映射.对于解码的过程,我们使用该容器来进行解码,指定要值的类型和获取哪一个key的值,同样的,编码的过程中,我们使用该容器来指定要编码的值和该值对应json中的key.

##### 3. `Codable`实际使用场景

当然了,现实开发中需要解析的JSON不会这么简单.

```swift

let json = """
        {
            "aircraft": {
                "identification": "NA875",
                "color": "Blue/White"
            },
            "route": ["KTTD", "KHIO"],
            "departure_time": {
                "proposed": 1540868946509,
                "actual": 1540869946509,
            },
            "flight_rules": "IFR",
            "remarks": null,
            "price": "NaN",
        }
        """.data(using: .utf8)!

public struct Aircraft: Codable {
    public var identification: String
    public var color: String
}
public enum FlightRules: String, Codable {
    case visual = "VFR"
    case instrument = "IFR"
}
public struct FlightPlan: Codable {
    // 嵌套模型
    public var aircraft: Aircraft
    // 包含数组
    public var route: [String]
    // 日期处理
    private var departureTime: [String: Date]
    public var proposedDepartureDate: Date? {
        return departureTime["proposed"]
    }
    public var actualDepartureDate: Date? {
        return departureTime["actual"]
    }
    // 枚举处理
    public var flightRules: FlightRules
    // 空值处理
    public var remarks: String?
    // 特殊值处理
    public var price: Float
    // 下划线key转驼峰命名
    private enum CodingKeys: String, CodingKey {
        case aircraft
        case flightRules = "flight_rules"
        case route
        case departureTime = "departure_time"
        case remarks
        case price
    }
}

let decoder = JSONDecoder()

// 解码时,日期格式是13位时间戳 .base64:通过base64解码
decoder.dateDecodingStrategy = .millisecondsSince1970

// 指定 infinity、-infinity、nan 三个特殊值的表示方式
decoder.nonConformingFloatDecodingStrategy = .convertFromString(positiveInfinity: "+∞", negativeInfinity: "-∞", nan: "NaN")

do {
    let plan = try decoder.decode(FlightPlan.self, from: json)
    
    plan.aircraft.color // Blue/White
    plan.aircraft.identification // NA875
    plan.route // ["KTTD", "KHIO"]
    plan.proposedDepartureDate // 2018-10-30 03:09:06 +0000
    plan.actualDepartureDate // 2018-10-30 03:25:46 +0000
    plan.flightRules // instrument
    plan.remarks // 可选类型 空
    plan.price // nan
    
}catch {
    print(error)
}

```

swift4.1中有个属性可以自动将key转化为驼峰命名:
`decoder.keyDecodingStrategy = .convertFromSnakeCase`,如果`CodingKeys`只是用来转成驼峰命名的话,设置好这个属性后就可以不用写`CodingKeys`这个枚举了.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="25">25.dispatch_once替代方案</h2>

OC中用来保证代码块只执行一次的`dispatch_once`在swfit中已经被废弃了,取而代之的是使用`static let`,`let`本身就带有线程安全性质的.

例如单例的实现.

```swift
final public class MySingleton {
    static let shared = MySingleton()
    private init() {}
}
```
但如果我们不想定义常量,需要某个代码块执行一次呢?

```swift
private lazy var takeOnceTime: Void = {
    // 代码块...
}()

_ = takeOnceTime
```
定义一个懒加载的变量,防止在初始化的时候被执行.后面加一个`void`,为了在`_ = takeOnceTime`赋值时不耗性能,返回一个`Void`类型.

`lazy var`改为`static let`也可以,为了使用方便,我们用一个类方法封装下

```swift
class ClassName {
    private static let takeOnceTime: Void = {
        // 代码块...
    }()
    static func takeOnceTimeFunc() {
        ClassName.takeOnceTime
    }
}

// 使用
ClassName.takeOnceTimeFunc()
```
这样就可以做到和`dispatch_once`一样的效果了.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="26">26.被废弃的+load()和+initialize()</h2>

我们都知道OC中两个方法`+load()`和`+initialize()`.

`+load()`:  app启动的时候会加载所有的类,此时就会调用每个类的load方法.  
`+initialize()`: 第一次初始化这个类的时候会被调用.

然而在目前的swift版本中这两个方法都不可用了,那现在我们要在这个阶段搞事情该怎么做? 例如`method swizzling`.

[JORDAN SMITH大神](http://jordansmith.io/handling-the-deprecation-of-initialize/)给出了一种很巧解决方案.`UIApplication`有一个`next`属性,它会在`applicationDidFinishLaunching`之前被调用,这个时候通过`runtime`获取到所有类的列表,然后向所有遵循SelfAware协议的类发送消息.

```swift
extension UIApplication {
    private static let runOnce: Void = {
        NothingToSeeHere.harmlessFunction()
    }()
    override open var next: UIResponder? {
        // Called before applicationDidFinishLaunching
        UIApplication.runOnce
        return super.next
    }
}

protocol SelfAware: class {
    static func awake()
}
class NothingToSeeHere {
    static func harmlessFunction() {
        let typeCount = Int(objc_getClassList(nil, 0))
        let types = UnsafeMutablePointer<AnyClass>.allocate(capacity: typeCount)
        let autoreleasingTypes = AutoreleasingUnsafeMutablePointer<AnyClass>(types)
        objc_getClassList(autoreleasingTypes, Int32(typeCount))
        for index in 0 ..< typeCount {
            (types[index] as? SelfAware.Type)?.awake()
        }
        types.deallocate()
    }
}
```

之后任何遵守`SelfAware`协议实现的`+awake()`方法在这个阶段都会被调用.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="27">27.交换方法 Method Swizzling</h2>

黑魔法`Method Swizzling`在swift中实现的两个困难点

- swizzling 应该保证只会执行一次.
- swizzling 应该在加载所有类的时候调用.

分别在`tips25`和`tips26`中给出了解决方案.

下面给出了两个示例供参考:

```swift
protocol SelfAware: class {
    static func awake()
    static func swizzlingForClass(_ forClass: AnyClass, originalSelector: Selector, swizzledSelector: Selector)
}

extension SelfAware {
    
    static func swizzlingForClass(_ forClass: AnyClass, originalSelector: Selector, swizzledSelector: Selector) {
        let originalMethod = class_getInstanceMethod(forClass, originalSelector)
        let swizzledMethod = class_getInstanceMethod(forClass, swizzledSelector)
        guard (originalMethod != nil && swizzledMethod != nil) else {
            return
        }
        if class_addMethod(forClass, originalSelector, method_getImplementation(swizzledMethod!), method_getTypeEncoding(swizzledMethod!)) {
            class_replaceMethod(forClass, swizzledSelector, method_getImplementation(originalMethod!), method_getTypeEncoding(originalMethod!))
        } else {
            method_exchangeImplementations(originalMethod!, swizzledMethod!)
        }
    }
}

class NothingToSeeHere {
    static func harmlessFunction() {
        let typeCount = Int(objc_getClassList(nil, 0))
        let types = UnsafeMutablePointer<AnyClass>.allocate(capacity: typeCount)
        let autoreleasingTypes = AutoreleasingUnsafeMutablePointer<AnyClass>(types)
        objc_getClassList(autoreleasingTypes, Int32(typeCount))
        for index in 0 ..< typeCount {
            (types[index] as? SelfAware.Type)?.awake()
        }
        types.deallocate()
    }
}
extension UIApplication {
    private static let runOnce: Void = {
        NothingToSeeHere.harmlessFunction()
    }()
    override open var next: UIResponder? {
        UIApplication.runOnce
        return super.next
    }
}
```
在`SelfAware`的`extension`中为`swizzlingForClass`做了默认实现,相当于一层封装.

###### 1. 给按钮添加点击计数

```swift
extension UIButton: SelfAware {
    static func awake() {
        UIButton.takeOnceTime
    }
    private static let takeOnceTime: Void = {
        let originalSelector = #selector(sendAction)
        let swizzledSelector = #selector(xxx_sendAction(action:to:forEvent:))
        
        swizzlingForClass(UIButton.self, originalSelector: originalSelector, swizzledSelector: swizzledSelector)
    }()
    
    @objc public func xxx_sendAction(action: Selector, to: AnyObject!, forEvent: UIEvent!) {
        struct xxx_buttonTapCounter {
            static var count: Int = 0
        }
        xxx_buttonTapCounter.count += 1
        print(xxx_buttonTapCounter.count)
        xxx_sendAction(action: action, to: to, forEvent: forEvent)
    }
}
```
###### 2. 替换控制器的`viewWillAppear`方法

```swift
extension UIViewController: SelfAware {
    static func awake() {
        swizzleMethod
    }
    private static let swizzleMethod: Void = {
        let originalSelector = #selector(viewWillAppear(_:))
        let swizzledSelector = #selector(swizzled_viewWillAppear(_:))
        
        swizzlingForClass(UIViewController.self, originalSelector: originalSelector, swizzledSelector: swizzledSelector)
    }()
    
    @objc func swizzled_viewWillAppear(_ animated: Bool) {
        swizzled_viewWillAppear(animated)
        print("swizzled_viewWillAppear")
    }
}
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="28">28.获取View的指定子视图</h2>

通过递归获取指定`view`的所有子视图.

#### 1. 获取`View`的子视图

使用

```swift
    let subViewArr = view.getAllSubViews() // 获取所有子视图
    let imageViewArr = view.getSubView(name: "UIImageView") // 获取指定类名的子视图
```

实现

```swift
extension UIView {
    private static var getAllsubviews: [UIView] = []
    public func getSubView(name: String) -> [UIView] {
        let viewArr = viewArray(root: self)
        UIView.getAllsubviews = []
        return viewArr.filter {$0.className == name}
    }
    public func getAllSubViews() -> [UIView] {
        UIView.getAllsubviews = []
        return viewArray(root: self)
    }
    private func viewArray(root: UIView) -> [UIView] {
        for view in root.subviews {
            if view.isKind(of: UIView.self) {
                UIView.getAllsubviews.append(view)
            }
            _ = viewArray(root: view)
        }
        return UIView.getAllsubviews
    }
}

extension NSObject {
    var className: String {
        let name = type(of: self).description()
        if name.contains(".") {
            return name.components(separatedBy: ".")[1]
        } else {
            return name
        }
    }
}

```

#### 2. 获取UIAlertController的titleLabel和messageLabel
`UIAlertController`好用,但可自定义程度不高,例如我们想让`message`文字左对齐,就需要获取到`messageLabel`,但`UIAlertController`并没有提供这个属性.

我们就可以通过递归拿到`alertTitleLabel`和`alertMessageLabel`.

```swift
extension UIAlertController {
    public var alertTitleLabel: UILabel? {
        return self.view.getSubView(name: "UILabel").first as? UILabel
    }
    public var alertMessageLabel: UILabel? {
        return self.view.getSubView(name: "UILabel").last as? UILabel
    }
}
```
虽然通过这种方法可以拿到`alertTitleLabel`和`alertMessageLabel`.但没法区分哪个是哪个,`alertTitleLabel`为默认子控件的第一个`label`,如果`title`传空,`message`传值,`alertTitleLabel`和`alertMessageLabel`获取到的都是`message`的`label`.

如果有更好的方法欢迎讨论.

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="29">29.线程安全: 互斥锁和自旋锁(10种)</h2>

无并发,不编程.提到多线程就很难绕开锁🔐.

iOS开发中较常见的两类锁:  
###### 1. 互斥锁: 同一时刻只能有一个线程获得互斥锁,其余线程处于挂起状态.
###### 2. 自旋锁: 当某个线程获得自旋锁后,别的线程会一直做循环,尝试加锁,当超过了限定的次数仍然没有成功获得锁时,线程也会被挂起.

自旋锁较适用于锁的持有者保存时间较短的情况下,实际使用中互斥锁会用的多一些.

#### 1. 互斥锁,信号量

##### 1.遵守`NSLocking`协议的四种锁

四种锁分别是:  
`NSLock`、`NSConditionLock`、`NSRecursiveLock`、`NSCondition`

`NSLocking`协议

```swift
public protocol NSLocking {    
    public func lock()
    public func unlock()
}
```

下面举个多个售票点同时卖票的例子

```swift
var ticket = 20
var lock = NSLock()
    
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    let thread1 = Thread(target: self, selector: #selector(saleTickets), object: nil)
    thread1.name = "售票点A"
    thread1.start()
    
    let thread2 = Thread(target: self, selector: #selector(saleTickets), object: nil)
    thread2.name = "售票点B"
    thread2.start()
}
	
@objc private func saleTickets() {
	while true {
	    lock.lock()
	    Thread.sleep(forTimeInterval: 0.5) // 模拟延迟
	    if ticket > 0 {
	        ticket = ticket - 1
	        print("\(String(describing: Thread.current.name!)) 卖出了一张票,当前还剩\(ticket)张票")
	        lock.unlock()
	    }else {
	        print("oh 票已经卖完了")
	        lock.unlock()
	        break;
	    }
	}
}
```
遵守协议后实现的两个方法`lock()`和`unlock()`,意如其名.

除此之外`NSLock`、`NSConditionLock`、`NSRecursiveLock`、`NSCondition`四种互斥锁各有其实现: 
###### 1. 除`NSCondition`外,三种锁都有的两个方法:

```swift
    // 尝试去锁,如果成功,返回true,否则返回false
    open func `try`() -> Bool
    // 在limit时间之前获得锁,没有返回NO
    open func lock(before limit: Date) -> Bool
```
###### 2. `NSCondition`条件锁:

```swift
    // 当前线程挂起
    open func wait()
    // 当前线程挂起,设置一个唤醒时间
    open func wait(until limit: Date) -> Bool
    // 唤醒在等待的线程
    open func signal()
    // 唤醒所有NSCondition挂起的线程
    open func broadcast()
```

当调用`wait()`之后,`NSCondition`实例会解锁已有锁的当前线程,然后再使线程休眠,当被`signal()`通知后,线程被唤醒,然后再给当前线程加锁,所以看起来好像`wait()`一直持有该锁,但根据苹果文档中说明,直接把`wait()`当线程锁并不能保证线程安全.

###### 3. `NSConditionLock `条件锁:

`NSConditionLock`是借助`NSCondition`来实现的,在`NSCondition`的基础上加了限定条件,可自定义程度相对`NSCondition`会高些.

```swift
    // 锁的时候还需要满足condition
    open func lock(whenCondition condition: Int)
    // 同try,同样需要满足condition
    open func tryLock(whenCondition condition: Int) -> Bool
    // 同unlock,需要满足condition
    open func unlock(withCondition condition: Int)
    // 同lock,需要满足condition和在limit时间之前
    open func lock(whenCondition condition: Int, before limit: Date) -> Bool
```

###### 4. `NSRecurisiveLock`递归锁:
定义了可以多次给相同线程上锁并不会造成死锁的锁.

提供的几个方法和`NSLock`类似.

##### 2. GCD的`DispatchSemaphore`和栅栏函数

###### 1. `DispatchSemaphore`信号量:

`DispatchSemaphore`中的信号量,可以解决资源抢占的问题,支持信号的通知和等待.每当发送一个信号通知,则信号量+1;每当发送一个等待信号时信号量-1,如果信号量为0则信号会处于等待状态.直到信号量大于0开始执行.所以我们一般将`DispatchSemaphore`的value设置为1.

下面给出了`DispatchSemaphore`的封装类

```swift
class GCDSemaphore {
    // MARK: 变量
    fileprivate var dispatchSemaphore: DispatchSemaphore!
    // MARK: 初始化
    public init() {
        dispatchSemaphore = DispatchSemaphore(value: 0)
    }
    public init(withValue: Int) {
        dispatchSemaphore = DispatchSemaphore(value: withValue)
    }
    // 执行
    public func signal() -> Bool {
        return dispatchSemaphore.signal() != 0
    }
    public func wait() {
        _ = dispatchSemaphore.wait(timeout: DispatchTime.distantFuture)
    }
    public func wait(timeoutNanoseconds: DispatchTimeInterval) -> Bool {
        if dispatchSemaphore.wait(timeout: DispatchTime.now() + timeoutNanoseconds) == DispatchTimeoutResult.success {
            return true
        } else {
            return false
        }
    }
}
```
###### 2. `barrier`栅栏函数:
栅栏函数也可以做线程同步,当然了这个肯定是要并行队列中才能起作用.只有当当前的并行队列执行完毕,才会执行栅栏队列.

```swift
/// 创建并发队列
let queue = DispatchQueue(label: "queuename", attributes: .concurrent)
/// 异步函数
queue.async {
    for _ in 1...5 {
        print(Thread.current)
    }
}
queue.async {
    for _ in 1...5 {
        print(Thread.current)
    }
}
/// 栅栏函数
queue.async(flags: .barrier) {
    print("barrier")
}
queue.async {
    for _ in 1...5 {
        print(Thread.current)
    }
}
```

##### 3. 其他的互斥锁
###### 1. `pthread_mutex`互斥锁
`pthread`表示`POSIX thread`,跨平台的线程相关的API,`pthread_mutex`也是一种互斥锁,互斥锁的实现原理与信号量非常相似,阻塞线程并睡眠,需要进行上下文切换.

一般情况下,一个线程只能申请一次锁,也只能在获得锁的情况下才能释放锁,多次申请锁或释放未获得的锁都会导致崩溃.假设在已经获得锁的情况下再次申请锁,线程会因为等待锁的释放而进入睡眠状态,因此就不可能再释放锁，从而导致死锁.

这边给出了一个基于`pthread_mutex_t`(安全的"FIFO"互斥锁)的封装 [MutexLock](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/DCTool/MutexLock.swift)

###### 1. @synchronized条件锁
日常开发中最常用的应该是@synchronized,这个关键字可以用来修饰一个变量,并为其自动加上和解除互斥锁.这样,可以保证变量在作用范围内不会被其他线程改变.但是在swift中它已经不存在了.其实@synchronized在幕后做的事情是调用了`objc_sync`中的`objc_sync_enter`和`objc_sync_exit` 方法，并且加入了一些异常判断.

因此我们可以利用闭包自己封装一套.

```swift
func synchronized(lock: AnyObject, closure: () -> ()) {
    objc_sync_enter(lock)
    closure()
    objc_sync_exit(lock)
}

// 使用
synchronized(lock: AnyObject) {
    // 此处AnyObject不会被其他线程改变
}

```

#### 2. 自旋锁

###### 1. `OSSpinLock`自旋锁
`OSSpinLock`是执行效率最高的锁,不过在iOS10.0以后已经被废弃了.

详见大神ibireme的[不再安全的 OSSpinLock](https://blog.ibireme.com/2016/01/16/spinlock_is_unsafe_in_ios/)

###### 2. `os_unfair_lock`自旋锁

它能够保证不同优先级的线程申请锁的时候不会发生优先级反转问题.这是苹果为了取代`OSSPinLock`新出的一个能够避免优先级带来的死锁问题的一个锁,`OSSPinLock`就是有由于优先级造成死锁的问题.

注意: 这个锁适用于小场景下的一个高效锁,否则会大量消耗cpu资源.

```swift
var unsafeMutex = os_unfair_lock()
os_unfair_lock_lock(&unsafeMutex)
os_unfair_lock_trylock(&unsafeMutex)
os_unfair_lock_unlock(&unsafeMutex)
```

这边给出了基于`os_unfair_lock`的封装 [MutexLock](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/DCTool/MutexLock.swift)

#### 3. 性能比较

这边贴一张大神ibireme在iPhone6、iOS9对各种锁的性能测试图

![](http://pcb5zz9k5.bkt.clouddn.com/lock_benchmark.png)

参考:  
[不再安全的OSSpinLock](https://blog.ibireme.com/2016/01/16/spinlock_is_unsafe_in_ios/)  
[深入理解iOS开发中的锁](https://bestswifter.com/ios-lock/)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="30">30.可选类型扩展</h2>

`Optional`(可选类型)为swift的类型安全起到了巨大的作用。

几种将可选值解包的操作。

```swift
var optionalStr: String? = "可选类型"

// 强制解包
print(optionalStr!)
    
// (Optional binding)可选绑定解包
if let optionalStr = optionalStr {
    print(optionalStr)
}
// guard解包
guard let optionalStr2 = optionalStr else {
    return
}
print(optionalStr2)

// ?? 如果??前面的值为空,就输出后面的值
print(optionalStr ?? "optionalStr为空")
```

这是常见的几种解包方式  
1. 强制解包不太推荐使用，除非真的很确定当前可选类型不为空  
2. 可选绑定解包，虽然可以保证安全，但使用多了很容易造成层层嵌套，阅读性不好  
3. `guard`解包虽然能避免层层嵌套，但如果`return`下面还有需要执行的业务逻辑咋办  
4. `??`用起来很方便，但后面只能是值，或者表达式，可能满足不了要求

其实我们可以用`extension`为`Optional`添加自定义的API。

##### 1. `isNone`和`isSome`

```swift
extension Optional {
    /// 判断是否为空
    var isNone: Bool {
        switch self {
        case .none:
            return true
        case .some:
            return false
        }
    }
    /// 判断是否有值
    var isSome: Bool {
        return !isNone
    }    
}
```
`optionalStr.isNone`这样使用比`if optionalStr == nil`简洁一些。

##### 2. or

```swift
extension Optional {
    /// 返回解包后的值或者默认值
    func or(_ default: Wrapped) -> Wrapped {
        return self ?? `default`
    }
    /// 返回解包后的值或`else`表达式的值
    func or(else: @autoclosure () -> Wrapped) -> Wrapped {
        return self ?? `else`()
    }
    /// 返回解包后的值或执行闭包返回值
    func or(else: () -> Wrapped) -> Wrapped {
        return self ?? `else`()
    }
}
```
`@autoclosure`关键词可以让表达式自动封装成一个闭包。从而可以去掉`{}`.`or`为`??`做了一层封装，当可选值为空时，执行??后面的表达式，或者闭包。

```swift
    // 为??做了一层封装
    print(optionalStr.or("为空"))

// 之前的写法
    if viewController == nil {
        viewController = UIViewController()
    }
    // 使用or的写法
    var viewController: UIViewController?
    viewController = viewController.or(else: UIViewController())

// or的else参数传入闭包
    var firstView: UIView? = nil
    firstView = firstView.or { () -> UIView in
        let view = UIView()
        // ...其他属性设置
        return view
    }  
```
##### 3. on

```swift
extension Optional {
    /// 当可选值不为空时，执行 `some` 闭包
    func on(some: () throws -> Void) rethrows {
        if self != nil { try some() }
    }
    /// 当可选值为空时，执行 `none` 闭包
    func on(none: () throws -> Void) rethrows {
        if self == nil { try none() }
    }
}
```
可选值为空和不为空执行的两个闭包。

```swift
    let firstView: UIView? = nil
    firstView.on(some: {
        print("不为nil执行的闭包")
    })
    firstView.on(none: {
        print("为nil执行的闭包")
    })
```

##### 4.其他的一些高级用法

```swift
extension Optional {
    /// 返回解包后的`map`过的值，如果为空，则返回默认值
    func map<T>(_ closure: (Wrapped) throws -> T, default: T) rethrows -> T {
        return try map(closure) ?? `default`
    }
    /// 返回解包后的`map`过的值，如果为空，则调用else闭包
    func map<T>(_ closure: (Wrapped) throws -> T, else: () throws -> T) rethrows -> T {
        return try map(closure) ?? `else`()
    }
    /// 可选值不为空时执行then闭包,返回执行结果
    /// 可链式调用
    func and<T>(then: (Wrapped) throws -> T?) rethrows -> T? {
        guard let unwrapped = self else { return nil }
        return try then(unwrapped)
    }
    /// 可选值不为空且可选值满足 `predicate` 条件才返回，否则返回 `nil`
    func filter(_ predicate: (Wrapped) -> Bool) -> Wrapped? {
        guard let unwrapped = self,
            predicate(unwrapped) else { return nil }
        return self
    }
}
```

```swift
    let optionalInt: Int? = nil
    // 使用前
    print(optionalArr.map({$0 * $0 }) ?? 3)
    // 使用后,这样可阅读性会更好一些
    print(optionalArr.map({ $0 * $0 }, default: 3))
    // else后添加闭包
    print(optionalArr.map({ $0 * $0 }, else: { return 3 }))

// 使用链式调用去空格并转大写
    let optionalString: String? = "Hello World"
    print(optionalString.and(then: {$0.filter{$0 != " "}}).and(then:{$0.uppercased()}).or("为空")) // 打印 HELLOWORLD

```

具体代码 [猛击](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/Extension/Optional%2BExtension.swift)

参考:  
[Useful Optional Extensions](https://appventure.me/2018/01/10/optional-extensions/)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="31">31.更明了的异常处理封装</h2>

```swift
// 错误类型
enum ExceptionError: Error {
    case httpCode(Int)
}

// 可能会抛出异常的方法
func throwError(code: Int) throws -> Int {
    if code == 200 {
        return code
    } else {
        throw ExceptionError.httpCode(code)
    }
}
```

#### 1. 正常的处理方式

```swift
do {
    let result =  try throwError(code: 300) // 返回值
} catch {
    print(error)
}

```

当`do`代码块捕捉到异常时放在`catch`中处理。

#### 2. 明了的处理方式

```swift
let error = should {
    let result = try throwError(code: 300) // 返回值
}

func should(_ try: () throws -> Void) -> Error? {
    do {
        try `try`()
        return nil
    } catch let error {
        return error
    }
}
```
在很多情况下，这样的处理方式更方便一些。

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="32">32.关键字static和class的区别</h2>

在`class`中`static`和`class`关键字都可以来修饰属性和方法，但它们有着本质的不同。

`static`关键字：它能够用在所有类型(`class`、`struct`、`enum`)，表示静态方法或静态属性(计算属性和存储属性)。  
`class`关键字：只能够用在`class`中，表示类方法或类属性(只能是计算属性)。

> 计算属性： 不直接存储值，而是提供一个`getter`和`setter `方法来获取和设置其他属性或变量的值。  
> 存储属性： 就是定义一个常量或者变量来存储值。

```swift
class MyClass {
    class var name: String {
        return "className"
    }
    static var staticName: String {
        return "staticName"
    }
    class func classDescription() {
        print("classDescription")
    }
    static func staticDescription() {
        print("staticDescription")
    }
}

class MyClassChild: MyClass {
    override class var name: String {
        return "className"
    }
    
//    override static var staticName: String {
//        return "staticName"
//    }
    //   Error: Cannot override static var
    
    override class func classDescription() {
        print("classDescription")
    }

//    override static func staticDescription() {
//        print("staticDescription")
//    }
    // Error: Cannot override static method
}

print(MyClass.name) // 打印:className
    print(MyClass.staticName) // 打印:staticName
    MyClass.classDescription() // 打印:classDescription
    MyClass.staticDescription() // 打印:staticDescription
    
    print(MyClassChild.name) // 打印:className
    MyClassChild.classDescription() // 打印:classDescription

```

使用`static`修饰的类方法和类属性无法在子类中重写，相当于`final class`。

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="33">33.在字典中用KeyPaths取值</h2>

#### 1.`[String: Any]`的正常取值办法
作为一门强类型语言，`swift`对于层层嵌套的`Dictionary`类型的取值一点也不友好。

比如我们要获取下面这个字典中`city`对应的值

```swift
var dict: [String: Any] = [
                            "msg": "success",
                            "code": "200",
                            "data": [
                                "userInfo": [
                                    "name": "Dariel",
                                    "city": "HangZhou",
                                ],
                                "other": [
                                    "sign": "9527",
                                ]
                            ]
                          ]
        
let city = ((dict["data"] as? [String: Any])?["userInfo"] as? [String: Any])?["city"] ?? "为空"  // HangZhou
```
这种方式跟OC的`NSDictionary`取值比起来是又臭又长，不推荐。

#### 2.`[String: Any]`取值的简便方式

在取值的过程中，既然每次都要将`[String: Any]`类型中取出来的值,转化为`String: Any]`，那为何不干脆写个分类自动转。

```swift
extension Dictionary {
    subscript(dictForKey key: Key) -> [String: Any]? {
        get { return self[key] as? [String: Any] }
        set { self[key] = newValue as? Value }
    }
    // 最后一次取值返回字符串
    subscript(stringForKey key: Key) -> String? {
        get { return self[key] as? String }
        set { self[key] = newValue as? Value }
    }
    // 最后一次取值返回类型可自己扩展
    // ...
}

let city = dict[dictForKey: "data"]?[dictForKey: "userInfo"]?[stringForKey: "city"] ?? ""  // HangZhou

```
这样看起来就好多了，把类型转换交给`extension`去做。

#### 2.通过`KeyPath`取值

如果自定义程度高一点，是不是还会有更方便的取值方式呢?我们可以参照下`KVC`的。

```swift
class Person: NSObject {
    @objc dynamic var firstName: String = ""
    
    init(firstName: String) {
        self.firstName = firstName
    }
}

let john = Person(firstName: "John")
// #keyPath()编译的时候检查表达式是否有效
john.setValue("Dariel", forKey: #keyPath(Person.firstName))
john.value(forKeyPath: #keyPath(Person.firstName))  // 打印 Dariel

```
通过`keyPath`取值，以这样的方式

```swift
let city = dict[keyPath: "data.userInfo.city"] ?? "" // HangZhou
```

具体实现：

```swift
extension Dictionary where Key: StringProtocol {
    subscript(keyPath keyPath: KeyPath) -> Any? {
        get {
            switch keyPath.headAndTail() {
            case nil:
                return nil
            case let (head, remainingKeyPath)? where remainingKeyPath.isEmpty:
                return self[Key(string: head)]
            case let (head, remainingKeyPath)?:
                let key = Key(string: head)
                switch self[key] {
                case let nestedDict as [Key: Any]:
                    return nestedDict[keyPath: remainingKeyPath]
                default:
                    return nil
                }
            }
        }
        set {
            switch keyPath.headAndTail() {
            case nil:
                return
            case let (head, remainingKeyPath)? where remainingKeyPath.isEmpty:
                let key = Key(string: head)
                self[key] = newValue as? Value
            case let (head, remainingKeyPath)?:
                let key = Key(string: head)
                let value = self[key]
                switch value {
                case var nestedDict as [Key: Any]:
                    nestedDict[keyPath: remainingKeyPath] = newValue
                    self[key] = nestedDict as? Value
                default:
                    return
                }
            }
        }
    }
}
struct KeyPath {
    var segments: [String]
    var isEmpty: Bool { return segments.isEmpty }
    var path: String {
        return segments.joined(separator: ".")
    }
    // 获取当前.前面的头部和后面的部分
    func headAndTail() -> (head: String, tail: KeyPath)? {
        guard !isEmpty else { return nil }
        var tail = segments
        let head = tail.removeFirst()
        return (head, KeyPath(segments: tail))
    }
}
extension KeyPath {
    init(_ string: String) {
        segments = string.components(separatedBy: ".")
    }
}
// 为了可以以这样的方式 let path: KeyPath = "123" 创建对象
extension KeyPath: ExpressibleByStringLiteral {
    init(stringLiteral value: String) {
        self.init(value)
    }
    init(unicodeScalarLiteral value: String) {
        self.init(value)
    }
    init(extendedGraphemeClusterLiteral value: String) {
        self.init(value)
    }
}

// 这个协议的作用: 保证Dictionary中的key是个字符串
protocol StringProtocol {
    init(string s: String)
}
extension String: StringProtocol {
    init(string s: String) {
        self = s
    }
}
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="34">34.给UIView顶部添加圆角</h2>

之前给`UIView`添加圆角，都是通过分类去操作。

```swift
extension UIView {
    /// 设置顶部两个圆角
    ///
    /// - Parameter radius: 圆角半径
    public func topRoundCorners(radius: CGFloat) {
        let path = UIBezierPath(roundedRect: self.bounds, byRoundingCorners: UIRectCorner(rawValue: UIRectCorner.topLeft.rawValue | UIRectCorner.topRight.rawValue) , cornerRadii: CGSize(width: radius, height: radius))
        let mask = CAShapeLayer()
        mask.path = path.cgPath
        self.layer.mask = mask
    }
}
```

ios11出了一个属性`maskedCorners`，共有四种类型：

- layerMinXMinYCorner  左上角
- layerMaxXMinYCorner  右上角
- layerMinXMaxYCorner  左下角
- layerMaxXMaxYCorner  右下角

```swift
if #available(iOS 11, *) {
    darkView.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]
    darkView.layer.cornerRadius = 8
}
```

我们将前面两种方法做下整合：

```swift
public extension CALayer {

func roundCorners(_ corners: CACornerMask, radius: CGFloat) {
        if #available(iOS 11, *) {
            self.cornerRadius = radius
            self.maskedCorners = corners
        } else {
            var cornerMask = UIRectCorner()
            if corners.contains(.layerMinXMinYCorner) {
                cornerMask.insert(.topLeft)
            }
            if corners.contains(.layerMaxXMinYCorner) {
                cornerMask.insert(.topRight)
            }
            if corners.contains(.layerMinXMaxYCorner) {
                cornerMask.insert(.bottomLeft)
            }
            if corners.contains(.layerMaxXMaxYCorner) {
                cornerMask.insert(.bottomRight)
            }
            let path = UIBezierPath(roundedRect: bounds, byRoundingCorners: cornerMask, cornerRadii: CGSize(width: radius, height: radius))
            let mask = CAShapeLayer()
            mask.path = path.cgPath
            self.mask = mask
        }
    }
}
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="35">35.使用系统自带气泡弹框</h2>

iOS中提供这几种转场样式

- **Show**： 用在`UINavigationController`堆栈视图时，`presentedViewController`进入时由右向左，退出时由左向右。新压入的视图控制器有返回按钮，单击可以返回。
  - **Show Detail**： 只适用于嵌入在`UISplitViewController`对象内的视图控制器，分割控制器用以替换详细控制器，不提供返回按钮。
  - **Present Modally**： 有多种不同呈现方式，可根据需要设置。在`iPhone`中，一般以动画的形式自下向上覆盖整个屏幕。
  - **Present As Popover**： 在`iPad`中，目标视图以浮动窗样式呈现，点击目标视图以外区域，目标视图消失；在`iPhone`中，默认目标视图以模态覆盖整个屏幕。
  - **Custom**: 可自定义转场样式。

我们平时用的比较多的是`Show`和`Present Modally`，`Present As Popover`这种气泡弹出样式是用在`iPad`上的，但有时`iPhone`上会用到，我们可以做下特殊处理，不让它覆盖整个屏幕。

实现

#### 1. 在`StroyBoard`中的布局

1. 设置`PopoverView`控制器的尺寸。
2. 添加`segue`并进行绑定。

具体步骤参考:[How to popover not full screen](https://stackoverflow.com/questions/47905805/storyboard-how-to-popover-not-full-screen)

#### 2. `UIPopoverPresentationControllerDelegate`设置

```swift
extension ViewController: UIPopoverPresentationControllerDelegate {
    
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        if segue.identifier == "popoverSegue" {
            let popoverViewController = segue.destination
            popoverViewController.popoverPresentationController!.delegate = self
        }
    }
    
    // 特殊处理 返回none 不让PopoverView覆盖整个屏幕
    func adaptivePresentationStyle(for controller: UIPresentationController) -> UIModalPresentationStyle {
        return .none
    }
    
    func popoverPresentationControllerDidDismissPopover(_ popoverPresentationController: UIPopoverPresentationController) {
        setAlphaOfBackgroundViews(alpha: 1)
    }
    
    func prepareForPopoverPresentation(_ popoverPresentationController: UIPopoverPresentationController) {
        setAlphaOfBackgroundViews(alpha: 0.8)
    }
    
    // 设置灰色背景
    func setAlphaOfBackgroundViews(alpha: CGFloat) {
        let statusBarWindow = UIApplication.shared.value(forKey: "statusBarWindow") as? UIWindow
        UIView.animate(withDuration: 0.2) {
            statusBarWindow?.alpha = alpha
            self.view.alpha = alpha
            self.navigationController?.navigationBar.alpha = alpha
        }
    }
}
```

因为`PopoverView`是一个控制器，相比第三方气泡弹框,可自定义程度会高一点。

[示例Demo](https://github.com/DarielChen/SwiftTips/tree/master/Demo/35.%E4%BD%BF%E7%94%A8%E7%B3%BB%E7%BB%9F%E8%87%AA%E5%B8%A6%E6%B0%94%E6%B3%A1%E5%BC%B9%E6%A1%86)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="36">36.给UILabel添加内边距</h2>

之前给`Label`设置左右内边距都是文字加空格，但觉得这样的方式不优雅。要是碰到需要设置上下内边距该咋办？

`CSS`中用`padding`设置内边距，给了我们一个解决办法的思路。

实现过程

```swift
@IBDesignable
class EdgeInsetLabel: UILabel {
    var textInsets = UIEdgeInsets.zero {
        didSet { invalidateIntrinsicContentSize() }
    }
    override func textRect(forBounds bounds: CGRect, limitedToNumberOfLines numberOfLines: Int) -> CGRect {
        let insetRect = bounds.inset(by: textInsets)
        let textRect = super.textRect(forBounds: insetRect, limitedToNumberOfLines: numberOfLines)
        let invertedInsets = UIEdgeInsets(top: -textInsets.top,
                                          left: -textInsets.left,
                                          bottom: -textInsets.bottom,
                                          right: -textInsets.right)
        return textRect.inset(by: invertedInsets)
    }
    override func drawText(in rect: CGRect) {
        super.drawText(in: rect.inset(by: textInsets))
    }
}

extension EdgeInsetLabel {
    @IBInspectable
    var leftTextInset: CGFloat {
        set { textInsets.left = newValue }
        get { return textInsets.left }
    }
    @IBInspectable
    var rightTextInset: CGFloat {
        set { textInsets.right = newValue }
        get { return textInsets.right }
    }
    @IBInspectable
    var topTextInset: CGFloat {
        set { textInsets.top = newValue }
        get { return textInsets.top }
    }
    @IBInspectable
    var bottomTextInset: CGFloat {
        set { textInsets.bottom = newValue }
        get { return textInsets.bottom }
    }
}
```

设置上下左右的内边距分别为: 10 20 30 40

`@IBDesignable`和`@IBInspectable`可以在使用`StoryBoard`和`Xib`时有更好的体验。

`@IBDesignable`修饰的类可以变得所见即所得，我们可以把`cornerRadius`、`borderWidth`、`borderColor`、`shadowRadius`、`shadowOpacity`、`shadowOffset`、`shadowColor`都交给它去做。

在`StoryBoard`和`Xib`可以达到如下图效果。

具体实现 [猛击](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/Extension/UIView%2BExtension.swift)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="37">37.给UIViewController添加静态Cell</h2>

正常情况下，我们可以给`UIViewController`添加`UITableView`，但如果添加完之后想把`Content`设置为`Static Cells`时会报错。

> error: Illegal Configuration: Static table views are only valid when embedded in UITableViewController instances

只有在`UITableViewController`才能设置静态Cell。

我们可以采取一个折中的办法，在`UIViewController`中添加一个`UITableViewController`子控制器。

在`StoryBoard`中的操作步骤：

1.添加`Container View`到`UIViewController`，设置好相关尺寸。

2.删除右边的`UIViewController`，再添加一个`UITableViewController`，拖线的时候注意是`Embed`

然后用代理在`UIViewController`中操作`UITableViewController `。

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="38">38.简化使用UserDefaults</h2>

用来做简单数据存储的`Preference`在我们的日常开发中使用的还是比较多的，但使用起来总感觉不那么方便。比如说需要去手动管理`key`，之前是这样做的。

```swift
public enum UserDefaultsKey: String {
    case keyOne
    case keyTwo
}

extension UserDefaults {
    /// 存储
    public final class func set(_ value: Any, forKey: UserDefaultsKey) {
        UserDefaults.standard.set(value, forKey: forKey.rawValue)
    }
    /// 读取
    public final class func getString(forKey: UserDefaultsKey) -> String? {
        return UserDefaults.standard.string(forKey: forKey.rawValue)
    }
    public final class func getBool(forKey: UserDefaultsKey) -> Bool? {
        return UserDefaults.standard.bool(forKey: forKey.rawValue)
    }
}

// 存储数据
UserDefaults.set(true, forKey: .keyOne)
// 读取数据        
UserDefaults.getBool(forKey: .keyOne)
```

我们可以通过使用`#function`避免手动管理`key`，在存储和读取数据时调动的`set`和`get`方法也可以交给目标属性默认的`set`和`get`方法去做,。

```swift
extension UserDefaults {
    /// 通过下标使用枚举
    subscript<T: RawRepresentable>(key: String) -> T? {
        get {
            if let rawValue = value(forKey: key) as? T.RawValue {
                return T(rawValue: rawValue)
            }
            return nil
        }
        set { set(newValue?.rawValue, forKey: key) }
    }
    
    subscript<T>(key: String) -> T? {
        get { return value(forKey: key) as? T }
        set { set(newValue, forKey: key) }
    }
}

struct Preference {
    /// bool
    static var isFirstLogin: Bool {
        get { return UserDefaults.standard[#function] ?? false }
        set { UserDefaults.standard[#function] = newValue }
    }
    /// enum
    static var appTheme: Theme {
        get { return UserDefaults.standard[#function] ?? .light }
        set { UserDefaults.standard[#function] = newValue }
    }
    /// 测试服跟正式服之间的切换（默认正式服）
    static var serverUrl: ServerUrlType {
        get { return UserDefaults.standard[#function] ?? .distributeServer }
        set { UserDefaults.standard[#function] = newValue }
    }
}

enum Theme: Int {
    case light
    case dark
    case blue
}

enum ServerUrlType: String {
    case developServer = "url: developServer" // 测试服
    case distributeServer = "url: distributeServer" // 正式服
}

// 存储数据
Preference.isFirstLogin = true
Preference.appTheme = .dark
Preference.serverUrl = .developServer

// 读取数据
Preference.isFirstLogin // true
Preference.appTheme == .dark // true 
Preference.serverUrl.rawValue // url: developServer

```

在测试环节经常需要在测试服和正式服来回切换，为了避免老是打包，我们可以利用`UserDefaults`去更改服务器地址，在适当的位置（可以是个测试页面）加个`UISwitch`，然后设置`serverUrl`的值。

> `UserDefaults`有性能问题吗？  
> `UserDefaults`是带缓存的。它会把访问到的`key`缓存到内存中，下次再访问时，如果内存中命中就直接访问，如果未命中再从文件中载入。它还会时不时调用同步方法来保证内存与文件中的数据的一致性，有时在写入一个值后也最好调用下这个方法来保证数据真正写入文件。

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="39">39.给TabBar上的按钮添加动画</h2>

`UITabBarItem`中无法直接获取到按钮的`UIImageView`和`UILabel`，我们可以参照`tips28`,根据类名获取指定子视图。

`TabBar`上的按钮动画加在`didSelect`方法中。

```swift
extension TabBarController {
  
    override func tabBar(_ tabBar: UITabBar, didSelect item: UITabBarItem) {      
        guard let idx = tabBar.items?.index(of: item),
            // tips28获取相关子视图
            let imageView = tabBar.getSubView(name: "UITabBarSwappableImageView")[idx] as? UIImageView,
            let label = tabBar.getSubView(name: "UITabBarButtonLabel")[idx] as? UILabel else {
                return
        }
        
        let bounceAnimation = CAKeyframeAnimation(keyPath: "transform.scale")
        bounceAnimation.values = [1.0, 1.4, 0.9, 1.02, 1.0]
        bounceAnimation.duration = TimeInterval(0.3)
        bounceAnimation.calculationMode = CAAnimationCalculationMode.cubic
        
        imageView.layer.add(bounceAnimation, forKey: nil)
        label.layer.add(bounceAnimation, forKey: nil)
    }
}

```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="40">40.给UICollectionView的Cell添加左滑删除</h2>

我们都知道`UITableView`有现成的`API`可以用来添加左滑删除功能，但如果想在`UICollectionView`中添加左滑删除功能就只能自定义了。

其实自定义的思路也是蛮简单的，在`Cell`上添加一个可以左右滚动的`UIScrollView`，把删除按钮放到右边，再用代理传递删除事件。

这边使用iOS9时出的`NSLayoutAnchor`写布局，相比`NSLayoutConstraint`，代码简化了很多，可读性也好了很多。

下面给出了`UICollectionViewCell`的基类`EditingCollectionViewCell`的实现过程。

```swift
protocol EditableCollectionViewCellDelegate: class {
    func hiddenContainerViewTapped(inCell cell: UICollectionViewCell)
}

class EditingCollectionViewCell: UICollectionViewCell {
    
    // MARK: Properties
    private let scrollView: UIScrollView = {
        let scrollView = UIScrollView(frame: .zero)
        scrollView.isPagingEnabled = true
        scrollView.showsVerticalScrollIndicator = false
        scrollView.showsHorizontalScrollIndicator = false
        return scrollView
    }()
    
    let visibleContainerView = UIView()
    let hiddenContainerView = UIView()
    
    weak var delegate: EditableCollectionViewCellDelegate?
    
    // MARK: Initializers
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupSubviews()
        setupGestureRecognizer()
    }
    
    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    private func setupSubviews() {
        let stackView = UIStackView()
        stackView.axis = .horizontal
        stackView.distribution = .fillEqually
        stackView.addArrangedSubview(visibleContainerView)
        stackView.addArrangedSubview(hiddenContainerView)
        
        addSubview(scrollView)
        scrollView.pinEdgesToSuperView()
        scrollView.addSubview(stackView)
        stackView.pinEdgesToSuperView()
        stackView.heightAnchor.constraint(equalTo: scrollView.heightAnchor).isActive = true
        stackView.widthAnchor.constraint(equalTo: scrollView.widthAnchor, multiplier: 2).isActive = true
    }
    private func setupGestureRecognizer() {
        let tapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(hiddenContainerViewTapped))
        hiddenContainerView.addGestureRecognizer(tapGestureRecognizer)
    }
    @objc private func hiddenContainerViewTapped() {
        delegate?.hiddenContainerViewTapped(inCell: self)
    }
}
```
`visibleContainerView`:用来存放Cell内容。
`hiddenContainerView`: 用来存放左滑显示出来的视图。

[示例Demo](https://github.com/DarielChen/SwiftTips/tree/master/Demo/40.%e7%bb%99UICollectionView%e7%9a%84Cell%e6%b7%bb%e5%8a%a0%e5%b7%a6%e6%bb%91%e5%88%a0%e9%99%a4)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="41">41.基于NSLayoutAnchor的轻量级AutoLayout扩展</h2>

相比`NSLayoutConstraint`，`tips40`中用到的`NSLayoutAnchor`使用起来更方便一些。

例如给一个高`40`的`label`设置左右上边距各为`20`，需要这样写：

```swift
label1.translatesAutoresizingMaskIntoConstraints = false
label1.topAnchor.constraint(equalTo: self.view.topAnchor, constant: 20).isActive = true
label1.leadingAnchor.constraint(equalTo: self.view.leadingAnchor, constant: 20).isActive = true
label1.trailingAnchor.constraint(equalTo: self.view.trailingAnchor, constant: -20).isActive = true
label1.heightAnchor.constraint(equalToConstant: 40).isActive = true
```

但如果使用了基于`NSLayoutAnchor`的`AutoLayout`扩展后可以这样

```swift
label1.layout {
    $0.aTop == self.view.aTop + 20
    $0.aLeading == self.view.aLeading + 20
    $0.aTrailing == self.view.aTrailing - 20
    $0.aHeight == 40
}
```

这种方式和使用`Storyboard`和`Xib`做`AutoLayout`布局的语法很相似，简洁，可读性好。

下面再用`AutoLayout`扩展举一个例子

三个label，宽度相等，高度为100，距顶部左右边距都是20。

```swift
label1.layout {
    $0.aLeading == self.view.aLeading + 20
    $0.aTrailing == label2.aLeading - 20
    $0.aTop == self.view.aTop + 20
    $0.aHeight == 100
    $0.aWidth == label2.aWidth
}

label2.layout {
    $0.aTop == self.view.aTop + 20
    $0.aHeight == 100
    $0.aTrailing == label3.aLeading - 20
    $0.aWidth == label3.aWidth
}

label3.layout {
    $0.aTop == self.view.aTop + 20
    $0.aHeight == 100
    $0.aTrailing == self.view.aTrailing - 20
}
```

具体代码 [猛击](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/DCTool/LayoutProxy.swift)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="42">42.简化复用Cell的代码</h2>

我们在利用`UITableView`和`UICollectionView`的重用机制绘制`Cell`的时候经常需要先注册，然后再去复用池中取，系统给的API虽然可以达到目的，但还是有简化的空间。

* 每次注册`Cell`都需要自定义一个`Identifier`，我们一般都是把这个`Identifier`定义为`Cell`的类名。
* 如果需要注册好几种类型的`Cell`，注册`Cell`部分需要写多次。

`Identifier`定义为`Cell`的类名，其实就没必要每次手动配置了，我们可以直接将类名转化为`Identifier`。
当需要同时注册多种类型`Cell`的时候，我们可以用`forEach`遍历操作。

之前的代码：

```swift
// 用Xib加载tableView的cell
tableView.register(UINib(nibName: "NibTableViewCell", bundle: nil), forCellReuseIdentifier: "NibTableViewCell")

// 纯代码加载tableView的cell
tableView.register(MyTableViewCell.self, forCellReuseIdentifier: "MyTableViewCell")

// 从复用池中取cell
let cell = tableView.dequeueReusableCell(withIdentifier: "NibTableViewCell") as! NibTableViewCell

// 同时注册多个不同的cell
tableView.register(UINib(nibName: "NibTableViewCell", bundle: nil), forCellReuseIdentifier: "NibTableViewCell")
tableView.register(MyTableViewCell.self, forCellReuseIdentifier: "MyTableViewCell")

```

简化之后的代码：

```swift
// 用Xib加载tableView的cell
tableView.register(cell: .nib(NibTableViewCell.self))

// 纯代码加载tableView的cell
tableView.register(cell: .class(MyTableViewCell.self))

// 从复用池中取cell
let cell: NibTableViewCell = tableView.dequeueCell(at: indexPath)

// 同时注册多个不同的cell
tableView.register(cells: [
    .class(MyTableViewCell.self)
    .nib(NibTableViewCell.self)
])
```

除了例子中的这些，还有一些`UICollectionView`的扩展，参考具体实现 [猛击](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/DCTool/Registerable.swift)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="43">43.正则表达式的封装</h2>

正则表达式具有通用性，但`NSRegularExpression`使用起来并不方便，我们可以试着对它进行封装，增加一些常用的正则处理方法。

具体使用如下：

```swift
let pattern = "^([a-z0-9_\\.-]+)@([\\da-z\\.-]+)\\.([a-z\\.]{2,6})$"
do {
    // 验证邮箱地址
    let mailAddress = "darielchen@126.com"
    let regex = try Regex(pattern)
    if regex.matches(mailAddress) {
        print("邮箱地址格式正确")
    } else {
        print("邮箱地址格式有误")
    }
 } catch {
    print(error)
}

let phonePattern = "^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\\d{8}$"
do {
    // 验证手机号码
    let phone = "17682323553"
    let regex = try Regex(phonePattern)
    if regex.matches(phone) {
        print("手机号格式正确")
    } else {
        print("手机号格式错误")
    }
} catch {
    print(error)
}

```

具体实现 [猛击](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/DCTool/Regex.swift)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="44">44.自定义带动画效果的模态框</h2>

#### 1. 自定义弹框

如上图，常见的实现方式是把模态框作为一个`View`，需要的时候通过动画从底部弹出来。这样做起来很方便，但可扩展性往往不够，弹框的内容可能会是任何控件或者组合。如果弹框是个控制器，扩展性就不会是个问题了。

如何根据文本内容的高度设置控制器的`frame`?  
在弹框控制器的构造方法中设置好`label`的约束，然后在`UIPresentationController`中重写`frameOfPresentedViewInContainerView`属性，在其中通过`UIView.systemLayoutSizeFitting`计算出内容的高度。

这边弹框的半径在`presentationTransitionWillBegin`中设置。

具体实现 [猛击](https://github.com/DarielChen/iOSTips/blob/master/Demo/44.%E8%87%AA%E5%AE%9A%E4%B9%89%E5%B8%A6%E5%8A%A8%E7%94%BB%E6%95%88%E6%9E%9C%E7%9A%84%E6%A8%A1%E6%80%81%E6%A1%86/CustomPresentation/ToastViewController.swift)

#### 2. 自定义`UIAlertController`

按照这个思路，我们可以自定义任何形式的弹框，包括系统的`UIAlertController`的`alert`和`actionSheet`，下图就是自定义了系统的`actionSheet`。

与上面自定义弹框不同的，自定义`UIAlertController`需要把背景颜色设置为透明灰色，这个我们也是在`UIPresentationController`中设置。

```swift
override func presentationTransitionWillBegin() {
    super.presentationTransitionWillBegin()
    
    presentedView?.layer.cornerRadius = 24
    containerView?.backgroundColor = .clear
    
    // 弹框出现的时候设置透明灰度
    if let coordinator = presentingViewController.transitionCoordinator {
        coordinator.animate(alongsideTransition: { [weak self] _ in
            self?.containerView?.backgroundColor = UIColor.black.withAlphaComponent(0.3)
            }, completion: nil)
    }
}
    
override func dismissalTransitionWillBegin() {
	super.dismissalTransitionWillBegin()
	
	// 弹框消失的时候把背景颜色置为clear
	if let coordinator = presentingViewController.transitionCoordinator {
        coordinator.animate(alongsideTransition: { [weak self] _ in
            self?.containerView?.backgroundColor = .clear
            }, completion: nil)
    }
}
```

这边在自定义`UIAlertController`的过程中，有个bug。

当点击`UIAlertController`上的确认按钮跳转到一个新的控制器，然后再返回到当前页面的时候，自定义`UIAlertController`会出现一闪的情况,可以把`PresentationController`中所有的代码注释掉就能重复这个bug，造成这种现象的原因是因为，在自定义尺寸的控制器上`present`一个全屏控制器的时候，系统会自动把当前层级下的自定义尺寸的控制器的`View`移除掉，当我们对全屏控制器做`dismiss`操作后又会添加回去。

这个bug的最优解决办法是给`UIPresentationController`设置一个子类，在子类中添加一个属性保存自定义尺寸的控制器的`frame`。

```swift
class PresentationController: UIPresentationController {
    
    private var calculatedFrameOfPresentedViewInContainerView = CGRect.zero
    private var shouldSetFrameWhenAccessingPresentedView = false
    
    // 如果弹框存在，设置弹框的frame
    override var presentedView: UIView? {
        if shouldSetFrameWhenAccessingPresentedView {
            super.presentedView?.frame = calculatedFrameOfPresentedViewInContainerView
        }
        return super.presentedView
    }
    
    // 弹框存在
    override func presentationTransitionDidEnd(_ completed: Bool) {
        super.presentationTransitionDidEnd(completed)
        shouldSetFrameWhenAccessingPresentedView = completed
    }
    
    // 弹框消失
    override func dismissalTransitionWillBegin() {
        super.dismissalTransitionWillBegin()
        shouldSetFrameWhenAccessingPresentedView = false
    }
    
    // 获取弹框的frame
    override func containerViewDidLayoutSubviews() {
        super.containerViewDidLayoutSubviews()
        calculatedFrameOfPresentedViewInContainerView = frameOfPresentedViewInContainerView
    }
}
```
具体实现 [猛击](https://github.com/DarielChen/iOSTips/blob/master/Demo/44.%E8%87%AA%E5%AE%9A%E4%B9%89%E5%B8%A6%E5%8A%A8%E7%94%BB%E6%95%88%E6%9E%9C%E7%9A%84%E6%A8%A1%E6%80%81%E6%A1%86/CustomPresentation/CustomActionsheetController.swift)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="45">45.利用取色盘获取颜色</h2>

#### 1.生成取色盘

取色盘处理除了使用设计给的图片，我们还可以利用`CIFilter`的`CIHueSaturationValueGradient`属性来生成取色盘图片。

上图左1的实现：

```swift
let filter = CIFilter(name: "CIHueSaturationValueGradient", parameters: [
            "inputColorSpace": CGColorSpaceCreateDeviceRGB(),
            "inputDither": 0,
            "inputRadius": 160,
            "inputSoftness": 0,
            "inputValue": 1
            ])!
let image = UIImage(ciImage: filter.outputImage!)

```

- `inputColorSpace`获取当前设备的色域。  
- `inputDither`类似像素点的一个属性，值设置为300，可以得到上图左2。  
- `inputRadius`取色盘上点的半径，上图在`@2x`设备上像素点为320X320，`@3x`设备上像素点为480X480。  
- `inputSoftness`柔和度，值为0表示很平滑，上图左3`inputSoftness`的值为4。
- `inputValue`表示亮度，1为最亮，0表示最暗，上图左4`inputValue`的值为0.5。

#### 2.获取颜色

获取`UIImageView`对应位置的颜色

```swift
extension UIImageView {
    func getPixelColorAt(point: CGPoint) -> UIColor {
        let pixel = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: 4)
        let colorSpace = CGColorSpaceCreateDeviceRGB()
        let bitmapInfo = CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedLast.rawValue)
        let context = CGContext(
            data: pixel,
            width: 1,
            height: 1,
            bitsPerComponent: 8,
            bytesPerRow: 4,
            space: colorSpace,
            bitmapInfo: bitmapInfo.rawValue
        )
        
        context!.translateBy(x: -point.x, y: -point.y)
        layer.render(in: context!)
        let color = UIColor(
            red: CGFloat(pixel[0]) / 255.0,
            green: CGFloat(pixel[1]) / 255.0,
            blue: CGFloat(pixel[2]) / 255.0,
            alpha: CGFloat(pixel[3]) / 255.0
        )       
        pixel.deallocate()
        return color
    }
}
```
[:arrow_up: 返回目录](#table-of-contents)

<h2 id="46">46.第三方库的依赖隔离</h2>

第三方库的使用可以大大减少我们开发的工作量，但也造成了第三库的代码和业务代码的高度耦合性，万一哪天使用的第三方库停止更新了，我们想要替换，成本有点大。我们就需要在业务代码和第三方库中加一个抽象层。

#### Extensions

我们可以用分类对图片下载缓存框架`KingFisher`进行隔离。

```swift
import Kingfisher

extension UIImageView {
    func setImage(from url: URL) {
        kf.setImage(with: url)
    }
}
```
这样做在替换成别的图片下载缓存框架很轻松，业务中也没有必要老是导入`Kingfisher`库了。

#### Protocols

作为一个安全的存储容器`Keychain`可以为不同的应用保存敏感信息，包括用户名密码啥的，苹果用它来保存Wi-Fi密码，VPN等，是一个独立于所有app之外的数据库。

而`keychain-swift`就是在`Keychain`基础上做了一层封装，使得我们能够更便捷的使用`Keychain`。

```swift
let keychain = KeychainSwift()
keychain.set("ACCEDDTOKEN", forKey: "accessToken")
keychain.get("accessToken") // Returns "ACCEDDTOKEN"
```
类似`key`、`value`的使用方式。

在`tips38`中，我们把`set`和`get`操作放到了属性的`set`和`get`，这边我们也可以这样操作。

```swift
protocol TokenStore {
    var accessToken: String? { get set }
    var refreshToken: String? { get set }
}

extension KeychainSwift: TokenStore {
    var accessToken: String? {
        get { return get(#function) }
        set {
            if let value = newValue  {
                set(value, forKey: #function)
            }
        }
    }
    var refreshToken: String? {
        get { return get(#function) }
        set {
            if let value = newValue  {
                set(value, forKey: #function)
            }
        }
    }
}
```
通过协议为`KeychainSwift`定义了属性，可以避免直接操作字符串`key`。

```swift
class AuthenticationService {
    private let tokenStore: TokenStore

init(tokenStore: TokenStore) {
        self.tokenStore = tokenStore
    }

func fetchToken(for credentials: Credentials) {
//        保存token
//        tokenStore.accessToken =
//        tokenStore.refreshToken =
    }
}
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="47">47.给App的某个功能添加快捷方式</h2>

iOS中给App添加快捷方式的几种方案：

1. 3DTouch，长按App唤起3DTouch菜单，这个同时也可以当做小组件添加到首屏左边的快捷方式页面中。 
2. 通过Siri唤醒对应的App。  
3. 直接在桌面添加对应的快捷方式，点击快捷方式直接跳到某个App的某个功能。

方案1，3DTouch的入口说实话一般人还是不太容易发现的。  
方案2，跟Siri语音交互个人觉得有点蠢。  
方案3，我觉得最合适了，我们用支付宝刷地铁或公交就可以通过添加桌面快捷方式，直接跳到支付二维码。

那么问题来了，支付宝是怎么做到的呢？

其实是利用了`Safari`的`PWA`功能，将编码好的网页内容和图标保存到桌面。点击桌面快捷方式打开网页执行JS，跳转到App对应的功能。

> PWA的中文名叫渐进式网页应用。它融合了`Web`和`App`的一些优点，可以在原生App的主屏幕上留下图标。可以像`Native App`那样离线使用。

下面是实现步骤

#### 1. 配置`App`跳转的`URL`
在`Xcode`的`Target`->`Info`->`URL Types`的`URL Schemes`添加`addshortcuts`，作为跳转`url`的协议头。

我们给`app`中需要添加快捷方式的功能页设置好跳转`url`:`addshortcuts://profile`。并在`AppDelegate`中添加如下代码

```swift
func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
        
    let storyboard = UIStoryboard.init(name: "Main", bundle: Bundle.main)
    let featureVc = storyboard.instantiateViewController(withIdentifier: "FeatureViewController")
        
    if let navController = window?.rootViewController as? UINavigationController, let topController = navController.topViewController{
        if topController.isKind(of: FeatureViewController.self) {
            return true
        }
        if url.absoluteString == "addshortcuts://profile" {
            navController.pushViewController(featureVc, animated: false)
        }
    }
        return true
}
```
到这里我们可以在浏览器中输入`addshortcuts://profile`，如果可以跳转到`App`对应的功能页面表示一切正常。

#### 2. 设置添加快捷方式到桌面的引导`H5`页面和跳转到`App`的`H5`页面

##### 1. 引导添加桌面快捷方式的`H5`页面
这个引导页面支付宝做的不错，几经辗转，我拿到了这个页面，稍微修改了下，界面效果如下图

##### 2. 跳转到`App`的`H5`页面

这个页面是个空白页，当我们点击快捷方式的时候，通过这个空白页跳转到`App`。

```html
<a id="redirect" href="addshortcuts://profile"></a>
```
打开空白页，执行下面这段JS，模拟点击上面的a标签

```javascript
var element = document.getElementById('redirect');
var event = document.createEvent('MouseEvents');
event.initEvent('click', true, true, document.defaultView, 1, 0, 0, 0, 0, false, false, false, false, 0, null);
document.body.style.backgroundColor = '#FFFFFF';
setTimeout(function() { element.dispatchEvent(event); }, 25);
```

其实引导页和跳转页可以放到一起，通过`window.navigator.standalone`检测`Safari`打开的Web应用程序是否全屏显示。如果是全屏显示表示是从桌面快捷方式进入的，那么就显示空白页，自动执行上面那段JS。如果不是全屏显示表示是从`app`跳转过去的引导页。

#### 3. 搭建可以打开编码后`H5`页面的本地`server`

##### 1. `h5`编码
`Safari`可以直接打开一串包含页面内容编码的URL，这个`URL`包含了这个页面需要的所有信息。

`data:text/html;base64,PGEgaHJlZj0iaHR0cHM6Ly9naXRodWIuY29tL0RhcmllbENoZW4vaU9TVGlwcyI+aU9TVGlwczwvYT4=`

在`Safari`中输入上面那串`URL`,会显示一个`<a href="https://github.com/DarielChen/iOSTips">iOSTips</a>`的标签。跟正常的标签一样，这是因为上面的`URL`是我们经过`base64`编码后处理的。同样我们可以把`h5`页面转化成这种`URL`编码格式。

##### 2. 搭建本地server

iOS中不能用`UIApplication.shared.open(url)`的方式打开包含`Base64`编码的`URL`，如果我们用`SFSafariViewController`,它也是不能够识别这个格式的`URL`。这个问题好像是出在苹果那边。

那支付宝是怎么做的呢？它是直接把这个页面部署到了服务端，我们可以参考这种方法，用`Swifter`搭建一个本地的`server`。

```swift
guard let deeplink = URL(string: "addshortcuts://profile") else {
    return
}
guard let shortcutUrl = URL(string: "http://localhost:8244/s") else {
    return
}
guard let iconData = UIImage(named: "feature_icon")?.jpegData(compressionQuality: 0.5) else {
    return
}
let html = htmlFor(title: "功能快捷方式", urlToRedirect: deeplink.absoluteString, icon: iconData.base64EncodedString())
guard let base64 = html.data(using: .utf8)?.base64EncodedString() else {
    return
}
server["/s"] = { request in
    return .movedPermanently("data:text/html;base64,\(base64)")
}
try? server.start(8244)
```

#### 4. 总结

整个操作流程如下图所示。

这种方式有个问题，多次添加桌面快捷方式会出现多个相同的图标，有解决方法的同学欢迎留言。

具体实现 [猛击](https://github.com/DarielChen/iOSTips/blob/master/Demo/47.%E7%BB%99App%E7%9A%84%E6%9F%90%E4%B8%AA%E5%8A%9F%E8%83%BD%E6%B7%BB%E5%8A%A0%E5%BF%AB%E6%8D%B7%E6%96%B9%E5%BC%8F)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="48">48.给UITableView添加空白页</h2>

介绍一种简单的给`UITableView`设置空白页的方法。

```swift
extension UITableView {

/// 添加空白页
    ///
    /// - Parameter message: 空白页文字
    func setNoDataPlaceholder(_ message: String) {
        let label = UILabel(frame: CGRect(x: 0, y: 0, width: self.bounds.size.width, height: self.bounds.size.height))
        label.text = message
        label.textAlignment = .center
        label.sizeToFit()
        self.isScrollEnabled = false
        self.backgroundView = label
        self.separatorStyle = .none
    }
    
    /// 删除空白页
    func removeNoDataPlaceholder() {
        self.isScrollEnabled = true
        self.backgroundView = nil
        self.separatorStyle = .singleLine
    }
}
```
上面代码只支持纯文本的空白页提示，如果需要添加空白页图片可以在`setNoDataPlaceholder`方法中自定义。

为了方便在`RxSwift`中使用，我们可以给`Reactive`添加扩展

```swift
extension Reactive where Base: UITableView {
    func isEmpty(message: String) -> Binder<Bool> {
        return Binder(base) { tableView, isEmpty in
            if isEmpty {
                tableView.setNoDataPlaceholder(message)
            } else {
                tableView.removeNoDataPlaceholder()
            }
        }
    }
}
```
使用

```swift
let isEmpty = tableView.rx.isEmpty(message:"暂无数据")
viewModel.responses.map({ $0.count <= 0 }).distinctUntilChanged().bind(to: isEmpty).disposed(by: disposeBag)
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="49">49.线程保活的封装</h2>

当我们开启一个线程并执行完相关的操作后，线程就会立即被销毁。下次再执行同样的操作时，还会创建一个新的线程，这就产生了不必要的开销，尤其是这样的操作很频繁的时候。

如何在执行完相关的操作后，线程依然不被销毁，等到下次直接去使用呢？

我们可以在这个线程中创建一个`RunLoop`，由`RunLoop`去管理线程。

在上代码前先解释下`RunLoop`和线程之间的关系

1. 每个线程都有一个对应的`RunLoop`，主线程的`RunLoop`在`Main`函数中创建。
  2. 主线程的`RunLoop`是自动开启的，子线程默认并没有开启`RunLoop`。
  3. 子线程创建的时候并没有创建好`RunLoop`对象，`RunLoop`对象会在第一次获取它的时候创建。
  4. 线程中的`RunLoop`会和线程一起被销毁。

由`RunLoop`管理线程：

```swift
    innerThread = DCThread(block: { [weak self] in
        // RunLoop.current:如果当前RunLoop不存在，就在线程中创建一个RunLoop
        // 往RunLoop中添加Source,防止空的RunLoop自动退出
        RunLoop.current.add(Port(), forMode: RunLoop.Mode.default)
        while self?.isStopped == false {
            // 单次运行RunLoop，不会超时
            RunLoop.current.run(mode: RunLoop.Mode.default, before: NSDate.distantFuture)
        }
    })
    innerThread?.start()
```

在子线程中执行任务：

```swift
    self.perform(#selector(innerExecuteTask(task:)), on: innerThread, with: task, waitUntilDone: false)

@objc private func innerExecuteTask(task: @escaping @convention(block)() -> Void) {
        // 需要在子线程中执行的操作
    }
```

停止子线程的`RunLoop`，销毁子线程：

```swift
    self.perform(#selector(innerStop), on: innerThread, with: nil, waitUntilDone: true)

@objc private func innerStop() {
        // 终止RunLoop的while循环
        isStopped = true
        // 停止当前线程中的当次RunLoop
        CFRunLoopStop(CFRunLoopGetCurrent());
        self.innerThread = nil
    }

```

封装完之后使用

```swift
    // 创建
    let thread = PermenantThread()

// 使用
    thread.executeTask {
        // 需要在子线程中执行的操作
        print(Thread.current)
    }

// 销毁
    thread.stop()
```

具体实现 [猛击](https://github.com/DarielChen/iOSTips/blob/master/Demo/49.%E7%BA%BF%E7%A8%8B%E4%BF%9D%E6%B4%BB%E7%9A%84%E5%B0%81%E8%A3%85)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="50">50.GCD定时器</h2>

`CADisplayLink`和`NSTimer`的底层都是基于`RunLoop`实现的，而主线程的`RunLoop`承担了大量的工作，比如UI界面的刷新，点击事件的处理，动画的响应等，如果`RunLoop`的任务过于繁重，就可能导致`CADisplayLink`和`NSTimer`执行的时候不准时。

在设置好`CADisplayLink`和`NSTimer`定时器后，`RunLoop`会每跑一圈去确认下时间，`RunLoop`每次循环的任务可能不一样，如果当次循环还没执行到定时器执行的时间间隔，就会执行下一次`RunLoop`循环， 而下一次循环执行到定时器任务时可能已经超过了定时器执行的时间间隔，这就导致了基于`RunLoop`的定时器的不准确。

而基于系统内核的GCD定时器不依赖RunLoop，相对来说会更准确一些。

为了方便使用，下面给出了GCD定时器定时器的封装

```swift
class GCDTimer {
    
    public let dispatchSourceTimer : DispatchSourceTimer
    
    init(in : GCDQueue, delay : Float = 0, interval : Float) {
        dispatchSourceTimer = DispatchSource.makeTimerSource(flags: [], queue: `in`.dispatchQueue)
        dispatchSourceTimer.schedule(deadline: .now() + .milliseconds(Int(delay * 1000)), repeating: .milliseconds(Int(interval * 1000)))
    }
    
    /// 设定定时器任务的回调函数
    ///
    /// - Parameter eventHandler: 回调函数
    func setTimerEventHandler(eventHandler: @escaping (GCDTimer) -> Void) {
        dispatchSourceTimer.setEventHandler {
            eventHandler(self)
        }
    }
    
    /// 设定定时器销毁时候的回调函数
    ///
    /// - Parameter eventHandler: 回调函数
    func setDestroyEventHandler(eventHandler: @escaping () -> Void) {
        dispatchSourceTimer.setCancelHandler {
            eventHandler()
        }
    }
    
    /// 挂起
    func suspend() {
         dispatchSourceTimer.suspend()
    }
    
    /// 开始定时
    func start() {
         dispatchSourceTimer.resume()
    }

/// 定时器销毁(执行了此方法后,start就会变得无效)
    func destroy() {
         dispatchSourceTimer.cancel()
    }
}
```
使用

```swift
// 设置定时器，延迟2秒执行，间隔1秒
let gcdTimer = GCDTimer(in: GCDQueue.global(), delay: 2, interval: 1)
    
var count : Int = 0
// 执行事件
gcdTimer.setTimerEventHandler { _ in
    count += 1
    print("\(count)")
    
    if count == 8 {
        // 定时器销毁
        gcdTimer.destroy()
    }
}
// 定时器开始
gcdTimer.start()
    
gcdTimer.setDestroyEventHandler {
    print("销毁事件的回调")
}
```

具体实现 [猛击](https://github.com/DarielChen/iOSTips/blob/master/Demo/50.GCD%e5%ae%9a%e6%97%b6%e5%99%a8)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="51">51.命名空间及应用</h2>

在OC中因为没有命名空间，开发者在给类库命名的时候一般都会加上两三个字母的前缀来防止命名冲突。这样做虽然可以大大降低引用第三方类库时的冲突，但还是会碰到命名相同的情况。

而在`swift`中由于可以使用命名空间，即使相同的类型名称只要来自不同的模块，就可以共存。每个模块都有一个自己的命名空间。

#### 1. 如何避免与系统API命名冲突

避免命名冲突最好的方式是跟系统的命名不一样，这也是代码规范的一部分，但如果真的冲突了，怎么解决？

```swift
// 获取当前项目的命名空间
let nameSpace = Bundle.main.infoDictionary?["CFBundleExecutable"] as? String // Optional("Namespace")

// 正常使用Int类型
let zeroOrOne = Int.random(in: 0...1)
print(zeroOrOne)

```

自定义了一个`Int`结构体

```swift
struct Int {}

let zeroOrOne = Int.random(in: 0...1) // 报错： Type 'Int' has no member 'random'
```
上面代码中的`Int.random`其实省略了命名空间，完整的写法应该是这样

```swift
// Namespace是当前项目的命名空间
let zeroOrOne = Namespace.Int.random(in: 0...1) // 报错： Type 'Int' has no member 'random'
```
如果我们想用`Foundation`中的`Int`类型应该在前面加`Swift`前缀。使用`UIKit`中的API，前面默认是加的`UIKit`。

```swift
let zeroOrOne = Swift.Int.random(in: 0...1)
print(zeroOrOne) // 0 或 1

let kitView = UIKit.UIView()
```

#### 2. 如何避免模块之间的命名冲突

在模块A和模块B中分别定义了两个相同名字的结构体Int,如果我们要在项目中同时使用这两个结构体只需要加前缀。

```swift

import ModuleA
import ModuleB

print(ModuleA.Int().description) // ModuleA
print(ModuleB.Int().description) // ModuleB
```

#### 3. 伪命名空间
有时为了更清晰的代码结构往往需要多层嵌套，我们可以使用伪命名空间来使代码结构更清晰。

用枚举来做伪命名空间嵌套更合适一些。因为相比类和结构体，枚举没有构造方法，也没有类的继承操作。

##### 1. 利用伪命名空间定义全局常量

```swift
class ItemListViewController { ... }
extension ItemListViewController {

enum Constants {
        static let itemsPerPage = 7
        static let headerHeight: CGFloat = 60
    }
}

// 全局常量
ItemListViewController.Constants.itemsPerPage
ItemListViewController.Constants.headerHeight

```
这样嵌套定义的全局常量一方面是直观清晰，另一方面可以有效避免命名污染。
##### 2. 利用伪命名空间来设置工厂方法

```swift
struct Item {
    ...
}
extension Item {
    enum Factory {
        static func make(from anotherItem: AnotherItem) -> Item {
            // 相关操作
            return Item(...)
        }
    }
}

let anotherItem = AnotherItem()
let item = Item.Factory.make(from: anotherItem)

```

总结 ：命名空间可以有效避免不同模块之间的命名冲突，但同一模块中的命名冲突并不支持，我们可以利用伪命名空间的嵌套来避免。

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="52">52.数据绑定的封装</h2>

函数响应式编程（例如`RxSwift`）有一个很大的优势，可以将模型与视图绑定。当模型中数据发生改变后，视图会直接产生变化，不用再去刷新视图。

下面给出了一个简单的数据绑定封装，不再依赖`RxSwift`。

使用：

```swift
// 模型
struct User {
    var name: String
    var followersCount: Int
}

class TestViewController: UIViewController {
    
    private lazy var countLabel = UILabel()
    var user: Bindable<User>? = nil
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // 创建模型
        user = Bindable(User(name: "Dariel", followersCount: 5))
        
        countLabel.text = "0"
        view.addSubview(countLabel)
        
        // 添加观察者，只要模型数据发生改变就会进回调
        user?.addObservation(for: self) { [weak self] (vc, user) in
            
            self?.countLabel.text = String(user.followersCount)
            self?.countLabel.sizeToFit()
            self?.countLabel.center = (self?.view.center)!
        }
        // 模型与视图绑定，本质上是添加观察者方法的又一层封装
        user?.bind(\.name, to: navigationItem, \.title)
        
        view.backgroundColor = UIColor.groupTableViewBackground
    }
    
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        
        // 改变模型
        user?.lastValue.followersCount += 1
        user?.lastValue.name = "大雷"
    }
    
    deinit {
        print("销毁.....")
    }
}
```
实现：

```swift

class Bindable<Value> {
    private var observations = [(Value) -> Bool]()
    // 模型
    var lastValue: Value {
        didSet { update() }
    }
    
    init(_ value: Value) {
        lastValue = value
    }
    
    /// 添加观察者
    ///
    /// - Parameters:
    ///   - object: 观察对象
    ///   - handler: 回调
    func addObservation<O: AnyObject>(for object: O, handler: @escaping (O, Value) -> Void) {
        handler(object, lastValue)
        observations.append { [weak object] value in
            guard let object = object else {
                return false
            }
            handler(object, value)
            return true
        }
    }
    
    /// 更新数据
    ///
    /// - Parameter value: 模型
    func update(with value: Value? = nil) {
        observations = observations.filter {
            $0(value ?? lastValue) }
    }
    
    /// 绑定视图
    ///
    /// - Parameters:
    ///   - sourceKeyPath: 模型属性
    ///   - object: 视图
    ///   - objectKeyPath: 视图属性
    func bind<O: AnyObject, T>(_ sourceKeyPath: KeyPath<Value, T>, to object: O, _ objectKeyPath: ReferenceWritableKeyPath<O, T?>) {
        
        addObservation(for: object) { object, observed in
            let value = observed[keyPath: sourceKeyPath]
            object[keyPath: objectKeyPath] = value
        }
    }
}
```
[:arrow_up: 返回目录](#table-of-contents)

<h2 id="53">53.基于CSS样式的富文本</h2>

iOS对于富文本的操作一直不是那么方便，一般涉及到富文本的页面我们会优先考虑使用`WebView`，`CSS`一方面样式丰富，另一方面是写起来简单。

其实`NSAttributedString`也是支持带有CSS样式的文本的，其`DocumentType`有一个类型为`html`。

下面给出了一个富文本的封装，可以便捷操作`NSAttributedString`。

```swift
extension NSAttributedString {
    
    convenience init(text: String, styles: [String: String]) {
        
        // 字典转CSS样式字符串
        let style = styles.compactMap({ (property, value) -> String in
            return "\(property): \(value)"
        }).joined(separator: ";")
        
        // 生成span标签对应的富文本
        try! self.init(
            data: Data("<span style=\"\(style)\">\(text)</span>".utf8),
            options: [.documentType: NSAttributedString.DocumentType.html, .characterEncoding: String.Encoding.utf8.rawValue],
            documentAttributes: nil
        )
    }
    
    /// 可以通过"+"拼接NSAttributedString对象
    static func +(lhs: NSAttributedString, rhs: NSAttributedString) -> NSAttributedString {
        
        let concatenatedString = NSMutableAttributedString(attributedString: lhs)
        concatenatedString.append(rhs)
        return concatenatedString
    }
}

```
使用：

绘制一个如下图的`Label`

```swift
// 统一的样式
enum Styles {

static let `protocol` = [
        "color" : "#7B68EE",
        "font-size": "32px",
        "font-style": "italic",
    ]
    
    static let separator = [
        "color" : "#B22222",
        "font-size": "28px",
    ]
    
    static let hostname = [
        "color" : "#20B2AA",
        "font-size": "34px",
        "text-decoration": "underline",
    ]
    
    static let path = [
        "color" : "#FFDEAD",
        "font-size": "32px",
        "text-decoration": "underline",
        "font-style": "oblique",
    ]
}

let `protocol` = NSAttributedString(text: "https", styles: Styles.protocol)
let separator = NSAttributedString(text: "://", styles: Styles.separator)
let hostname = NSAttributedString(text: "github.com", styles: Styles.hostname)
let path = NSAttributedString(text: "/DarielChen/iOSTips", styles: Styles.path)
        
label.attributedText = `protocol` + separator + hostname + path

```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="54">54.阴影视差效果的封装</h2>

在`iPhone`锁屏页面上下左右翻转`iPhone`，锁屏壁纸会沿着各个方向发生位移，有一个独特的视差效果。这是利用了陀螺仪，好在苹果有相关的API支持，使用起来不是那么复杂。

我们可以把这个API用在自己的项目中，比如改变阴影的位移。

```swift
    blueView.cornerRadius = 6
    blueView.borderWidth = 2
    blueView.borderColor = .lightGray
       
    blueView.shadowColor = UIColor.darkGray
    blueView.shadowRadius = 6
    blueView.shadowOpacity = 0.5
    blueView.shadowOffset = CGSize(width: 8, height: 8)
    
    // 基于位置的偏移    
    // blueView.shadowMotionOffset = CGSize(width: 12, height: 12)
    // 阴影的偏移
    blueView.motionOffset = CGSize(width: 12, height: 12)
```

具体实现 [猛击](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/Extension/UIView%2BExtension.swift)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="55">55.使用协调器模式管理控制器</h2>

对于控制器之间的跳转，最方便的操作是在需要跳转的地方创建目标控制器，但这种方式总觉得不是太合适。

* 当前控制器和目标控制器本质上是同一类型对象，不应该在当前控制器的某个方法中创建目标控制器。
* 控制器的创建分散在控制器中，不便于统一管理和模块化开发。

使用协调器模式就可以解决上面两个问题。

使用协调器模式的优点：  
 1. 将控制器的创建，配置和切换从控制器层级中剥离开，放到协调器层级中
 2. 控制器不再通过导航控制器`push`或`present`目标控制器
 3. 控制器之间的结构更清晰，易于调试
 4. 协调器中可以嵌套子协调器，使减小模块与模块之间的耦合度

当然了协调器模式也会有缺点：
  1. 协调器不可避免会带来更多的代码，很多操作都要使用代理
  2. 有时还会需要多级代理来传递数据

虽然有缺点但协调器模式还是值得一用。

#### 协调器模式的使用流程

```swift
// 所有的协调器遵守的协议
protocol Coordinator {
    // 设置协调器初始模块
    func start()
}
```
##### 1. 主协调器
主协调器`AppCoordinator`负责管理所有的子协调器，并设置所有子协调器的代理为自身，实现代理方法，作为子协调器之间的切换操作。

##### 2. 统一管理用Storyboard创建的控制器
```swift
extension UIStoryboard {
    
    // MARK: - 获取对应的Storyboard
    private static var main: UIStoryboard {
        return UIStoryboard(name: "Main", bundle: nil)
    }
    // MARK: - Storyboard中控制器管理
    static func instantiateMainViewController(delegate: MainViewControllerDelegate) -> MainViewController {
        let mainVc = main.instantiateViewController(withIdentifier: "MainViewController") as! MainViewController
        mainVc.delegate = delegate
        return mainVc
    }
}
```
利用`extension`加了一层封装，用起来方便一些。

##### 3. 子协调器
子协调器的实现类似主协调器，每个子协调器负责管理一个模块，模块内部的控制器跳转交给子协调器管理，主协调器管理所有的子协调器。实例代码中有两个子模块`Auth`和`Main`。

具体实现 [猛击](https://github.com/DarielChen/iOSTips/blob/master/Demo/55.%e4%bd%bf%e7%94%a8%e5%8d%8f%e8%b0%83%e5%99%a8%e6%a8%a1%e5%bc%8f%e7%ae%a1%e7%90%86%e6%8e%a7%e5%88%b6%e5%99%a8)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="56">56.判断字符串是否为空</h2>

这个空可能是`nil` `单个空格` `多个空格` `tab` `return` `全角空格`。

#### 1. 使用`isEmpty`

`isEmpty`无法判断多个空字符串组合的情况。

```swift
 print("str".isEmpty)  // false
 print("".isEmpty)     // true
 print("  ".isEmpty)   // false
```
因为`isEmpty`的实现逻辑是基于`startIndex`和`endIndex`。下面是`Collection.swift`中关于`isEmpty`的实现过程。

```swift
public var isEmpty: Bool {
  return startIndex == endIndex
}
```
`isEmpty`不能满足需要。

#### 2. 判断字符串中是否包含空格

`isWhitespace`可以实现，但每一次都需要遍历这个字符串。这个遍历我们可以用`allSatisfy`这个高阶函数实现，`allSatisfy`只有当所有的元素满足条件才会返回`true`，否则返回`false`。

```swift
extension String {
    var isBlank: Bool {
        return allSatisfy({ $0.isWhitespace })
    }
}

"str".isBlank          // false
"   str   ".isBlank    // false
"".isBlank             // true
" ".isBlank            // true
"\t\r\n".isBlank       // true
"\u{00a0}".isBlank     // true

```
需要判断字符串是否为空，我们为可选类型添加扩展

```swift
extension Optional where Wrapped == String {
    var isBlank: Bool {
        return self?.isBlank ?? true
    }
}

var str: String? = nil
str.isBlank            // true
str = ""               
str.isBlank            // true
str = "  \t  "               
str.isBlank            // true
str = "Dariel"
str.isBlank            // false
```
[:arrow_up: 返回目录](#table-of-contents)

<h2 id="57">57.避免将字符串硬编码在代码中</h2>

之前都是直接把字符串写在代码中的，思考了一下觉得代码在整洁性和灵活性上有欠缺，其实可以做下统一管理。项目后期要是需要添加国际化也方便一些。

但如果整个项目的字符串都做统一管理，在开发效率上就会有折扣，所以决定在每个包含字符串的文件中添加`String` `Extension`

```swift
fileprivate extension String {
    
    static let recordCell = "recordCell"
    static let showPlayer = "showPlayer"
    static let uuidPathKey = "uuidPath"
    
    static let submit = NSLocalizedString("提交", comment: "提交按钮的标题")
    static let pause = NSLocalizedString("暂停", comment: "")
    static let save = NSLocalizedString("保存", comment: "")
}
```
对于显示在UI上的文字使用`NSLocalizedString`。

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="58">58.恢复非正常终止的应用状态</h2>

App 进入后台后，长时间不使用，或者系统觉得内存不够了，会被自动清理掉。下次再启动的时候，原先的页面和在页面上的操作没有了，用户体验不友好。其实苹果提供了该问题的解决方案。

冷启动恢复状态分为两步：
1. 恢复之前栈中存在的控制器
2. 恢复页面上的内容

#### 1. 控制器栈的恢复

##### 1. 在`AppDelegate`中实现两个方法

```swift

func application(_ application: UIApplication, shouldSaveApplicationState coder: NSCoder) -> Bool {

return true
}
func application(_ application: UIApplication, shouldRestoreApplicationState coder: NSCoder) -> Bool {

return true
}
```

##### 2. 设置`Restoration ID`

###### 1. 对于使用`xib`或者`Storyboard`创建的控制器，需要在如下图添加`Restoration ID`

###### 2.对于纯代码创建的控制器

需要遵守`UIViewControllerRestoration`协议，并实现`withRestorationIdentifierPath`方法，在这个方法中初始化目标控制器。

```swift
extension LastViewController: UIViewControllerRestoration {
    static func viewController(withRestorationIdentifierPath identifierComponents: [String], coder: NSCoder) -> UIViewController? {
        let vc = LastViewController()
        return vc
    }
}
```

#### 2. 控制器状态的恢复

例子，恢复控制器中的一个`UITextField`输入文本。

```swift
extension SecondViewController {

override func encodeRestorableState(with coder: NSCoder) {
        super.encodeRestorableState(with: coder)

guard let input = inputField.text, isViewLoaded else {
            return
        }
        coder.encode(input, forKey: .encodingKeyFieldValue)
    }

override func decodeRestorableState(with coder: NSCoder) {
        super.decodeRestorableState(with: coder)
        assert(isViewLoaded, "We assume the controller is never restored without loading its view first.")
        inputField.text = coder.decodeObject(forKey: .encodingKeyFieldValue) as? String
    }

override func applicationFinishedRestoringState() {
        print("Finished restoring everything.")
    }
}

fileprivate extension String {
    static let encodingKeyFieldValue = "encodingKeyFieldValue"
}
```

#### 3.调试

1. 使用`Xcode`将项目在真机或模拟器上跑起来
2. 按`Home`键将项目退到后台
3. 点击`Xcode`的停止项目按钮
4. 打开非正常终止的项目

具体实现 [猛击](https://github.com/DarielChen/iOSTips/blob/master/Demo/58.%e6%81%a2%e5%a4%8d%e9%9d%9e%e6%ad%a3%e5%b8%b8%e7%bb%88%e6%ad%a2%e7%9a%84%e5%ba%94%e7%94%a8%e7%8a%b6%e6%80%81)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="59">59.清晰的错误处理类型Result</h2>

Swift5.0的标准库中加入了一个新的类型`Result`，使用`Result`可以更清晰的处理代码中的错误。`Result`是一个枚举，分为两种类型`success`和`failure`，都是泛型实现，其中`failure`必须遵守`Error`协议。

### 1. 简化网络请求

网络请求必然要返回成功和失败信息，通常的做法请求成功和失败分别搞一个闭包。

```swift

enum NetError: Error {
    case urlError
    case otherError(Error)
}

// 调用
requestURL("url", success: { data in
 // success
}) { error in
 // failure
}

// 实现
func requestURL(_ url: String, success: @escaping (Data?) -> Void, error: ((NetError) -> Void)? = nil) {
    guard let requestURL = URL(string: url) else {
        error?(.urlError)
        return
    }
    URLSession.shared.dataTask(
        with: URLRequest(url: requestURL),
        completionHandler: { data, _, err in
            if let e = err {
                error?(.otherError(e))
            } else {
                success(data)
            }
    }).resume()
}
```

使用`Result`之后

```swift
// 调用
requestURL("url") { result in
    switch result {
    case .success(let data):
        // success
    case .failure(let error):
        // failure
    }
}

// 实现
func requestURL(_ url: String, completionHandler: @escaping (Result<Data?, NetError>) -> Void) {
        guard let requestURL = URL(string: url) else {
            completionHandler(.failure(.urlError))
            return
        }
        URLSession.shared.dataTask(
            with: URLRequest(url: requestURL),
            completionHandler: { data, _, err in
                if let e = err {
                    completionHandler(.failure(.otherError(e)))
                } else {
                    completionHandler(.success(data))
                }
        }).resume()
}
```

使用`Result`之后可以在一个`switch`语句中统一处理成功和失败的情况。

### 2. `try-catch`与`Result`的转换

如果一个方法中有`try-catch`，而我们又想在方法调用的地方处理错误，那就需要`throws`，但使用`throws`我一直觉得可读性不好。这时我们就可以使用`Result`替换`try-catch`。

```swift
let result = Result { try ... }
```

下面将带有`try-catch`的`decode`转化为返回`Result`的`decode`。

```swift

// try-catch
func decode<T: Codable>(data: Data) throws -> T {
    do {
        return try JSONDecoder().decode(T.self, from: data)
    }catch {
        throw error
    }
}

// Result
func decode<T: Codable>(data: Data) -> Result<T, Error> {

return Result {
        try JSONDecoder().decode(T.self, from: data)
    }
}
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="60">60.插件化子控制器</h2>

在实际开发中经常会碰到比较复杂的页面结构，为了让代码清晰就需要其拆分。可以拆分成多个`UIView`或多个`UIViewController`，像我个人还是更喜欢`UIViewController`一点，一方面是它拥有生命周期方法，另一方面是控制器之间会更独立一点，代码之间的耦合性会小一点。

### 1.添加子控制器的方法

1. 代码添加删除

```swift
extension UIViewController {
    func add(_ child: UIViewController) {
        addChild(child)
        view.addSubview(child.view)
        child.didMove(toParent: self)
    }

func remove() {
        // 避免重复删除
        guard parent != nil else {
            return
        }

willMove(toParent: nil)
        view.removeFromSuperview()
        removeFromParent()
    }
}
```

2.`Stroyboard`中添加

[37.给UIViewController添加静态Cell](#37)

### 2.可上下滚动的`StackViewController`

页面结构一复杂，内容高度很容易超过屏幕高度，就需要视图支持上下拖动，`UIScrollView`和`UIStackView`无疑是一对好的组合。下面给出了一个自定义的`StackViewController`。

#### 1. 继承实现

```swift
class StackViewController: UIViewController {
    private let scrollView = UIScrollView()
    private let stackView = UIStackView()

override func viewDidLoad() {
        super.viewDidLoad()
        view.addSubview(scrollView)
        scrollView.addSubview(stackView)
        setupConstraints()
        stackView.axis = .vertical
    }

private func setupConstraints() {
        scrollView.translatesAutoresizingMaskIntoConstraints = false
        stackView.translatesAutoresizingMaskIntoConstraints = false

NSLayoutConstraint.activate([
            scrollView.leadingAnchor.constraint(equalTo: view.safeAreaLayoutGuide.leadingAnchor),
            scrollView.trailingAnchor.constraint(equalTo: view.safeAreaLayoutGuide.trailingAnchor),
            scrollView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
            scrollView.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),

stackView.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor),
            stackView.trailingAnchor.constraint(equalTo: scrollView.trailingAnchor),
            stackView.topAnchor.constraint(equalTo: scrollView.topAnchor),
            stackView.bottomAnchor.constraint(equalTo: scrollView.bottomAnchor),
            stackView.widthAnchor.constraint(equalTo: view.safeAreaLayoutGuide.widthAnchor)
        ])
    }
}

extension StackViewController {
    func add(_ child: UIViewController, size: CGSize) {
        addChild(child)
        stackView.addArrangedSubview(child.view)
        child.didMove(toParent: self)

child.view.translatesAutoresizingMaskIntoConstraints = false
        NSLayoutConstraint.activate([
            child.view.heightAnchor.constraint(equalToConstant: size.height),
            child.view.widthAnchor.constraint(equalToConstant:size.width)
        ])
    }

func remove(_ child: UIViewController) {
        guard child.parent != nil else {
            return
        }

child.willMove(toParent: nil)
        stackView.removeArrangedSubview(child.view)
        child.view.removeFromSuperview()
        child.removeFromParent()
    }
}
```

使用：添加三个屏幕宽度，高度为500的控制器`View`到`ViewController`上。

```swift
class ViewController: StackViewController {

override func viewDidLoad() {
        super.viewDidLoad()

let vc1 = UIViewController()
        vc1.view.backgroundColor = UIColor.orange

let vc2 = UIViewController()
        vc2.view.backgroundColor = UIColor.purple

let vc3 = UIViewController()
        vc3.view.backgroundColor = UIColor.blue

add(vc1, size: CGSize(width: UIScreen.main.bounds.width, height: 500))
        add(vc2, size: CGSize(width: UIScreen.main.bounds.width, height: 500))
        add(vc3, size: CGSize(width: UIScreen.main.bounds.width, height: 500))
    }
}
```
#### 2. 协议实现

如果觉得用继承会增加代码的耦合性，还可以使用`protocol`。[猛击StackViewControllerProtocol](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/DCTool/StackViewControllerProtocol.swift)

使用：添加三个屏幕宽度，高度为500的控制器`View`到`ViewController`上。

```swift
class ViewController: UIViewController, StackViewControllerProtocol {
    var scrollView: UIScrollView = UIScrollView()
    var stackView: UIStackView  = UIStackView()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        setUpStackAndScrollView()
        
        let vc1 = UIViewController()
        vc1.view.backgroundColor = UIColor.orange

let vc2 = UIViewController()
        vc2.view.backgroundColor = UIColor.purple

let vc3 = UIViewController()
        vc3.view.backgroundColor = UIColor.blue

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="61">61.ExpressibleBy协议集:通过字面量实例化对象</h2>

实现了`ExpressibleBy`协议集的对象，可以通过像字符串、整型、浮点型、数组、字典等直接实例化对象。

这个协议集有什么用呢？

### 1.实例化URL

```swift
// 字符串构造URL
let url1: URL = URL(string: "https://github.com/DarielChen/iOSTips")!
```

实现了`ExpressibleBy`协议后，可以通过字符串直接构造URL

```swift
let url2: URL = "https://github.com/DarielChen/iOSTips"

// ExpressibleByStringLiteral:通过字符串构造对象
extension URL: ExpressibleByStringLiteral {
    public init(stringLiteral value: String) {
        guard let url = URL(string: value) else {
            fatalError("Bad string, failed to create url from: \(value)")
        }
        self = url
    }
}
```

`String`类默认实现了`ExpressibleByStringLiteral`，当我们往`String`对象赋值字符串的时候，会通过构造方法初始化一个`String`对象。

### 2.用时间戳和字符串实例化`Date`

```swift
// 字符串转Date
let date1: Date = "2019-07-23"
let date2: Date = "2019-07-23 16:12"
let date3: Date = "2019-07-23 16:12:05"

// 时间戳转Date
let date4: Date = "1563873794"
let date5: Date = 1563873794
```

具体实现 [猛击](https://github.com/DarielChen/SwiftTips/blob/master/SwiftTipsDemo/DCTool/Extension/Date%2BExtension.swift)

### 3.字典转模型

```swift
 // 字典转模型
let Joan: Person = ["name": "Joan", "age": 10, "isMan": false]

let persons: [Person] = [
                        ["name": "Joan", "age": 10, "isMan": false],
                        ["name": "Joan", "age": 10, "isMan": false]
                    ]

// json转模型
let John: Person = #"{"name":"John", "age": 10, "isMan": false}"#
```

将字典转模型的实现放到构造方法中，在`extension`中实现这个构造方法，具体实现如下代码：

```swift
struct Person: ExpressibleByModelLiteral {
    let name: String
    let age: Int
    let isMan: Bool
}

protocol ExpressibleByModelLiteral: Codable, ExpressibleByDictionaryLiteral, ExpressibleByStringLiteral {}
extension ExpressibleByModelLiteral {

public init(dictionaryLiteral elements: (String, Any)...) {

let dict: [String: Any] = elements.reduce(into: [String: Any](), { $0[$1.0] = $1.1})
        do {
            let jsonData = try JSONSerialization.data(withJSONObject: dict, options: [])
            self = try JSONDecoder().decode(Self.self, from: jsonData)
        }catch {
            fatalError("Dictionary to model failed, error:\(error)")
        }
    }

public init(stringLiteral value: String) {
        guard let data = value.data(using: .utf8) else {
            fatalError("String to data failed")
        }
        do {
            self = try JSONDecoder().decode(Self.self, from: data)
        }catch {
            fatalError("String to model failed, error:\(error)")
        }
    }
}
```

### 4.`ExpressibleBy`协议集

#### 集合

```swift
ExpressibleByArrayLiteral // 通过数组实例化对象
ExpressibleByDictionaryLiteral // 通过字典实例化对象
```

#### 值

```swift
ExpressibleByIntegerLiteral // 通过整型实例化对象
ExpressibleByFloatLiteral // 通过浮点数实例化对象
ExpressibleByBooleanLiteral // 通过bool值实例化对象
ExpressibleByNilLiteral // 用nil实例化对象，可选类型的底层实现

```

#### 字符串

```swift
ExpressibleByStringLiteral // 通过字符串实例化对象
ExpressibleByExtendedGraphemeClusterLiteral // 将字符、字符集实例化对象
ExpressibleByUnicodeScalarLiteral // 通过Unicode实例化对象
ExpressibleByStringInterpolation // 通过字符串插值（"\(value)"）实例化对象
```

实现`ExpressibleBy`对应的协议后，可以将对应实例的构造方法实现交给编译器去做，直接通过赋值的方式完成对象实例化，代码可以更简洁，但代码的可阅读性会降低，是否使用还是看实际场景。

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="62">62.插件化TableView</h2>

每次实现`TableView`都要写一堆重复的代码，包括注册`cell`,实现数据源方法，设置各种代理。

这个过程可以简化，下面出了一种方案供参考。

先说怎么使用：

### 1. 设置数据源

```swift
let section = Section(items: [
            ENCellModel(name: "chili", imageStr: "chili"),
            ENCellModel(name: "mushroom", imageStr: "mushroom"),
            ENCellModel(name: "radish", imageStr: "radish")
            ])
let dataSource = DataSource(sections: [section])
```

`DataSource`是一个数组，负责管理所有的`section`。

### 2. 配置cell

```swift

let configuartor = Configurator{ (cell, model: ENCellModel, tableView, indexPath) -> NibTableViewCell in
    cell.iconLabel.text = model.name
    cell.iconView.image = UIImage(named: model.imageStr)
    return cell
}

```

通过闭包回调设置`Cell`。

### 3. 初始化`TableView`，传入数据源和配置

```swift

let pluginTableView = PluginTableView(frame: view.bounds, style: .plain, dataSource: dataSource, configurator: configuartor)
pluginTableView.tableView.rowHeight = 80
view.addSubview(pluginTableView)

```

像`View`一样添加到页面上。

### 4. 通过闭包回调`TableView`代理

```swift
// didSelectRow回调
pluginTableView.didSelectRow = { [weak self] (tableView, indexPath) in

}
```

### 5. 支持不同类型的`Cell`

```swift
// 在设置section的时候一下包装，包装section中不同的model
private enum CellModel {
    case CNCell(CNCellModel)
    case ENCell(ENCellModel)
}
// 重新实现ConfiguratorType协议，在里面区分cell
private struct AggregateConfigurator: ConfiguratorType {
    let cellConfigurator1: Configurator<CNCellModel, CodeTableViewCell>
    let cellConfigurator2: Configurator<ENCellModel, NibTableViewCell>

func reuseIdentifier(for item: CellModel, indexPath: IndexPath) -> String {
        switch item {
        case .CNCell:
            return cellConfigurator1.reuseIdentifier
        case .ENCell:
            return cellConfigurator2.reuseIdentifier
        }
    }

func configure(cell: UITableViewCell, item: CellModel, tableView: UITableView, indexPath: IndexPath) -> UITableViewCell {

switch item {
        case .CNCell(let model):
            return cellConfigurator1.configuredCell(for: model, tableView: tableView, indexPath: indexPath)
        case .ENCell(let model):
            return cellConfigurator2.configuredCell(for: model, tableView: tableView, indexPath: indexPath)
        }
    }

func registerCells(in tableView: UITableView) {
        cellConfigurator1.registerCells(in: tableView)
        cellConfigurator2.registerCells(in: tableView)
    }
}
```

```swift

// 分开配置section
let section1 = Section<CellModel>(items: [
            .CNCell(CNCellModel(name: "柠檬", imageStr: "lemon")),
            .CNCell(CNCellModel(name: "橙子", imageStr: "orange")),
            .CNCell(CNCellModel(name: "西瓜", imageStr: "watermelon"))
            ])
let section2 = Section<CellModel>(items: [
            .ENCell(ENCellModel(name: "chili", imageStr: "chili")),
            .ENCell(ENCellModel(name: "mushroom", imageStr: "mushroom")),
            .ENCell(ENCellModel(name: "radish", imageStr: "radish"))
            ])

let dataSource = DataSource(sections: [section1, section2])

let configuartor1 = Configurator { (cell, model: CNCellModel, tableView, indexPath) -> CodeTableViewCell in
    cell.iconLabel.text = model.name
    cell.iconView.image = UIImage(named: model.imageStr)
    return cell
}

let configuartor2 = Configurator { (cell, model: ENCellModel, tableView, indexPath) -> NibTableViewCell in
    cell.iconLabel.text = model.name
    cell.iconView.image = UIImage(named: model.imageStr)
    return cell
}

// 分开cell属性设置，通过刚刚实现的AggregateConfigurator做统一管理
let aggregate = AggregateConfigurator(cellConfigurator1: configuartor1, cellConfigurator2: configuartor2)

let pluginTableView = PluginTableView(frame: view.bounds, style: .grouped, dataSource: dataSource, configurator: aggregate)

pluginTableView.tableView.rowHeight = 80
view.addSubview(pluginTableView)

```

具体实现 [猛击](https://github.com/DarielChen/iOSTips/blob/master/Demo/62.%e6%8f%92%e4%bb%b6%e5%8c%96TableView//PluginTableView/PluginTableView)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="63">63.自定义底部弹层控制器</h2>

开发中经常会碰到需要自定义底部弹层，常用的方式是自定义一个View，但有时底部弹层中的业务逻辑会很多，尤其是还需要调用网络层，使用自定义View就不太合适了。其实我们可以通过自定义modal转场动画的方式实现一个自定义底部弹层控制器。

具体实现代码如下：

```swift

class PresentPartController: UIViewController {
    lazy var backdropView: UIView = {
        let bdView = UIView(frame: self.view.bounds)
        bdView.backgroundColor = UIColor.black.withAlphaComponent(0.5)
        return bdView
    }()

let menuView = UIView()
    let menuHeight = UIScreen.main.bounds.height / 2
    var isPresenting = false

init() {
        super.init(nibName: nil, bundle: nil)
        modalPresentationStyle = .custom
        transitioningDelegate = self
    }

required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

override func viewDidLoad() {
        super.viewDidLoad()

view.backgroundColor = .clear
        view.addSubview(backdropView)
        view.addSubview(menuView)

menuView.backgroundColor = .white
        menuView.translatesAutoresizingMaskIntoConstraints = false
        menuView.heightAnchor.constraint(equalToConstant: menuHeight).isActive = true
        menuView.bottomAnchor.constraint(equalTo: view.bottomAnchor).isActive = true
        menuView.leadingAnchor.constraint(equalTo: view.leadingAnchor).isActive = true
        menuView.trailingAnchor.constraint(equalTo: view.trailingAnchor).isActive = true

let tapGesture = UITapGestureRecognizer(target: self, action: #selector(PresentPartController.handleTap(_:)))
        backdropView.addGestureRecognizer(tapGesture)
    }

@objc func handleTap(_ sender: UITapGestureRecognizer) {
        dismiss(animated: true, completion: nil)
    }
}

extension PresentPartController: UIViewControllerTransitioningDelegate, UIViewControllerAnimatedTransitioning {
    func animationController(forPresented presented: UIViewController, presenting: UIViewController, source: UIViewController) -> UIViewControllerAnimatedTransitioning? {
        return self
    }

func animationController(forDismissed dismissed: UIViewController) -> UIViewControllerAnimatedTransitioning? {
        return self
    }

func transitionDuration(using transitionContext: UIViewControllerContextTransitioning?) -> TimeInterval {
        return 0.24
    }

func animateTransition(using transitionContext: UIViewControllerContextTransitioning) {
        let containerView = transitionContext.containerView
        let toViewController = transitionContext.viewController(forKey: UITransitionContextViewControllerKey.to)
        guard let toVC = toViewController else { return }
        isPresenting = !isPresenting

if isPresenting == true {
            containerView.addSubview(toVC.view)

menuView.frame.origin.y += menuHeight
            backdropView.alpha = 0

UIView.animate(withDuration: 0.24, delay: 0, options: [.curveEaseOut], animations: {
                self.menuView.frame.origin.y -= self.menuHeight
                self.backdropView.alpha = 1
            }, completion: { _ in
                transitionContext.completeTransition(true)
            })
        } else {
            UIView.animate(withDuration: 0.24, delay: 0, options: [.curveEaseOut], animations: {
                self.menuView.frame.origin.y += self.menuHeight
                self.backdropView.alpha = 0
            }, completion: { _ in
                transitionContext.completeTransition(true)
            })
        }
    }
}

```

示例Demo [猛击](https://github.com/DarielChen/iOSTips/blob/master/Demo/63.%e8%87%aa%e5%ae%9a%e4%b9%89%e5%ba%95%e9%83%a8%e5%bc%b9%e5%b1%82%e6%8e%a7%e5%88%b6%e5%99%a8)

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="64">64.UIAlertController的封装</h2>

如果单纯使用系统的API创建一个`UIAlertController`总觉得有点麻烦，首先要初始化`UIAlertController`，然后再创建多个`UIAlertAction`添加到`UIAlertController`中

```swift
let alertController = UIAlertController(title: "标题文字", message: "内容文字", preferredStyle: .alert)
        
let confirmAction = UIAlertAction(title: "确认", style: .default) { _ in  }
let cancelAction = UIAlertAction(title: "取消", style: .cancel)
        
alertController.addAction(cancelAction)
alertController.addAction(confirmAction)

present(alertController, animated: true)
```

其实我们可以用`swift5.1`新特性`Function Builders`对`UIAlertController`做一层简化封装，达到如下效果

```swift
UIAlertController.show(title: "标题文字", message: "内容文字", style: .alert) { () -> [Action] in 		
    Action.default("确认") { print("String") }
    Action.cancel("取消")
}
```

## Function Builders

这个特性是用在`swiftUI`中用来构建`@ViewBuilder`的，但由于它是`swift`语言层面的特性，所以非`swiftUI`我们也可以使用。

这个新特性在`swift5.1`中还未完全实现，所以我们用的不是注解`@functionBuilder`而是`@_functionBuilder`

下面是几个需要实现的方法

```swift
// 是否允许使用闭包
buildBlock(_ components: Component...) -> Component // required

// 闭包内是否允许使用 if-else语句
buildIf(_ component: Component?) -> Component // optional
buildEither(first: Component) -> Component // optional
buildEither(second: Component) -> Component // optional
```

完整的实现

```swift
extension UIAlertController {
    
    static func show(title: String? = nil, message: String? = nil, style: UIAlertController.Style, @ActionBuilder _ makeActions: () -> [Action]) {
        let controller = UIAlertController(
            title: title,
            message: message,
            preferredStyle: style
        )
        for action in makeActions() {
            let uiAction = UIAlertAction(title: action.title, style: action.style) { _ in
                action.action()
            }
            controller.addAction(uiAction)
        }
        UIApplication.shared.keyWindow?.rootViewController?.present(controller, animated: true, completion: nil)
    }
}

struct Action {
    let title: String
    let style: UIAlertAction.Style
    let action: () -> Void
}
extension Action {
    static func `default`(_ title: String, action: @escaping () -> Void) -> [Action] {
        return [Action(title: title, style: .default, action: action)]
    }
    static func destructive(_ title: String, action: @escaping () -> Void) -> [Action] {
        return [Action(title: title, style: .destructive, action: action)]
    }
    static func cancel(_ title: String, action: @escaping () -> Void = {}) -> [Action] {
        return [Action(title: title, style: .cancel, action: action)]
    }
}

@_functionBuilder
struct ActionBuilder {
    typealias Expression = Action
    typealias Component = [Action]

static func buildBlock(_ children: Component...) -> Component {
        return children.flatMap { $0 }
    }
    static func buildIf(_ component: Component?) -> Component {
        return component ?? []
    }
    static func buildEither(first component: Component) -> Component {
        return component
    }
    static func buildEither(second component: Component) -> Component {
        return component
    }
}
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="65">65.自定义控制器构造方法</h2>

有时我们初始化控制器时，也需要传入一些值，因为这些值是伴随着初始化的，所以通过控制器的构造方法传入会合适一点。

因为`userID`一定要在构造方法中传入，`userID`属性就可以是非可选类型，所以在使用的时候可以减少一层解包操作。

```swift
    // 初始化TestViewController
    TestViewController(userID: "7812381312")

class TestViewController: UIViewController {
    private let userID: String
    
    init(userID: String) {
        self.userID = userID
        super.init(nibName: nil, bundle: nil)
    }
    
    // 如果不想使用storyboard初始化构造方法，我们可以使用Xcode给的默认提示
    @available(*, unavailable) // 防止调用
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

// ...
}
```
在`iOS13`中如果我们想通过`storyboard`来初始化控制器可以自定义构造方法

```swift 
    // 1.通过代码初始化控制器
    showTestVc(for: "7812381312")
    @available(iOS 13.0, *)
    private func showTestVc(for userID: String) {
        guard let viewController = storyboard?.instantiateViewController(
            identifier: "TestViewController",
            creator: { coder in
                TestViewController(userID: userID, coder: coder)
            }
        ) else {
            fatalError("Failed to create Product Details VC")
        }
        show(viewController, sender: self)
    }

// 2.通过storyboard segues初始化控制器,记得关联segue actions
    @IBSegueAction func showTestVc2(_ coder: NSCoder) -> TestViewController? {
        TestViewController(userID: "7812381312", coder: coder)
    }

class TestViewController: UIViewController {
    // ....
    init?(userID: String, coder: NSCoder) {
        self.userID = userID
        super.init(coder: coder)
    }
    
    @available(*, unavailable, renamed: "init(userID:coder:)")
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    // ...
}
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="66">66.性能调优之像素对齐</h2>

我们日常开发中使用本地图片都需要以`@2x`、`@3x`命名结尾，2x、3x的意思是一个点`Point`对应多少个像素`pixel`。

点`Point`：逻辑坐标的基本单位，也是日常布局中常用的，比如某个视图的宽度为8，宽度单位就是点。点是虚拟单位，并非实际存在，还需`GPU`计算点对应的像素。

像素`pixel`：屏幕上最小的色块单元，例如`iPhone 11 Pro Max`的屏幕像素是`1242x2688 px`，对应的点是`414x896 pt` ，点跟像素对应的关系是1：3，所以在`iPhone 11 Pro Max`上需要使用`@3x`的图片。

[苹果所有设备的屏幕尺寸及对应的像素](https://developer.apple.com/design/human-interface-guidelines/ios/visual-design/adaptivity-and-layout/)

我们还可以通过`UIScreen.main.scale`来获取像素与点的对应关系。

像素不对齐: 因为点跟像素之间需要`GPU`计算转换，那么肯定会出现点不能转化为整个像素的情况，比如，0.5个点转化为1.5个像素，这时就需要`GPU`做反锯齿计算，产生性能损耗。

查看是否有像素不对齐：在模拟器调试时，打开模拟器的 `Debug` -> 勾选`Color Misaligned Images`，看看视图是不是标黄了

```swift
let label = UILabel()

// 0.5个点在3x设备上不能转化为整个像素
label.frame = CGRect(x: 20.5, y: 160, width: 320, height: 40)
label.textColor = .gray
label.text = "x: 20.5, y: 160, width: 320, height: 40"
```

解决像素不对齐的方法我们可以根据屏幕倍数对点进行向上取整。下面是一些可用的`extension`。

```swift
// from
label.frame = CGRect(x: 20.5, y: 160, width: 320, height: 40)

//to
label.frame = CGRect(x: 20.5, y: 160, width: 320, height: 40).flat()
// or
label.frame = CGRect(20.5, 160, 320, 40)
```

```swift
public extension CGSize {
    /// 创建 一个像素对齐的`CGSize`
    init(_ width: CGFloat, _ height: CGFloat) {
        self.init(width: width.flat(), height: height.flat())
    }

/// 转化成像素对齐的`CGSize`
    /// - Returns: 像素对齐的`CGSize`
    func flat() -> CGSize {
        return CGSize(width: width.flat(), height: height.flat())
    }
}

public extension CGRect {
    /// 创建 一个像素对齐的`CGRect`
    init(_ x: CGFloat, _ y: CGFloat, _ width: CGFloat, _ height: CGFloat) {
        self.init(x: x.flat(), y: y.flat(), width: width.flat(), height: height.flat())
    }

/// 转化成像素对齐的`CGRect`
    /// - Returns: 像素对齐的`CGRect`
    func flat() -> CGRect {
        return CGRect(x: origin.x.flat(), y: origin.y.flat(), width: width.flat(), height: height.flat())
    }
}

public extension CGFloat {
    /// 基于屏幕倍数，进行像素取整
    /// - Parameter scale: 屏幕倍数（不传为当前屏幕倍数）
    /// - Returns: 取整后的像素
    /// 例如传进来 “2.1”，在 `2x` 倍数下会返回 2.5（0.5pt 对应 1px），在 `3x`倍数下会返回 2.333（0.333pt 对应 1px）。
    func flat(scale: CGFloat? = nil) -> CGFloat {
        let floatValue = removeFloatMin()
        let newScale = scale ?? UIScreen.main.scale
        return ceil(floatValue * newScale) / newScale
    }

/// 将最小正数转为0，避免将最小正数当做数值参与计算（这样可能会导致某些精度问题）
    /// - Returns:非最小正数
    func removeFloatMin() -> CGFloat {
        return self == .leastNormalMagnitude ? 0 : self
    }
}
```

[:arrow_up: 返回目录](#table-of-contents)

<h2 id="67">67.可以做与运算的结构体</h2>

我们都知道枚举的`case`具有互斥性 ，每次赋值只能选择一种类型，但如果需要同时选择多种类型呢？

比如给`view`添加圆角，可设置的圆角有四个，通常我们都会一次同时添加几个圆角。

```swift
// 给view添加两个顶部的圆角
darkView.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]
```

有没有注意到`maskedCorners`属性的类型，它其实不是枚举。

```swift
// CACornerMask
public struct CACornerMask : OptionSet {
    public init(rawValue: UInt)

public static var layerMinXMinYCorner: CACornerMask { get }
    public static var layerMaxXMinYCorner: CACornerMask { get }
    public static var layerMinXMaxYCorner: CACornerMask { get }
    public static var layerMaxXMaxYCorner: CACornerMask { get }
}
```
`CACornerMask`是个结构体，赋值的时候可以同时支持多种类型的静态内部变量。

下面我们自定义一个这种类型。  
具体实现：

```swift
struct DCCornerMask: OptionSet {
    let rawValue: Int
    static let layerMinXMinYCorner = DCCornerMask(rawValue: 1 << 0)
    static let layerMaxXMinYCorner = DCCornerMask(rawValue: 1 << 1)
    static let layerMinXMaxYCorner = DCCornerMask(rawValue: 1 << 2)
    static let layerMaxXMaxYCorner = DCCornerMask(rawValue: 1 << 3)
}
```

使用：
```swift
    mask = [.layerMinXMinYCorner, .layerMinXMaxYCorner, .layerMaxXMaxYCorner]
```

赋值转化，如何去解析给结构体设置的值：
```swift
var mask: DCCornerMask? {
    didSet {
        guard let mask = mask else { return }
        if mask.contains(.layerMinXMinYCorner) {
            // 打印 1
            print(DCCornerMask.layerMinXMinYCorner.rawValue)
        }
        if mask.contains(.layerMaxXMinYCorner) {
            print(DCCornerMask.layerMaxXMinYCorner.rawValue)
        }
        if mask.contains(.layerMinXMaxYCorner) {
            // 打印 4
            print(DCCornerMask.layerMinXMaxYCorner.rawValue)
        }
        if mask.contains(.layerMaxXMaxYCorner) {
            // 打印 8
            print(DCCornerMask.layerMaxXMaxYCorner.rawValue)
        }
    }
}
```

[:arrow_up: 返回目录](#table-of-contents)

iOSTips

iOSTips 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

iOSTips

iOSTips 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README