Swift 之访问控制、内存管理、字面量、模式匹配

1、访问控制

Swift 提供了5个不同的访问级别：open > public > internal > fileprivate > private
open：允许在定义实体的模块、其他模块中访问，允许其他模块进行继承、重写（open只能用在类、类成员上）。
public：允许在定义实体的模块、其他模块中访问，不允许其他模块进行继承、重写。
internal：只允许在定义实体的模块中访问，不允许在其他模块中访问。绝大部分实体默认都是该级别。
fileprivate：只允许在定义实体的源文件中访问。
private：只允许在定义实体的封闭声明中访问。

使用规则：
一个实体不可以被更低访问级别的实体定义，比如：
变量\常量类型 ≥ 变量\常量
参数类型、返回值类型 ≥ 函数
父类 ≥ 子类
父协议 ≥ 子协议
原类型 ≥ typealias
原始值类型、关联值类型 ≥ 枚举类型
定义类型A时用到的其他类型 ≥ 类型A

元组：
元组类型的访问级别是所有成员类型最低的那个。

泛型类型：
泛型类型的访问级别是类型的访问级别以及所有泛型类型参数的访问级别中最低的那个。

成员、嵌套类型：
类型的访问级别会影响成员（属性、方法、初始化器、下标）、嵌套类型的默认访问级别。若类型为 private 或 fileprivate，那么成员\嵌套类型默认也是 private 或 fileprivate；若类型为 internal 或 public，那么成员\嵌套类型默认是 internal。

成员的重写：
1、子类重写成员的访问级别必须 ≥ 子类的访问级别/父类被重写成员的访问级别。
2、父类的成员不能被成员作用域外定义的子类重写。

全局作用域：
直接在全局作用域下定义的 private 等价于 fileprivate。

getter、setter：
getter、setter 默认自动接收它们所属环境的访问级别。也可以给 setter 单独设置一个比 getter 更低的访问级别，用以限制写的权限。

初始化器：
1、如果一个 public 类想在另一个模块调用编译生成的默认无参初始化器，必须显式提供 public 的无参初始化器。因为 public 类的默认初始化器是 internal 级别。
2、required 初始化器 ≥ 它的默认访问级别。
3、如果结构体有 private\fileprivate 的存储实例属性，那么它的成员初始化器也是 private\fileprivate，否则默认就是 internal。

枚举类型的 case：
1、不能给 enum 的每个 case 单独设置访问级别
2、每个 case 自动接收 enum 的访问级别，enum 为 public 时 case 也是 public。

协议：
1、协议中定义的要求自动接收协议的访问级别，不能单独设置访问级别。public 协议定义的要求也是 public。
2、协议实现的访问级别必须 ≥ 类型的访问级别 / 协议的访问级别。

扩展：
1、如果有显式设置扩展的访问级别，扩展添加的成员自动接收扩展的访问级别。如果没有显式设置扩展的访问级别，扩展添加的成员的默认访问级别，跟直接在类型中定义的成员一样。
2、可以单独给扩展添加的成员设置访问级别。
3、不能给用于遵守协议的扩展显式设置扩展的访问级别。
4、在同一文件中的扩展，可以写成类似多个部分的类型声明。在原本的声明中声明一个私有成员，可以在同一文件的扩展中访问它。在扩展中声明一个私有成员，可以在同一文件的其他扩展中、原本声明中访问它。

2、内存管理

跟 OC 一样，Swift 也是采取基于引用计数的 ARC 内存管理方案（针对堆空间）。
Swift 的 ARC 中有3种引用
1、强引用（strong reference）：默认情况下，引用都是强引用。
2、弱引用（weak reference）：通过 weak 定义弱引用。必须是可选类型的 var，因为实例销毁后，ARC 会自动将弱引用设置为 nil。ARC 自动给弱引用设置 nil 时，不会触发属性观察器。
3、无主引用（unowned reference）：通过 unowned 定义无主引用。它不会产生强引用，实例销毁后仍然存储着实例的内存地址（类似于OC中的 unsafe_unretained）。试图在实例销毁后访问无主引用，会产生运行时错误（野指针）。

weak、unowned 的使用条件：只能用在类实例上面。

循环引用：
weak、unowned 都能解决循环引用的问题，unowned 要比 weak 少一些性能消耗。在生命周期中可能会变为 nil 的使用 weak。初始化赋值后再也不会变为 nil 的使用 unowned。

闭包的循环引用：
1、闭包表达式默认会对用到的外层对象产生额外的强引用（对外层对象进行了 retain 操作）。在闭包表达式的捕获列表声明 weak 或 unowned 引用，解决循环引用问题。
2、如果想在定义闭包属性的同时引用 self，这个闭包必须是 lazy 的（因为在实例初始化完毕之后才能引用 self）。
3、如果 lazy 属性是闭包调用的结果，那么不用考虑循环引用的问题（因为闭包调用后，闭包的生命周期就结束了）。

@escaping：
1、非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数。
非逃逸闭包：闭包调用发生在函数结束前，闭包调用在函数作用域内。
逃逸闭包：闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过 @escaping 声明。
2、逃逸闭包不可以捕获 inout 参数。

内存访问冲突：
内存访问冲突会在两个访问满足下列条件时发生：
1、至少一个是写入操作。
2、它们访问的是同一块内存。
3、它们的访问时间重叠（比如在同一个函数内）。

// 不存在内存访问冲突
func plus(_ num: inout Int) -> Int { num + 1 }
var number = 1
number = plus(&number)

// 存在内存访问冲突
// 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(©OfStep)
step = copyOfStep

func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}
var num1 = 42
var num2 = 30
balance(&num1, &num2) // OK
balance(&num1, &num1) // Error

struct Player {
    var name: String
    var health: Int
    var energy: Int
    mutating func shareHealth(with teammate: inout Player) {
        balance(&teammate.health, &health)
    }
}
var oscar = Player(name: "Oscar", health: 10, energy: 10)
var maria = Player(name: "Maria", health: 5, energy: 10)
oscar.shareHealth(with: &maria) // OK
oscar.shareHealth(with: &oscar) // Error

var tulpe = (health: 10, energy: 20)
// Error
balance(&tulpe.health, &tulpe.energy)
var holly = Player(name: "Holly", health: 10, energy: 10)
// Error
balance(&holly.health, &holly.energy)

如果下面的条件可以满足，说明重叠访问结构体的属性是安全的：
1、只访问实例存储属性，不是计算属性或者类属性。
2、结构体是局部变量而非全局变量。
3、结构体要么没有被闭包捕获要么只被非逃逸闭包捕获。

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

指针
1、Swift 中也有专门的指针类型，这些都被定性为 Unsafe（不安全的），常见的有以下4种类型:
UnsafePointer 类似于 const Pointee *。
UnsafeMutablePointer 类似于 Pointee *。
UnsafeRawPointer 类似于 const void *。
UnsafeMutableRawPointer 类似于 void *。

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

var age = 10
func test3(_ ptr: UnsafeMutableRawPointer) {
    ptr.storeBytes(of: 20, as: Int.self)
}
func test4(_ ptr: UnsafeRawPointer) {
    print(ptr.load(as: Int.self))
}
test3(&age)
test4(&age) // 20
print(age) // 20

2、应用

var arr = NSArray(objects: 11, 22, 33, 44)
arr.enumerateObjects { (obj, idx, stop) in
    print(idx, obj)
    if idx == 2 { // 下标为2就停止遍历
        stop.pointee = true
    }
}

var arr = NSArray(objects: 11, 22, 33, 44)
for (idx, obj) in arr.enumerated() {
    print(idx, obj)
    if idx == 2 {
        break
    }
}

3、获得指向某个变量的指针

var age = 11
var ptr1 = withUnsafeMutablePointer(to: &age) { $0 }
var ptr2 = withUnsafePointer(to: &age) { $0 }
ptr1.pointee = 22
print(ptr2.pointee) // 22
print(age) // 22

var ptr3 = withUnsafeMutablePointer(to: &age) { UnsafeMutableRawPointer($0) }
var ptr4 = withUnsafePointer(to: &age) { UnsafeRawPointer($0) }
ptr3.storeBytes(of: 33, as: Int.self)
print(ptr4.load(as: Int.self)) // 33
print(age) // 33

4、获得指向堆空间实例的指针

class Person {}
var person = Person()
var ptr = withUnsafePointer(to: &person) { UnsafeRawPointer($0) }
var heapPtr = UnsafeRawPointer(bitPattern: ptr.load(as: UInt.self))
print(heapPtr!)

5、创建指针

var ptr = UnsafeRawPointer(bitPattern: 0x100001234)

// 创建
var ptr = malloc(16)
// 存
ptr?.storeBytes(of: 11, as: Int.self)
ptr?.storeBytes(of: 22, toByteOffset: 8, as: Int.self)
// 取
print((ptr?.load(as: Int.self))!) // 11
print((ptr?.load(fromByteOffset: 8, as: Int.self))!) // 22
// 销毁
free(ptr)

var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
ptr.storeBytes(of: 11, as: Int.self)
ptr.advanced(by: 8).storeBytes(of: 22, as: Int.self)
print(ptr.load(as: Int.self)) // 11
print(ptr.advanced(by: 8).load(as: Int.self)) // 22
ptr.deallocate()
var ptr = UnsafeRawPointer(bitPattern: 0x100001234)

var ptr = UnsafeMutablePointer.allocate(capacity: 3)
ptr.initialize(to: 11)
ptr.successor().initialize(to: 22)
ptr.successor().successor().initialize(to: 33)

print(ptr.pointee) // 11
print((ptr + 1).pointee) // 22
print((ptr + 2).pointee) // 33

print(ptr[0]) // 11
print(ptr[1]) // 22
print(ptr[2]) // 33

ptr.deinitialize(count: 3)
ptr.deallocate()

class Person {
    var age: Int
    var name: String
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    deinit { print(name, "deinit") }
}

var ptr = UnsafeMutablePointer.allocate(capacity: 3)
ptr.initialize(to: Person(age: 10, name: "Jack"))
(ptr + 1).initialize(to: Person(age: 11, name: "Rose"))
(ptr + 2).initialize(to: Person(age: 12, name: "Kate"))
// Jack deinit
// Rose deinit
// Kate deinit
ptr.deinitialize(count: 3)
ptr.deallocate()

6、指针转换

var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
ptr.assumingMemoryBound(to: Int.self).pointee = 11
(ptr + 8).assumingMemoryBound(to: Double.self).pointee = 22.0
print(unsafeBitCast(ptr, to: UnsafePointer.self).pointee) // 11
print(unsafeBitCast(ptr + 8, to: UnsafePointer.self).pointee) // 22.0
ptr.deallocate()

unsafeBitCast 是忽略数据类型的强制转换，不会因为数据类型的变化而改变原来的内存数据。

class Person {}
var person = Person()
var ptr = unsafeBitCast(person, to: UnsafeRawPointer.self)
print(ptr)

3、字面量

常见字面量（Literal）的默认类型：
public typealias IntegerLiteralType = Int
public typealias FloatLiteralType = Double
public typealias BooleanLiteralType = Bool
public typealias StringLiteralType = String

// 可以通过typealias修改字面量的默认类型
typealias FloatLiteralType = Float
typealias IntegerLiteralType = UInt8
var age = 10 // UInt8
var height = 1.68 // Float

Swift 自带的绝大部分类型，都支持直接通过字面量进行初始化：Bool、Int、Float、Double、String、Array、Dictionary、Set、Optional 等。Swift 自带类型之所以能够通过字面量初始化，是因为它们遵守了对应的协议。
Bool : ExpressibleByBooleanLiteral
Int : ExpressibleByIntegerLiteral
Float、Double : ExpressibleByIntegerLiteral、ExpressibleByFloatLiteral
Dictionary : ExpressibleByDictionaryLiteral
String : ExpressibleByStringLiteral
Array、Set : ExpressibleByArrayLiteral
Optional : ExpressibleByNilLiteral

字面量协议应用

extension Int : ExpressibleByBooleanLiteral {
    public init(booleanLiteral value: Bool) { self = value ? 1 : 0 }
}
var num: Int = true
print(num) // 1

class Student : ExpressibleByIntegerLiteral, ExpressibleByFloatLiteral, ExpressibleByStringLiteral, CustomStringConvertible {
    var name: String = ""
    var score: Double = 0
    required init(floatLiteral value: Double) { self.score = value }
    required init(integerLiteral value: Int) { self.score = Double(value) }
    required init(stringLiteral value: String) { self.name = value }
    required init(unicodeScalarLiteral value: String) { self.name = value }
    required init(extendedGraphemeClusterLiteral value: String) { self.name = value }
    var description: String { "name=\(name),score=\(score)" }
}
var stu: Student = 90
print(stu) // name=,score=90.0
stu = 98.5
print(stu) // name=,score=98.5
stu = "Jack"
print(stu) // name=Jack,score=0.0

struct Point {
    var x = 0.0, y = 0.0
}
extension Point : ExpressibleByArrayLiteral, ExpressibleByDictionaryLiteral {
    init(arrayLiteral elements: Double...) {
        guard elements.count > 0 else { return }
        self.x = elements[0]
        guard elements.count > 1 else { return }
        self.y = elements[1]
    }
    init(dictionaryLiteral elements: (String, Double)...) {
        for (k, v) in elements {
            if k == "x" { self.x = v } else if k == "y" { self.y = v }
        }
    }
}
var p: Point = [10.5, 20.5]
print(p) // Point(x: 10.5, y: 20.5)
p = ["x" : 11, "y" : 22]
print(p) // Point(x: 11.0, y: 22.0)

4、模式匹配

模式是用于匹配的规则，比如 switch 的 case、捕捉错误的 catch、if\guard\while\for 语句的条件等。
Swift中的模式有：
通配符模式（Wildcard Pattern）
标识符模式（Identifier Pattern）
值绑定模式（Value-Binding Pattern）
元组模式（Tuple Pattern）
枚举 Case 模式（Enumeration Case Pattern）
可选模式（Optional Pattern）
类型转换模式（Type-Casting Pattern）
表达式模式（Expression Pattern）

通配符模式（Wildcard Pattern）：
_ 匹配任何值
_? 匹配非 nil 值

enum Life {
    case human(name: String, age: Int?)
    case animal(name: String, age: Int?)
}
func check(_ life: Life) {
    switch life {
        case .human(let name, _):
        print("human", name)
    case .animal(let name, _?):
        print("animal", name)
    default:
        print("other")
    }
}
check(.human(name: "Rose", age: 20)) // human Rose
check(.human(name: "Jack", age: nil)) // human Jack
check(.animal(name: "Dog", age: 5)) // animal Dog
check(.animal(name: "Cat", age: nil)) // other

标识符模式（Identifier Pattern）
给对应的变量、常量名赋值

var age = 10
let name = "jack"

值绑定模式（Value-Binding Pattern）

let point = (3, 2)
switch point {
case let (x, y):
    print("The point is at (\(x), \(y)).")
}

元组模式（Tuple Pattern）

let points = [(0, 0), (1, 0), (2, 0)]
for (x, _) in points {
    print(x)
}

let name: String? = "jack"
let age = 18
let info: Any = [1, 2]
switch (name, age, info) {
    case (_?, _ , _ as String):
        print("case")
    default:
        print("default")
} // default

var scores = ["jack" : 98, "rose" : 100, "kate" : 86]
for (name, score) in scores {
    print(name, score)
}

枚举 Case 模式（Enumeration Case Pattern）
if case 语句等价于只有1个 case 的 switch 语句

let age = 2
// 原来的写法
if age >= 0 && age <= 9 {
    print("[0, 9]")
}
// 枚举Case模式
if case 0...9 = age {
    print("[0, 9]")
}
guard case 0...9 = age else { return }
print("[0, 9]")

switch age {
    case 0...9: print("[0, 9]")
    default: break
}

let ages: [Int?] = [2, 3, nil, 5]
for case nil in ages {
    print("有nil值")
    break
} // 有nil值

let points = [(1, 0), (2, 1), (3, 0)]
for case let (x, 0) in points {
    print(x)
} // 1 3

可选模式（Optional Pattern）

let age: Int? = 42
if case .some(let x) = age { print(x) }
if case let x? = age { print(x) }

let ages: [Int?] = [nil, 2, 3, nil, 5]
for case let age? in ages {
    print(age)
} // 2 3 5

let ages: [Int?] = [nil, 2, 3, nil, 5]
for item in ages {
    if let age = item {
        print(age)
    }
} // 跟上面的for，效果是等价的

func check(_ num: Int?) {
    switch num {
        case 2?: print("2")
        case 4?: print("4")
        case 6?: print("6")
        case _?: print("other")
        case _: print("nil")
    }
}
check(4) // 4
check(8) // other
check(nil) // nil

类型转换模式（Type-Casting Pattern）

let num: Any = 6
switch num {
    case is Int:
        // 编译器依然认为num是Any类型
        print("is Int", num)
    //case let n as Int:
        // print("as Int", n + 1)
    default:
        break
}

class Animal { func eat() { print(type(of: self), "eat") } }
class Dog : Animal { func run() { print(type(of: self), "run") } }
class Cat : Animal { func jump() { print(type(of: self), "jump") } }
func check(_ animal: Animal) {
    switch animal {
    case let dog as Dog:
        dog.eat()
        dog.run()
    case is Cat:
        animal.eat()
    default: break
    }
}
// Dog eat
// Dog run
check(Dog())
// Cat eat
check(Cat())

表达式模式（Expression Pattern）
表达式模式用在 case 中

let point = (1, 2)
switch point {
    case (0, 0):
        print("(0, 0) is at the origin.")
    case (-2...2, -2...2):
        print("(\(point.0), \(point.1)) is near the origin.")
    default:
        print("The point is at (\(point.0), \(point.1)).")
} // (1, 2) is near the origin.

自定义表达式模式
可以通过重载运算符，自定义表达式模式的匹配规则。

struct Student {
    var score = 0, name = ""
    static func ~= (pattern: Int, value: Student) -> Bool { value.score >= pattern }
    static func ~= (pattern: ClosedRange, value: Student) -> Bool { pattern.contains(value.score) }
    static func ~= (pattern: Range, value: Student) -> Bool { pattern.contains(value.score) }
}

var stu = Student(score: 75, name: "Jack")
switch stu {
case 100: print(">= 100")
case 90: print(">= 90")
case 80..<90: print("[80, 90)")
case 60...79: print("[60, 79]")
case 0: print(">= 0")
default: break
} // [60, 79]

if case 60 = stu {
    print(">= 60")
} // >= 60

var info = (Student(score: 70, name: "Jack"), "及格")
switch info {
case let (60, text): print(text)
default: break
} // 及格

extension String {
    static func ~= (pattern: (String) -> Bool, value: String) -> Bool {
        pattern(value)
    }
}
func hasPrefix(_ prefix: String) -> ((String) -> Bool) { { $0.hasPrefix(prefix) } }
func hasSuffix(_ suffix: String) -> ((String) -> Bool) { { $0.hasSuffix(suffix) } }
var str = "jack"
switch str {
case hasPrefix("j"), hasSuffix("k"):
    print("以j开头，以k结尾")
default: break
} // 以j开头，以k结尾

func isEven(_ i: Int) -> Bool { i % 2 == 0 }
func isOdd(_ i: Int) -> Bool { i % 2 != 0 }
extension Int {
    static func ~= (pattern: (Int) -> Bool, value: Int) -> Bool {
        pattern(value)
    }
}

var age = 9
switch age {
case isEven:
    print("偶数")
case isOdd:
    print("奇数")
default:
    print("其他")
}

prefix operator ~>
prefix operator ~>=
prefix operator ~<
prefix operator ~<=
prefix func ~> (_ i: Int) -> ((Int) -> Bool) { { $0 > i } }
prefix func ~>= (_ i: Int) -> ((Int) -> Bool) { { $0 >= i } }
prefix func ~< (_ i: Int) -> ((Int) -> Bool) { { $0 < i } }
prefix func ~<= (_ i: Int) -> ((Int) -> Bool) { { $0 <= i } }

var age = 9
switch age {
case ~>=0:
    print("1")
case ~>10:
    print("2")
default: break
} // [0, 10]

where
可以使用 where 为模式匹配增加匹配条件

var data = (10, "Jack")
switch data {
case let (age, _) where age > 10:
    print(data.1, "age>10")
case let (age, _) where age > 0:
    print(data.1, "age>0")
default: break
}

var ages = [10, 20, 44, 23, 55]
for age in ages where age > 30 {
    print(age)
} // 44 55

protocol Stackable { associatedtype Element }
protocol Container {
    associatedtype Stack : Stackable where Stack.Element : Equatable
}

func equal(_ s1: S1, _ s2: S2) -> Bool where S1.Element == S2.Element, S1.Element : Hashable {
    return false
}

extension Container where Self.Stack.Element : Hashable { }

注：

方法也可以像函数那样，赋值给一个 let 或者 var。

struct Person {
    var age: Int
    func run(_ v: Int) { print("func run", age, v) }
    static func run(_ v: Int) { print("static func run", v) }
}

let fn1 = Person.run
fn1(10) // static func run 10
let fn2: (Int) -> () = Person.run
fn2(20) // static func run 20
let fn3: (Person) -> ((Int) -> ()) = Person.run
fn3(Person(age: 18))(30) // func run 18 30