image.png

Swift 协议

1.协议介绍

协议可以用来定义方法、属性、下标的声明，协议可以被枚举、结构体、类遵守(多个协议之间用逗号隔开)

// 创建协议
  protocol Drawable {
    func draw()
    var x: Int { get set }
    var y: Int { get }
    subscript(index: Int) -> Int { get set }
}

// 遵守多个协议
protocol Test1 { }
protocol Test2 { }
protocol Test3 { }
class TestClass : Test1, Test2, Test3 { }

• 协议中定义方法时不能有默认参数值
• 默认情况下，协议中定义的内容必须全部都实现

2. 协议中的属性

• 协议中定义属性时必须用var关键字
• 实现协议时的属性权限要不小于协议中定义的属性权限
  • 协议定义get、set，用var存储属性或get、set计算属性去实现
  • 协议定义get，用任何属性都可以实现

protocol Drawable {
    func draw()
    var x: Int { get set }
    var y: Int { get }
    subscript(index: Int) -> Int { get set }
}

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

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

3. static、class

为了保证通用，协议中必须用static定义类型方法、类型属性、类型下标

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

4.mutating

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

protocol Drawable {
    mutating func draw()
}
class Size : Drawable {
    var width: Int = 0
    func draw() {
width = 10 }
}
struct Point : Drawable {
    var x: Int = 0
    mutating func draw() {
        x = 10
} }

5. init

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

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

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

protocol Livable {
    init(age: Int)
}
class Person {
    init(age: Int) { }
}
class Student : Person, Livable {
    required override init(age: Int) {
        super.init(age: age)
    }
}

6.init、init?、init!

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

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

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

7.协议的继承

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

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

8. 协议组合

协议组合，可以包含1个类类型(最多1个)

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

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

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

9.CaseIterable

让枚举遵守CaseIterable协议，可以实现遍历枚举值

enum Season : CaseIterable {
    case spring, summer, autumn, winter
}
let seasons = Season.allCases
print(seasons.count) // 4
for season in seasons {
    print(season)
} // spring summer autumn winter

10. CustomStringConvertible

遵守CustomStringConvertible协议，可以自定义实例的打印字符串

 class Person : CustomStringConvertible {
    var age: Int
    var name: String
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    var description: String {
        "age=\(age), name=\(name)"
} }
var p = Person(age: 10, name: "Jack")
print(p) // age=10, name=Jack

11. Any、AnyObject

Swift提供了2种特殊的类型:Any、AnyObject

• Any:可以代表任意类型(枚举、结构体、类，也包括函数类型)
• AnyObject:可以代表任意类类型(在协议后面写上: AnyObject代表只有类能遵守这个协议)

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

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

12. is、as?、as!、as

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

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

var stu: Any = 10
print(stu is Int) // true
stu = "Jack"
print(stu is String) // true 
stu = Student()
print(stu is Person) // true 
print(stu is Student) // true 
print(stu is Runnable) // true

var stu: Any = 10
(stu as? Student)?.study() // 没有调用study stu = Student()
(stu as? Student)?.study() // Student study (stu as! Student).study() // Student study (stu as? Runnable)?.run() // Student run

 var data = [Any]() 
 data.append(Int("123") as Any)
 
var d = 10 as Double
print(d) // 10.0

13. X.self、X.Type、AnyClass

X.self是一个元类型(metadata)的指针，metadata存放着类型相关信息
X.self属于X.Type类型

class Person { }
class Student : Person { }
var perType: Person.Type = Person.self var stuType: Student.Type = Student.self perType = Student.self

var anyType: AnyObject.Type = Person.self anyType = Student.self
public typealias AnyClass = AnyObject.Type var anyType2: AnyClass = Person.self 
anyType2 = Student.self

var per = Person()
var perType = type(of: per) // Person.self print(Person.self == type(of: per)) // true

14. Self

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

protocol Runnable {
    func test() -> Self
}
class Person : Runnable {
    required init() { }
func test() -> Self { type(of: self).init() } }
class Student : Person { }

var p = Person()
// Person
print(p.test())
var stu = Student()
// Student
print(stu.test())

Swift 泛型(Generics)

1.介绍

泛型代码让你能根据你所定义的要求写出可以用于任何类型的灵活的、可复用的函数,泛型是 Swift 最强大的特性之一，很多 Swift 标准库是基于泛型代码构建的

泛型可以将类型参数化，提高代码复用率，减少代码量

2.泛型函数

泛型函数可以用于任何类型, 函数用了一个占位符类型名（这里叫做 T ），占位符类型名没有声明 T 必须是什么样的，但是它确实说了 a 和 b 必须都是同一个类型 T ，或者说都是 T 所表示的类型。,下面的例子: T会自动推断为Int 类型

func swapValues<T>(_ a: inout T, _ b: inout T) { 
    (a, b) = (b, a)
}

var i1 = 10
var i2 = 20
swapValues(&i1, &i2)

3. 泛型类型

除了泛型函数，Swift允许你定义自己的泛型类型。它们是可以用于任意类型的自定义类、结构体、枚举，和 Array 、 Dictionary 方式类似。

struct Stack<Element> {
    var items = [Element]()
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
}

var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")

4.关联类型(Associated Type)

定义一个协议时，有时在协议定义里声明一个或多个关联类型是很有用的。关联类型给协议中用到的类型一个占位符名称。直到采纳协议时，才指定用于该关联类型的实际类型。关联类型通过 associatedtype 关键字指定。

• 关联类型的作用:给协议中用到的类型定义一个占位名称
• 协议中可以拥有多个关联类型

protocol Stackable {
    associatedtype Element // 关联类型 
    mutating func push(_ element: Element)  
    mutating func pop() -> Element
    func top() -> Element
    func size() -> Int
}

class StringStack : Stackable {
    // 给关联类型设定真实类型
    // typealias Element = String
    var elements = [String]()
    func push(_ element: String) { elements.append(element) } func pop() -> String { elements.removeLast() }
    func top() -> String { elements.last! }
    func size() -> Int { elements.count } }
var ss = StringStack()
ss.push("Jack")
ss.push("Rose")

5.类型约束

类型约束指出一个类型形式参数必须继承自特定类，或者遵循一个特定的协议、组合协议。

 protocol Runnable { }
        class Person { }
        func swapValues<T : Person & Runnable>(_ a: inout T, _ b: inout T) {
            (a, b) = (b, a)
        }
}

6.可选项的本质

可选项的本质是enum类型

public enum Optional<Wrapped> : ExpressibleByNilLiteral { 
    case none
    case some(Wrapped)
    public init(_ some: Wrapped) 
}

var age: Int? = 10
var age0: Optional<Int> = Optional<Int>.some(10) var age1: Optional = .some(10)
var age2 = Optional.some(10)
var age3 = Optional(10)
age = nil
age3 = .none

Swift 扩展

1.介绍

扩展为现有的类、结构体、枚举类型、或协议添加了新功能。扩展和 Objective-C 中的分类类似。（与 Objective-C 的分类不同的是，Swift 的扩展没有名字。）

Swift 中的扩展可以：

• 添加计算实例属性和计算类型属性；
• 定义实例方法和类型方法；
• 提供新初始化器；
• 定义下标；
• 定义和使用新内嵌类型；
• 使现有的类型遵循某协议

2.扩展的语法

使用 extension 关键字来声明扩展：

extension SomeType {
    // new functionality to add to SomeType goes here
}

扩展可以使已有的类型遵循一个或多个协议。在这种情况下，协议名的书写方式与类或结构体完全一样：

extension SomeType: SomeProtocol, AnotherProtocol {
    // implementation of protocol requirements goes here
}

3.计算属性

扩展可以向已有的类型添加计算实例属性和计算类型属性。

extension Double {
    var km: Double { return self * 1_000.0 }
    var m: Double { return self }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1_000.0 }
    var ft: Double { return self / 3.28084 }
}
let oneInch = 25.4.mm
print("One inch is \(oneInch) meters")
// Prints "One inch is 0.0254 meters"
let threeFeet = 3.ft
print("Three feet is \(threeFeet) meters")
// Prints "Three feet is 0.914399970739201 meters"

4.初始化器

• 扩展可向已有的类型添加新的初始化器。这允许你扩展其他类型以使初始化器接收你的自定义类型作为形式参数，或提供该类型的原始实现中未包含的额外初始化选项。

• 扩展能为类添加新的便捷初始化器，但是不能为类添加指定初始化器或反初始化器。指定初始化器和反初始化器 必须由原来类的实现提供。

class Person {
    var age: Int
    var name: String
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
}
extension Person {
    convenience init() {
        self.init(age: 0, name: "") }
}

5. 方法

扩展可以为已有的类型添加新的实例方法和类型方法

extension Int {
    func repetitions(task: () -> Void) {
        for _ in 0..<self {
            task()
        }
    }
}

3.repetitions {
    print("Hello!")
}

6. 协议

• 如果一个类型已经实现了协议的所有要求，但是还没有声明它遵守了这个协议
• 可以通过扩展来让它遵守这个协议

protocol TestProtocol {
    func test()
}
class TestClass {
    func test() {
        print("test")
    } }
extension TestClass : TestProtocol {}

• 扩展可以给协议提供默认实现，也间接实现『可选协议』的效果
• 扩展可以给协议扩充『协议中从未声明过的方法』

protocol TestProtocol {
    func test1()
}
extension TestProtocol {
    func test1() { print("TestProtocol test1")
    }
    func test2() {
        print("TestProtocol test2") }
}

class TestClass : TestProtocol {} 
var cls = TestClass()
cls.test1() // TestProtocol test1 
cls.test2() // TestProtocol test2 
var cls2: TestProtocol = TestClass() 
cls2.test1() // TestProtocol test1 
cls2.test2() // TestProtocol test2

7.下标

扩展能为已有的类型添加新的下标。

extension Int {
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 0..<digitIndex {
            decimalBase *= 10
        }
        return (self / decimalBase) % 10
    }
}

8.内嵌类型

扩展可以为已有的类、结构体和枚举类型添加新的内嵌类型：

extension Int {
    enum Kind {
        case negative, zero, positive
    }
    var kind: Kind {
        switch self {
        case 0:
            return .zero
        case let x where x > 0:
            return .positive
        default:
            return .negative
        }
    }
}

9.协议

• 扩展中依然可以使用原类型中的泛型类型
• 符合条件才扩展

class Stack<E> {
    var elements = [E]()
    func push(_ element: E) {
        elements.append(element) }
    func pop() -> E { elements.removeLast()}
    func size() -> Int { elements.count }
}
// 扩展中依然可以使用原类型中的泛型类型
extension Stack {
func top() -> E { elements.last! }
}
// 符合条件才扩展
extension Stack : Equatable where E : Equatable {
    static func == (left: Stack, right: Stack) -> Bool {
        left.elements == right.elements
    }
}

Swift 高级运算符

1.介绍

Swift 提供了一些对值进行更加复杂操作的高级运算符,作为基本运算符的补充，这些运算包括你在 C 或 Objective-C 所熟悉的所有按位和移位运算符。

2.溢出运算符(Overflow Operator)

• Swift的算数运算符出现溢出时会抛出运行时错误
• Swift有溢出运算符(&+、&-、&*)，用来支持溢出运算

var min = UInt8.min
print(min &- 1) // 255, Int8.max
var max = UInt8.max
print(max &+ 1) // 0, Int8.min print(max &* 2) // 254, 等价于 max &+ max

3.运算符重载(Operator Overload)

类、结构体、枚举可以为现有的运算符提供自定义的实现，这个操作叫做:运算符重载

struct Point {
    var x: Int
    var y: Int
    
    // 重载运算符
    static func + (p1: Point, p2: Point) -> Point {
        return Point(x: p1.x + p2.x, y: p1.y + p2.y)
    }
    static func - (p1: Point, p2: Point) -> Point {
        return Point(x: p1.x - p2.x, y: p1.y - p2.y)
    }
    static prefix func - (p: Point) -> Point {
        return Point(x: -p.x, y: -p.y)
    }
    static func += (p1: inout Point, p2: Point) {
        p1 = p1 + p2
    }
    static prefix func ++ (p: inout Point) -> Point { p += Point(x: 1, y: 1)
        return p
    }
    static postfix func ++ (p: inout Point) -> Point {
        let tmp = p
        p += Point(x: 1, y: 1)
        return tmp
    }
    static func == (p1: Point, p2: Point) -> Bool {
         return (p1.x == p2.x) && (p1.y == p2.y)
    }
}

var p1 = Point(x: 10, y: 10)
var p2 = Point(x: 20, y: 20)
var p3 = p1 + p2

4.Equatable

• 要想得知2个实例是否等价，一般做法是遵守Equatable 协议，重载== 运算符
• 与此同时，等价于重载了 != 运算符

struct Point : Equatable {
    
    var x: Int
    var y: Int
    static func == (p1: Point, p2: Point) -> Bool {
        return (p1.x == p2.x) && (p1.y == p2.y)
    }
}
var p1 = Point(x: 10, y: 10)
var p2 = Point(x: 10, y: 10)
print(p1 == p2)

Swift为以下类型提供默认的Equatable 实现
没有关联类型的枚举

• 只拥有遵守 Equatable 协议关联类型的枚举
• 只拥有遵守 Equatable 协议存储属性的结构体

引用类型比较存储的地址值是否相等(是否引用着同一个对象)，使用恒等运算符=== 、!==

5.Comparable

要想比较2个实例的大小，一般做法是:

• 遵守 Comparable 协议
• 重载相应的运算符

//score大的比较大，若score相等，age小的比较大 struct Student : Comparable {
var age: Int
var score: Int
init(score: Int, age: Int) {
    self.score = score
    self.age = age
}
static func < (lhs: Student, rhs: Student) -> Bool { (lhs.score < rhs.score)
    || (lhs.score == rhs.score && lhs.age > rhs.age)
}
static func > (lhs: Student, rhs: Student) -> Bool {
    (lhs.score > rhs.score)
        || (lhs.score == rhs.score && lhs.age < rhs.age)
}
static func <= (lhs: Student, rhs: Student) -> Bool {
    !(lhs > rhs) }
static func >= (lhs: Student, rhs: Student) -> Bool { !(lhs < rhs)
} }

var stu1 = Student(score: 100, age: 20) var stu2 = Student(score: 98, age: 18) var stu3 = Student(score: 100, age: 20) print(stu1 > stu2) // true
print(stu1 >= stu2) // true
print(stu1 >= stu3) // true
print(stu1 <= stu3) // true
print(stu2 < stu1) // true
print(stu2 <= stu1) // true

6. 自定义运算符(Custom Operator)

可以自定义新的运算符:在全局作用域使用operator进行声明

prefix operator 前缀运算符
postfix operator 后缀运算符
infix operator 中缀运算符 : 优先级组

precedencegroup 优先级组 {
    associativity: 结合性(left\right\none)
    higherThan: 比谁的优先级高
    lowerThan: 比谁的优先级低
    assignment: true代表在可选链操作中拥有跟赋值运算符一样的优先级
}

prefix operator +++
infix operator +- : PlusMinusPrecedence precedencegroup PlusMinusPrecedence {
    associativity: none
    higherThan: AdditionPrecedence lowerThan: MultiplicationPrecedence assignment: true
}

Swift 错误处理

开发过程常见的错误

• 语法错误(编译报错)
• 逻辑错误
• 运行时错误(可能会导致闪退，一般也叫做异常)

1.自定义错误

• Swift中可以通过Error协议自定义运行时的错误信息

enum SomeError : Error {
    case illegalArg(String) 
    case outOfBounds(Int, Int) 
    case outOfMemory
}

• 函数内部通过throw抛出自定义Error，可能会抛出Error的函数必须加上throws声明

func divide(_ num1: Int, _ num2: Int) throws -> Int { if num2 == 0 {
    throw SomeError.illegalArg("0不能作为除数") }
    return num1 / num2
}

• 需要使用try调用可能会抛出Error的函数

 var result = try divide(20, 10)

2.do-catch

• 可以使用do-catch捕捉Error

func test() {
    print("1")
    do {
        print("2")
        print(try divide(20, 0))
        print("3")
    } catch let SomeError.illegalArg(msg) {
        print("参数异常:", msg)
    } catch let SomeError.outOfBounds(size, index) {
        print("下标越界:", "size=\(size)", "index=\(index)")
    } catch SomeError.outOfMemory {
        print("内存溢出") } catch {
            print("其他错误")
    }
    print("4")
}

• 抛出Error后，try下一句直到作用域结束的代码都将停止运行

3.处理Error

处理Error的2种方式
1 通过do-catch捕捉Error
2 不捕捉Error，在当前函数增加throws声明，Error将自动抛给上层函数

• 如果最顶层函数(main函数)依然没有捕捉Error，那么程序将终止

 func test() throws {
    print("1")
    print(try divide(20, 0))
    print("2") 
}
try test()

 do {
    print(try divide(20, 0))
} catch is SomeError {
    print("SomeError")
}

4.try?、try!

可以使用try?、try!调用可能会抛出Error的函数，这样就不用去处理Error

 func test() {
    print("1")
    var result1 = try? divide(20, 10) // Optional(2), Int?
    var result2 = try? divide(20, 0) // nil
    var result3 = try! divide(20, 10) // 2, Int
    print("2")
} test()

a、b是等价的

var a = try? divide(20, 0)
var b: Int?
do {
    b = try divide(20, 0)
} catch { b = nil }

5.rethrows

rethrows表明:函数本身不会抛出错误，但调用闭包参数抛出错误，那么它会将错误向上抛

 func exec(_ fn: (Int, Int) throws -> Int, _ num1: Int, _ num2: Int) rethrows {
    print(try fn(num1, num2))
}
// Fatal error: Error raised at top level
try exec(divide, 20, 0)

6.defer

• defer语句:用来定义以任何方式(抛错误、return等)离开代码块前必须要执行的代码
• defer语句将延迟至当前作用域结束之前执行

func open(_ filename: String) -> Int { 
     print("open")
     return 0 
}
func close(_ file: Int) {
    print("close")
}

defer语句的执行顺序与定义顺序相反

func fn1() { print("fn1") }
func fn2() { print("fn2") }
func test() {
    defer { fn1() }
    defer { fn2() }
}
test()
// fn2
// fn1

func processFile(_ filename: String) throws { let file = open(filename)
defer {
        close(file)
    }
// 使用file
// ....
try divide(20, 0)
// close将会在这里调用 }
try processFile("test.txt")
// open
// close
// Fatal error: Error raised at top level

7.assert(断言)

• 很多编程语言都有断言机制:不符合指定条件就抛出运行时错误，常用于调试(Debug)阶段的条件判断
• 默认情况下，Swift的断言只会在Debug模式下生效，Release模式下会忽略

func divide(_ v1: Int, _ v2: Int) -> Int { 
    assert(v2 != 0, "除数不能为0")
    return v1 / v2
}
print(divide(20, 0))

8. fatalError

• 如果遇到严重问题，希望结束程序运行时，可以直接使用fatalError函数抛出错误(这是无法通过do-catch捕捉的错误)
• 使用了fatalError函数，就不需要再写return

 func test(_ num: Int) -> Int {
    if num >= 0 {
        return 1 
    }
fatalError("num不能小于0") }

• 在某些不得不实现、但不希望别人调用的方法，可以考虑内部使用fatalError函数

 class Person { required init() {} } 
 class Student : Person {
    required init() { 
        fatalError("don't call Student.init") 
        }
    init(score: Int) {}
}
var stu1 = Student(score: 98) 
var stu2 = Student()

Swift 访问控制

访问控制限制其他源文件和模块对你的代码的访问。这个特性允许你隐藏代码的实现细节，并指定一个偏好的接口让其他代码可以访问和使用。

在访问权限控制这块，Swift提供了5个不同的访问级别:

• open: 允许在定义实体的模块、其他模块中访问，允许其他模块进行继承、重写(open只能用在类、类成员上)
• public: 允许在定义实体的模块、其他模块中访问，不允许其他模块进行继承、重写
• internal: 只允许在定义实体的模块中访问，不允许在其他模块中访问
• fileprivate: 只允许在定义实体的源文件中访问
• private: 只允许在定义实体的封闭声明中访问

Swift 内存管理

跟OC一样，Swift也是采取基于引用计数的ARC内存管理方案(针对堆空间)

Swift的ARC中有3种引用

• 强引用(strong reference):默认情况下，引用都是强引用
• 弱引用(weak reference):通过weak定义弱引用
  • 必须是可选类型的var，因为实例销毁后，ARC会自动将弱引用设置为nil
  • ARC自动给弱引用设置nil时，不会触发属性观察器
• 无主引用(unowned reference):通过unowned定义无主引用
  • 不会产生强引用，实例销毁后仍然存储着实例的内存地址(类似于OC中的unsafe_unretained)
  • 试图在实例销毁后访问无主引用，会产生运行时错误(野指针)

1. weak、unowned的使用限制

protocol Livable : AnyObject {}
class Person {}
weak var p0: Person?
weak var p1: AnyObject?
weak var p2: Livable?
unowned var p10: Person?
unowned var p11: AnyObject?
unowned var p12: Livable?

2. Autoreleasepool

autoreleasepool {
    let p = MJPerson(age: 20, name: "Jack")
    p.run()
}

3. 循环引用(Reference Cycle)

weak、unowned 都能解决循环引用的问题，unowned 要比weak 少一些性能消耗

• 在生命周期中可能会变为 nil 的使用 weak
• 初始化赋值后再也不会变为 nil 的使用 unowned

image.png

4. 闭包的循环引用

闭包表达式默认会对用到的外层对象产生额外的强引用

• 在闭包表达式的捕获列表声明weak或unowned引用，解决循环引用问题

class Person {
    var fn: (() -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}
func test() {
    let p = Person()
    // 使用 weak 进行弱引用,在闭包内
    p.fn = {[weak p] in
        p?.run() 
    }
}
test()

5. 内存访问冲突(Conflicting Access to Memory)

内存访问冲突会在两个访问满足下列条件时发生:

• 至少一个是写入操作
• 它们访问的是同一块内存
• 它们的访问时间重叠(比如在同一个函数内)

 // 存在内存访问冲突
// Simultaneous accesses to 0x0, but modification requires exclusive access var step = 1
func increment(_ num: inout Int) { num += step }
increment(&step)

 // 解决内存访问冲突
var copyOfStep = step increment(&copyOfStep) step = copyOfStep

如果下面的条件可以满足，就说明重叠访问结构体的属性是安全的

• 你只访问实例存储属性，不是计算属性或者类属性
• 结构体是局部变量而非全局变量
• 结构体要么没有被闭包捕获要么只被非逃逸闭包捕获

 // Ok
func test() {
var tulpe = (health: 10, energy: 20) balance(&tulpe.health, &tulpe.energy)
var holly = Player(name: "Holly", health: 10, energy: 10)
balance(&holly.health, &holly.energy) }
test()

6. 指针

Swift中也有专门的指针类型，这些都被定性为“Unsafe”(不安全的)，常见的有以下4种类型

• UnsafePointer<Pointee> 类似于 const Pointee *
• UnsafeMutablePointer<Pointee> 类似于 Pointee *
• UnsafeRawPointer 类似于 const void *
• UnsafeMutableRawPointer 类似于 void *

var age = 10
func test1(_ ptr: UnsafeMutablePointer<Int>) {
    ptr.pointee += 10
}
func test2(_ ptr: UnsafePointer<Int>) { print(ptr.pointee)
}
test1(&age)
test2(&age) // 20
print(age) // 20

Swift 从OC到 Swift

1. MARK、TODO、FIXME

• // MARK: 类似于OC中的 #pragma mark
• // MARK: - 类似于OC中的 #pragma mark -
• // TODO: 用于标记未完成的任务
• // FIXME: 用于标记待修复的问题

image.png

2. 条件编译

// 操作系统:macOS\iOS\tvOS\watchOS\Linux\Android\Windows\FreeBSD
#if os(macOS) || os(iOS)
// CPU架构:i386\x86_64\arm\arm64
#elseif arch(x86_64) || arch(arm64)
// swift版本
#elseif swift(<5) && swift(>=3)
// 模拟器
#elseif targetEnvironment(simulator)
// 可以导入某模块
#elseif canImport(Foundation)

#else

#endif 

3. 打印

func log<T>(_ msg: T,
            file: NSString = #file,
            line: Int = #line,
            fn: String = #function) {
    #if DEBUG
    let prefix = "\(file.lastPathComponent)_\(line)_\(fn):"
    print(prefix, msg)
    #endif
}

4. 系统版本检测

if #available(iOS 10, macOS 10.12, *) {
    // 对于iOS平台，只在iOS10及以上版本执行
    // 对于macOS平台，只在macOS 10.12及以上版本执行 // 最后的*表示在其他所有平台都执行
}

5. API可用性说明

@available(iOS 10, macOS 10.15, *)
class Person {}
struct Student {
    @available(*, unavailable, renamed: "study")
    func study_() {}
    func study() {}
    @available(iOS, deprecated: 11)
    @available(macOS, deprecated: 10.12)
    func run() {}
}

// 更多用法参考:https://docs.swift.org/swift-book/ReferenceManual/Attributes.html

6. iOS程序的入口

在AppDelegate上面默认有个@UIApplicationMain标记，这表示

• 编译器自动生成入口代码(main函数代码)，自动设置AppDelegate为APP的代理

也可以删掉@UIApplicationMain，自定义入口代码:新建一个main.swift文件

image.png

7. Swift调用OC

• 新建1个桥接头文件，文件名格式默认为:{targetName}-Bridging-Header.h
• 在{targetName}-Bridging-Header.h 文件中#import OC需要暴露给Swift的内容

Swift调用OC – @_silgen_name
如果C语言暴露给Swift的函数名跟Swift中的其他函数名冲突了
可以在Swift中使用 @_silgen_name 修改C函数名

 // C语言
int sum(int a, int b) {
    return a + b; 
}

 // Swift
@_silgen_name("sum") func swift_sum(_ v1: Int32, _ v2: Int32) -> Int32
print(swift_sum(10, 20)) // 30
print(sum(10, 20)) // 30
 

8 . OC调用Swift

Xcode已经默认生成一个用于OC调用Swift的头文件，文件名格式是: {targetName}-Swift.h

• Swift暴露给OC的类最终继承自NSObject
• 使用@objc修饰需要暴露给OC的成员
• 使用@objcMembers修饰类
  • 代表默认所有成员都会暴露给OC(包括扩展中定义的成员)
  • 最终是否成功暴露，还需要考虑成员自身的访问级别
• 可以通过@objc 重命名Swift暴露给OC的符号名(类名、属性名、函数名等)

9. 选择器(Selector)

Swift中依然可以使用选择器，使用#selector(name)定义一个选择器
必须是被@objcMembers或@objc修饰的方法才可以定义选择器

@objcMembers class Person: NSObject {
    func test1(v1: Int) { print("test1") }
    func test2(v1: Int, v2: Int) { print("test2(v1:v2:)") }
    func test2(_ v1: Double, _ v2: Double) { print("test2(_:_:)") }
    func run() {
        perform(#selector(test1))
        perform(#selector(test1(v1:)))
        perform(#selector(test2(v1:v2:)))
        perform(#selector(test2(_:_:)))
        perform(#selector(test2 as (Double, Double) -> Void))
    }
}

10. String

Swift的字符串类型String，跟OC的NSString，在API设计上还是有较大差异

// String创建方式
var emptyString = ""
var emptyString1 = String()

// 拼接
var str = ""

// 方式1.拼接字符
str.append("H")
// 方式2.拼接字符串
str.append("ello")
// 方式3 + 拼接
str  += "world!"
// 方式4: 插值表达式
str = "\(str) ,Welcome to Swift"

// 字符串长度
print(str.count)


var str = "123456"
// 前缀
print(str.hasPrefix("123"))
// 后缀
print(str.hasSuffix("456"))

字符串插入与删除

var str = "1_2"
// 1_2_
str.insert("_", at: str.endIndex)
// 1_2_3_4
str.insert(contentsOf: "3_4", at: str.endIndex)
// 1666_2_3_4
str.insert(contentsOf: "666", at: str.index(after: str.startIndex))
// 1666_2_3_8884
str.insert(contentsOf: "888", at: str.index(before: str.endIndex))
// 1666hello_2_3_8884
str.insert(contentsOf: "hello", at: str.index(str.startIndex, offsetBy: 4))


// 666hello_2_3_8884
str.remove(at: str.firstIndex(of: "1")!)
// hello_2_3_8884
str.removeAll { $0 == "6" }
var range = str.index(str.endIndex, offsetBy: -4)..<str.index(before: str.endIndex) // hello_2_3_4
str.removeSubrange(range)

Substring

String可以通过下标、 prefix、 suffix等截取子串，子串类型不是String，而是Substring

var str = "1_2_3_4_5"
// 1_2
var substr1 = str.prefix(3)
// 4_5
var substr2 = str.suffix(3)
// 1_2
var range = str.startIndex..<str.index(str.startIndex, offsetBy: 3) var substr3 = str[range]
// 最初的String，1_2_3_4_5 print(substr3.base)
// Substring -> String
var str2 = String(substr3)

String 与 Character

for c in "jack" { 
    // c是Character类型 
    print(c)
}
var str = "jack"
// c是Character类型
var c = str[str.startIndex]

String相关的协议

BidirectionalCollection 协议包含的部分内容

• startIndex 、 endIndex 属性、index 方法
• String、Array 都遵守了这个协议

RangeReplaceableCollection 协议包含的部分内容

• append、insert、remove 方法
• String、Array 都遵守了这个协议

Dictionary、Set 也有实现上述协议中声明的一些方法，只是并没有遵守上述协议

多行String

let str = """ 1
"2" 3
'4' """

String 与 NSString

String 与 NSString 之间可以随时随地桥接转换

• 如果你觉得String的API过于复杂难用，可以考虑将String转为NSString

var str1: String = "jack"
var str2: NSString = "rose"
var str3 = str1 as NSString
var str4 = str2 as String
// ja
var str5 = str3.substring(with: NSRange(location: 0, length: 2)) print(str5)

11. Swift、OC桥接转换表

image.png

12. 只能被class继承的协议

被@objc 修饰的协议，还可以暴露给OC去遵守实现

protocol Runnable1: AnyObject {}
protocol Runnable2: class {}
@objc protocol Runnable3 {}

13. 可选协议

可以通过@objc 定义可选协议，这种协议只能被class 遵守

 @objc protocol Runnable {
    func run1()
    @objc optional func run2()
func run3() }
class Dog: Runnable {
    func run3() { print("Dog run3") }
    func run1() { print("Dog run1") }
}
var d = Dog()
d.run1() // Dog run1
d.run3() // Dog run3
 

14. dynamic

被 @objc dynamic 修饰的内容会具有动态性，比如调用方法会走runtime那一套流程

 class Dog: NSObject {
    @objc dynamic func test1() {}
    func test2() {}
}
var d = Dog()
d.test1()
d.test2()

15. KVC\KVO

Swift 支持 KVC \ KVO 的条件

• 属性所在的类、监听器最终继承自 NSObject
• 用 @objc dynamic 修饰对应的属性

 class Observer: NSObject {
override func observeValue(forKeyPath keyPath: String?,
                               of object: Any?,
                               change: [NSKeyValueChangeKey : Any]?,
                               context: UnsafeMutableRawPointer?) {
print("observeValue", change?[.newKey] as Any) }
}


class Person: NSObject {
    @objc dynamic var age: Int = 0
    var observer: Observer = Observer()
    override init() {
        super.init()
        self.addObserver(observer,
                         forKeyPath: "age",
                         options: .new,
                         context: nil)
}
deinit {
        self.removeObserver(observer,
                            forKeyPath: "age")
} }
var p = Person()
// observeValue Optional(20)
p.age = 20
// observeValue Optional(25)
p.setValue(25, forKey: "age")

16. block方式的KVO

 class Person: NSObject {
    @objc dynamic var age: Int = 0
    var observation: NSKeyValueObservation?
    override init() {
        super.init()
        observation = observe(\Person.age, options: .new) {
            (person, change) in
            print(change.newValue as Any)
        }
} }
var p = Person()
// Optional(20)
p.age = 20
// Optional(25)
p.setValue(25, forKey: "age")

17. 关联对象(Associated Object)

• 在Swift中，class依然可以使用关联对象
• 默认情况，extension不可以增加存储属性
• 借助关联对象，可以实现类似extension为class增加存储属性的效果

class Person {}
extension Person {
private static var AGE_KEY: Void? var age: Int {
get {
(objc_getAssociatedObject(self, &Self.AGE_KEY) as? Int) ?? 0
} set {
objc_setAssociatedObject(self, &Self.AGE_KEY,
} }
}

18. 资源名管理

这种做法实际上是参考了Android的资源名管理方式

let img = UIImage(named: "logo") 
let btn = UIButton(type: .custom)
btn.setTitle("添加", for: .normal) 
performSegue(withIdentifier: "login_main", sender: self)

let img = UIImage(R.image.logo) 
let btn = UIButton(type: .custom)
btn.setTitle(R.string.add, for: .normal)
performSegue(withIdentifier: R.segue.login_main, sender: self) 

enum R {
    enum string: String {
case add = "添加" }
    enum image: String {
        case logo
    }
    enum segue: String {
        case login_main
    }
}

extension UIImage {
    convenience init?(_ name: R.image) {
        self.init(named: name.rawValue) }
}
extension UIViewController {
    func performSegue(withIdentifier identifier: R.segue, sender: Any?) {
        performSegue(withIdentifier: identifier.rawValue, sender: sender) }
}
extension UIButton {
    func setTitle(_ title: R.string, for state: UIControl.State) {
        setTitle(title.rawValue, for: state) }
}

19. 资源名管理的其他思路

image.png

更多优秀的思路参考
https://github.com/mac-cain13/R.swift
https://github.com/SwiftGen/SwiftGen

20. 多线程开发 – 异步

class Asyncs: NSObject {
    
    public typealias Task = () -> Void
    
    public static func async( task: @escaping Task){
        _async(task)
    }
    
    public static func async(_ task: @escaping Task , _ mainTask: @escaping Task){
        _async(task ,mainTask)
    }
    
    private static func _async(_ task: @escaping Task,
                               _ mainTask: Task? = nil) {
        let item = DispatchWorkItem(block: task)
        DispatchQueue.global().async(execute: item)
        if let main = mainTask {
            item.notify(queue: DispatchQueue.main, execute: main)
        }
    }
    
    @discardableResult
    public static func delay(_ seconds: Double,
                             _ block: @escaping Task) -> DispatchWorkItem {
        let item = DispatchWorkItem(block: block)
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + seconds,
                                      execute: item)
        return item
    }
    
    @discardableResult
    public static func asyncDelay(_ seconds: Double,
                                  _ task: @escaping Task) -> DispatchWorkItem {
        return _asyncDelay(seconds, task)
    }
    @discardableResult
    public static func asyncDelay(_ seconds: Double,
                                  _ task: @escaping Task,
                                  _ mainTask: @escaping Task) -> DispatchWorkItem { return _asyncDelay(seconds, task, mainTask)
    }
    private static func _asyncDelay(_ seconds: Double,
                                    _ task: @escaping Task,
                                    _ mainTask: Task? = nil) -> DispatchWorkItem {
        let item = DispatchWorkItem(block: task)
        DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + seconds, execute: item)
        if let main = mainTask {
            item.notify(queue: DispatchQueue.main, execute: main)
        }
        return item
    }
}

21. 多线程开发 – once

dispatch_once在Swift中已被废弃，取而代之

• 可以用类型属性或者全局变量\常量
• 默认自带 lazy + dispatch_once 效果

class Singleton {    
    static let sharedInstance = Singleton()
    private init(){
        print("init")
    }
}

22. 多线程开发 – 加锁

//gcd信号量

class Cache {
    private static var data = [String: Any]()
    private static var lock = DispatchSemaphore(value: 1) static func set(_ key: String, _ value: Any) {
        lock.wait()
        defer { lock.signal() }
        data[key] = value
    }
}

// Foundation
private static var lock = NSLock()
static func set(_ key: String, _ value: Any) {
    lock.lock()
    defer { lock.unlock() }
}

private static var lock = NSRecursiveLock() static func set(_ key: String, _ value: Any) {
    lock.lock()
    defer { lock.unlock() }
}