image.png

Swift 協議

1.協議介紹

協議可以用來定義方法、屬性、下標的聲明，協議可以被枚舉、結構體、類遵守(多個協議之間用逗號隔開)

// 創(chuàng)建協議
  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()

 // 創(chuàng)建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 中綴運算符 : 優(yōu)先級組

precedencegroup 優(yōu)先級組 {
    associativity: 結合性(left\right\none)
    higherThan: 比誰的優(yōu)先級高
    lowerThan: 比誰的優(yōu)先級低
    assignment: true代表在可選鏈操作中擁有跟賦值運算符一樣的優(yōu)先級
}

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

Swift 錯誤處理

開發(fā)過程常見的錯誤

• 語法錯誤(編譯報錯)
• 邏輯錯誤
• 運行時錯誤(可能會導致閃退，一般也叫做異常)

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等)離開代碼塊前必須要執(zhí)行的代碼
• defer語句將延遲至當前作用域結束之前執(zhí)行

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

defer語句的執(zhí)行順序與定義順序相反

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 訪問控制

訪問控制限制其他源文件和模塊對你的代碼的訪問。這個特性允許你隱藏代碼的實現細節(jié)，并指定一個偏好的接口讓其他代碼可以訪問和使用。

在訪問權限控制這塊，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時，不會觸發(fā)屬性觀察器
• 無主引用(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. 循環(huán)引用(Reference Cycle)

weak、unowned 都能解決循環(huán)引用的問題，unowned 要比weak 少一些性能消耗

• 在生命周期中可能會變?yōu)?nil 的使用 weak
• 初始化賦值后再也不會變?yōu)?nil 的使用 unowned

image.png

4. 閉包的循環(huán)引用

閉包表達式默認會對用到的外層對象產生額外的強引用

• 在閉包表達式的捕獲列表聲明weak或unowned引用，解決循環(huán)引用問題

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)

內存訪問沖突會在兩個訪問滿足下列條件時發(fā)生:

• 至少一個是寫入操作
• 它們訪問的是同一塊內存
• 它們的訪問時間重疊(比如在同一個函數內)

 // 存在內存訪問沖突
// 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及以上版本執(zhí)行
    // 對于macOS平臺，只在macOS 10.12及以上版本執(zhí)行 // 最后的*表示在其他所有平臺都執(zhí)行
}

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創(chuàng)建方式
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 修飾的內容會具有動態(tài)性，比如調用方法會走runtime那一套流程

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

15. KVC\KVO

Swift 支持 KVC \ KVO 的條件

• 屬性所在的類、監(jiān)聽器最終繼承自 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

更多優(yōu)秀的思路參考
https://github.com/mac-cain13/R.swift
https://github.com/SwiftGen/SwiftGen

20. 多線程開發(fā) – 異步

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. 多線程開發(fā) – once

dispatch_once在Swift中已被廢棄，取而代之

• 可以用類型屬性或者全局變量\常量
• 默認自帶 lazy + dispatch_once 效果

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

22. 多線程開發(fā) – 加鎖

//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() }
}