- 使用 isKnownUniquelyReferenced 方法检查一个类的实例是不是唯一的引用，如果是，我们就不需要对结构体实例进行复制，如果不是，说明对象被不同的结构体共享，这时对它进行更改就需要进行复制
- 在Swift中采用的优化方式叫做写时复制技术，简单的说就是，只有当一个结构体发生了写入行为时才会有复制行为。具体的做法就是，在结构体内部用一个引用类型来存储实际的数据，在不进行写入操作的普通传递过程中，都是将内部的reference的应用计数+1，在进行写入操作时，对内部的reference做一次copy操作用来存储新的数据，防止和之前的reference产生意外的数据共享。
- #file 用于获取当前文件文件名
- #line 用于获取当前行号
- #column 用于获取当前列编号
- #function 用于获取当前函数名
required 是 Swift 中用于类的初始化方法的一个修饰符。它的主要作用是确保子类也必须实现这个初始化方法。这在涉及到协议的初始化方法时尤为重要，因为协议中的初始化方法无法被自动继承。
- 使用值类型传递参数，直接修改值类型的值
func swap( a: inout Int, b: inout Int) {
let temp = a
a = b
b = temp
}
var a = 1
var b = 2
print(a, b)// 1 2
swap(a: &a, b: &b)
print(a, b)// 2 1
var mutableArray = [1,2,3]
for _ in mutableArray {
mutableArray.removeLast()
}
在每次迭代时，for-in 循环会遍历最初确定的元素。尽管数组在每次迭代中被修改，但循环依然会按照原始的长度（3 次迭代）进行。这是因为 for-in 在开始时决定了要遍历的元素，而不是在每次迭代时重新计算。
函数返回值 是协议的时候可以直接使用some关键字标记该协议，译器可以根据返回值进行类型推断得到具体类型，但是不能是多个不同类型否则编译器报错
- 基本语法
- 变量和常量 (
var和let) - 注释 (
//和/* */) - 操作符（算术、比较、逻辑、赋值等）
- 字符串插值
- 变量和常量 (
-
解释
let和var的区别？let用于定义常量，一旦赋值后不可更改。var用于定义变量，可以在定义后更改其值。
-
如何在 Swift 中进行字符串插值？
- 使用
\()在字符串中插入变量或表达式。
let name = "World" let greeting = "Hello, \(name)!"
- 使用
-
Swift 中如何进行多行注释？
- 使用
/* */进行多行注释。
/* 这是一个多行注释。 可以包含多行文字。 */
- 使用
-
Swift 中的操作符优先级如何影响表达式的计算？
- 操作符优先级决定了表达式中操作符的计算顺序。优先级高的操作符先计算。
- 数据类型
- 标准数据类型（
Int、Float、Double、Bool、String等） - 集合类型（
Array、Set、Dictionary） - 元组（
Tuple） - 可选类型（
Optional）
- 标准数据类型（
-
解释 Swift 中的标准数据类型？
- 标准数据类型包括
Int、Float、Double、Bool、String、Array、Set和Dictionary等。
- 标准数据类型包括
-
如何在 Swift 中定义和使用数组、集合和字典？
// 数组 var array: [Int] = [1, 2, 3] // 集合 var set: Set<Int> = [1, 2, 3] // 字典 var dictionary: [String: Int] = ["one": 1, "two": 2, "three": 3]
-
什么是可选类型，如何使用它们？
- 可选类型表示一个变量可能有值也可能为
nil。用?定义。
var optionalString: String? = "Hello"
- 可选类型表示一个变量可能有值也可能为
-
可选类型的解包方式有哪些？
- 强制解包：使用
!，需确保有值。 - 可选绑定：使用
if let或guard let。 - 隐式解包：使用
?或!。
- 强制解包：使用
- 控制流
- 条件语句（
if、guard、switch） - 循环语句（
for、while、repeat-while） - 控制转移语句（
break、continue、return、fallthrough)
- 条件语句（
-
Swift 中有哪些条件语句？请举例说明。
if、else if、else、switch
if condition { // ... } else if anotherCondition { // ... } else { // ... } switch value { case 1: // ... case 2: // ... default: // ... }
-
如何在 Swift 中使用
switch语句？它与if语句有何不同？switch语句用于多条件判断，支持值绑定和模式匹配。- 与
if语句不同，switch必须穷尽所有情况或使用default分支。
-
Swift 中有哪些循环语句？请举例说明。
for-in、while、repeat-while
for i in 1...5 { // ... } while condition { // ... } repeat { // ... } while condition
-
break和continue在循环中有何作用？break：终止当前循环。continue：跳过当前迭代，开始下一次迭代。
- 函数和闭包
- 函数的定义和调用
- 函数参数和返回值
- 内嵌函数和函数作为参数
- 闭包的定义和使用
- 捕获列表
-
如何在 Swift 中定义和调用函数？
func greet(name: String) -> String { return "Hello, \(name)!" } let greeting = greet(name: "World")
-
什么是高阶函数？请举例说明。
- 高阶函数可以接收函数作为参数或返回函数。
func applyOperation(_ operation: (Int, Int) -> Int, to a: Int, and b: Int) -> Int { return operation(a, b) } let sum = applyOperation(+, to: 3, and: 5)
-
闭包与函数有何区别？
- 闭包是自包含的代码块，可以捕获和存储其作用域内的变量。
- 函数是命名的闭包，闭包是匿名的。
-
Swift 中如何捕获和管理闭包中的变量？
- 闭包可以自动捕获并存储其作用域内的变量。
var counter = 0 let increment = { counter += 1 } increment() // counter = 1
- 面向对象编程
- 类和结构体
- 属性和方法
- 构造器和析构器
- 继承和重写
- 枚举
-
Swift 中的类和结构体有何不同？请举例说明。
- 类是引用类型，结构体是值类型。
- 类支持继承和类型转换，结构体不支持。
class MyClass { var name: String init(name: String) { self.name = name } } struct MyStruct { var name: String }
-
如何在 Swift 中定义和使用类的属性和方法？
class MyClass { var name: String init(name: String) { self.name = name } func greet() -> String { return "Hello, \(name)!" } } let obj = MyClass(name: "World") let greeting = obj.greet() ```
-
Swift 中的构造器和析构器有何作用？
- 构造器：用于初始化对象。
- 析构器：用于在对象释放前执行清理工作。
-
如何在 Swift 中实现继承和方法重写？
class ParentClass { func greet() -> String { return "Hello" } } class ChildClass: ParentClass { override func greet() -> String { return "Hello, World!" } }
- 协议与扩展
- 协议的定义和实现
- 协议继承
- 使用协议作为类型
- 扩展的定义和使用
- 扩展添加方法、属性、构造器
-
什么是 Swift 协议？如何定义和实现协议？
- 协议定义了一组方法和属性的蓝图。
protocol Greetable { func greet() -> String } class MyClass: Greetable { func greet() -> String { return "Hello, World!" } }
-
协议继承和类继承有何区别？
- 协议继承可以多继承，类继承只能单继承。
- 协议只定义接口，不提供实现。
-
如何使用协议作为类型？
func greet(_ greeter: Greetable) { print(greeter.greet()) } let obj = MyClass() greet(obj)
-
Swift 中的扩展有什么用？请举例说明。
- 扩展用于向已有类型添加新功能。
extension String { func reversed() -> String { return String(self.reversed()) } } let str = "Hello" print(str.reversed()) // "olleH"
- 错误处理
- 错误类型的定义
- 抛出和捕获错误
do-catch语句try、try?和try!
-
Swift 中如何定义错误类型？
- 错误类型需符合
Error协议。
enum MyError: Error { case runtimeError(String) }
- 错误类型需符合
-
如何在 Swift 中抛出和捕获错误？
- 使用
throw抛出错误，使用do-catch捕获错误。
func mightThrowError(shouldThrow: Bool) throws { if shouldThrow { throw MyError.runtimeError("An error occurred") } } do { try mightThrowError(shouldThrow: true) } catch { print("Caught an error: \(error)") }
- 使用
-
do-catch语句的使用场景有哪些？- 用于捕获并处理可能抛出错误的代码。
-
Swift 中的错误处理与其他语言（如 Objective-C）有何不同？
- Swift 的错误处理使用
do-catch和throws关键字，更加类型安全。 - Objective-C 使用
NSError指针和@try-@catch进行错误处理，运行时检查。
- Swift 的错误处理使用
- 基础知识综合问题：
-
解释 Swift 中变量、常量、可选类型和集合类型的使用场景。
let用于定义常量，适用于值不变的场景；var用于定义变量，适用于值可能改变的场景。- 可选类型用于处理可能为
nil的值，确保安全解包。 - 数组、集合和字典用于存储和操作多个值，分别适用于有序、无序且唯一、键值对的存储场景。
-
描述 Swift 的控制流和错误处理机制的设计理念。
- Swift 的控制流（如
if、switch、循环）提供了清晰的条件和迭代控制，确保代码逻辑的可读性和可维护性。 - Swift 的错误处理机制（
do-catch和throws）通过类型安全的方式处理异常，避免运行时崩溃，提高代码的鲁棒性。
- Swift 的控制流（如
-
比较 Swift 中的类与结构体，协议与扩展，函数与闭包的实现与使用场景。
- 类是引用类型，适用于需要共享状态和继承的场景；结构体是值类型，适用于独立数据的场景。
- 协议定义接口规范，适用于解耦和多态；扩展用于向已有类型添加新功能，避免修改原代码。
- 函数和闭包都可作为可执行代码块，闭包更灵活，适用于捕获上下文的场景。
-
举例说明如何使用 Swift 的面向对象特性（如继承、多态）实现代码复用。
class Animal { func sound() -> String { return "Some sound" } } class Dog: Animal { override func sound() -> String { return "Bark" } } class Cat: Animal { override func sound() -> String { return "Meow" } } let animals: [Animal] = [Dog(), Cat()] for animal in animals { print(animal.sound()) }
-
代码示例和优化问题：
-
给定一段代码，要求解释其中的变量和常量使用，并指出是否可以优化。
let constantValue = 10 var variableValue = 5 // 假设需要重复使用的变量，可以定义为常量以提高安全性 variableValue += constantValue
-
如何在一个函数中处理多个错误场景？请举例说明。
enum MyError: Error { case errorOne case errorTwo } func process() throws { // 一些可能会抛出错误的代码 throw MyError.errorOne } do { try process() } catch MyError.errorOne { print("Handled error one") } catch MyError.errorTwo { print("Handled error two") } catch { print("Handled other errors") }
-
设计一个简单的类结构，要求使用协议和扩展实现某个功能。
protocol Drivable { func drive() } class Car: Drivable { func drive() { print("Car is driving") } } class Bike: Drivable { func drive() { print("Bike is driving") } } extension Drivable { func startEngine() { print("Engine started") } } let myCar: Drivable = Car() myCar.startEngine() myCar.drive()
-
给定一个使用闭包的代码，要求解释闭包的捕获列表和内存管理。
var value = 10 let closure = { [value] in print("Value: \(value)") } value = 20 closure() // 输出 "Value: 10"
-
- ARC：Swift 使用 ARC 来管理应用程序的内存。每当创建一个类实例时，ARC 会自动跟踪并管理该实例的引用次数。
- 引用计数增加：当有新的引用指向实例时，引用计数增加。
- 引用计数减少：当引用不再指向实例时，引用计数减少。
- 内存释放：当引用计数降到零时，ARC 自动释放该实例占用的内存。
- Stack（栈）：
- 用于存储局部变量和函数调用。
- 具有较快的分配和释放速度。
- 内存由系统自动管理，生命周期由作用域决定。
- Heap（堆）：
- 用于存储类实例和动态分配的内存。
- 分配和释放速度较慢，需要手动管理（通过 ARC）。
- 生命周期由程序控制，通过引用计数管理。
- 弱引用和无主引用：
- 使用
weak和unowned关键字来避免强引用循环。 weak：引用不增加引用计数，引用对象被销毁时自动置为nil。unowned：引用不增加引用计数，但引用对象被销毁时不置为nil，容易导致野指针错误。
- 使用
- 延迟初始化：
- 使用
lazy关键字延迟属性的初始化，优化内存使用。
- 使用
- 合适的数据结构：
- 选择合适的数据结构以减少内存占用，如使用
Set替代Array进行查找操作。
- 选择合适的数据结构以减少内存占用，如使用
- 内存泄漏：
- 发生在对象的引用计数无法降到零，从而无法释放内存。
- 常见原因是强引用循环。
- 工具检测：
- Xcode Instruments：使用 Instruments 中的 "Leaks" 和 "Allocations" 工具来检测内存泄漏和监视内存使用。
- Xcode Memory Graph：在调试时使用 Xcode 的 Memory Graph 工具查看应用的内存图，识别强引用循环和其他内存问题。
-
编译优化级别：
-Onone：无优化，主要用于开发和调试。编译速度快，生成的代码便于调试。-O：基本优化，平衡编译速度和代码性能。适用于日常开发。-Ounchecked：高性能优化，忽略安全检查。适用于性能关键的生产代码，但可能导致运行时错误。-Osize：优化代码尺寸，适用于需要减小应用体积的场景。
-
Link-Time Optimization (LTO)：
- 在链接时进行跨模块优化，提高最终生成代码的性能。
-
Whole Module Optimization (WMO)：
- 整个模块的源代码一起进行优化，能够跨文件进行优化。
- Lexing：
- 将源码转换为词法单元（tokens）。
- Parsing：
- 将词法单元解析为抽象语法树（AST）。
- Semantic Analysis：
- 语义分析，类型检查和确定变量作用域。
- SIL（Swift Intermediate Language）生成：
- 将 AST 转换为中间表示（SIL），便于优化和分析。
- SIL 优化：
- 对 SIL 进行优化，如内联、消除死代码等。
- LLVM IR 生成：
- 将优化后的 SIL 转换为 LLVM 中间表示（LLVM IR）。
- LLVM 优化：
- 对 LLVM IR 进行进一步优化，如循环优化等。
- 机器代码生成：
- 将优化后的 LLVM IR 转换为目标机器代码。
- 链接：
- 将生成的机器代码与系统库和其他模块链接，生成可执行文件。
-
代码内联（Inlining）：
- 编译器将函数调用替换为函数体本身，减少函数调用的开销。
- 提高了代码执行速度，但可能增加代码尺寸。
-
性能优化技巧：
- 避免不必要的对象创建：减少对象创建频率，降低内存分配和垃圾回收的开销。
- 使用值类型（struct）代替引用类型（class）：值类型避免引用计数的开销，适用于小型数据结构。
- 减少动态派发：尽量使用静态派发（如
final、private方法），减少运行时开销。 - 高效使用集合类型：根据实际需求选择合适的集合类型，如
Set代替Array进行查找操作。 - Profile 和 Benchmark：使用 Instruments 等工具进行性能分析，找出瓶颈并优化。
- 类型元数据（Type Metadata）：
- Swift 在运行时维护类型的相关信息，称为类型元数据。
- 类型元数据包括类型的名称、大小、存储属性、方法表等信息。
- 可以通过反射机制（
Mirror）或标准库函数获取类型元数据。
- 值类型总是会使用直接派发, 简单易懂
- 而协议和类的extension都会使用直接派发
- NSObject的extension会使用消息机制进行派发
- NSObject声明作用域里的函数都会使用函数表进行派发
- 协议里声明的, 并且带有默认实现的函数会使用函数表进行派发
-
Direct Dispatch（直接派发）
- 适用场景：
struct和enum的方法final class的方法private和fileprivate作用域的方法
- 实现方式：
- 编译时确定具体实现，直接调用函数地址。
- 没有运行时查找开销，性能最佳。
- 适用场景：
-
Table Dispatch（虚方法表派发）
- 适用场景：
- 非
final类的方法 - 默认类方法（不带
@objc修饰符）
- 非
- 实现方式：
- 在编译时为类生成虚方法表，包含所有虚方法的指针。
- 在运行时通过虚方法表查找并调用具体实现。
- 比直接派发开销稍大，但比消息发送开销小。
- 适用场景：
-
Message Dispatch（消息发送派发）
- 适用场景：
@objc修饰的类和方法- Objective-C 兼容的类和方法
- 实现方式：
- 使用 Objective-C 的消息传递机制，通过
objc_msgSend函数在运行时查找并调用方法。 - 动态性强，允许运行时改变方法实现，但开销较大。
- 使用 Objective-C 的消息传递机制，通过
- 适用场景：
理解 Swift 的派发机制对于优化性能和正确使用动态特性至关重要。在编写性能关键代码时，尽量使用静态派发；而在需要动态行为时，选择合适的派发机制。
-
反射机制：
- 反射允许在运行时检查类型、属性和方法。
Mirror类型是 Swift 的反射 API，提供了对实例的运行时检查功能。
-
使用
Mirror：- 可以通过
Mirror(reflecting: instance)创建Mirror实例。 Mirror提供属性和子元素的详细信息，可以用于调试、序列化等场景。
let instance = MyClass() let mirror = Mirror(reflecting: instance) for child in mirror.children { print("Property name: \(child.label ?? ""), value: \(child.value)") }
- 可以通过
-
使用
perform：- 通过
NSObject的perform方法动态调用 Objective-C 方法。 - 适用于与 Objective-C 交互的场景。
- 通过
-
使用
Selector：- 通过
Selector类型动态调用方法。 - 主要用于 Objective-C 兼容的类和方法。
class MyClass: NSObject { @objc func dynamicMethod() { print("Dynamic method called") } } let instance = MyClass() let selector = #selector(instance.dynamicMethod) instance.perform(selector)
- 通过
-
函数指针：
- 通过函数指针调用方法，适用于高性能要求的场景。
func myFunction() { print("Function called") } let functionPointer: () -> Void = myFunction functionPointer()
- 协议表（Protocol Witness Table，PWT）：
- 用于保存协议方法的实现。
- 当一个类型遵循某个协议时，编译器会生成一个协议表，包含该类型对协议中所有方法的具体实现。
- 通过协议表实现动态派发，允许不同类型遵循相同协议，提供多态性。
在 Swift 中，协议方法的派发机制取决于协议是如何被使用的。具体来说，可以分为以下几种情况：
如果协议方法在编译时可以确定具体实现，则会使用静态派发。静态派发没有运行时开销，性能最佳。
适用场景：
- 使用泛型约束的协议方法。
- 编译时能够确定具体类型实现的情况。
示例：
protocol Greetable { func greet() } struct Person: Greetable { func greet() { print("Hello!") } } func greet<T: Greetable>(_ value: T) { value.greet() // 静态派发 } let person = Person() greet(person)表派发用于协议表（Protocol Witness Table, PWT）中存储的方法。通过协议表实现动态派发，允许不同类型遵循相同协议，提供多态性。
适用场景：
- 类型以具体类型遵循协议，但不使用
@objc属性。示例：
protocol Greetable { func greet() } struct Person: Greetable { func greet() { print("Hello!") } } let greetable: Greetable = Person() greetable.greet() // 表派发消息发送派发用于
@objc修饰的协议方法，通过 Objective-C 的运行时系统发送消息来实现动态派发。
适用场景：
- 使用
@objc修饰的协议方法。- Objective-C 兼容的类和方法。
示例：
@objc protocol Greetable { func greet() } class Person: NSObject, Greetable { func greet() { print("Hello!") } } let greetable: Greetable = Person() greetable.greet() // 消息发送派发
- 静态派发：用于编译时可以确定具体实现的协议方法（例如，泛型约束）。
- 表派发：用于以具体类型遵循协议但不使用
@objc修饰的方法，通过协议表实现动态派发。- 消息发送派发：用于
@objc修饰的协议方法，通过 Objective-C 的运行时系统实现动态派发。
- 协议合规性检查：
- 在编译时检查类型是否符合协议要求，确保类型实现了协议中所有的方法和属性。
- 协议的合规性检查在运行时也会通过协议表进行，确保类型动态地满足协议的要求。
- 类型擦除（Type Erasure）：
protocol Printer {
associatedtype T
var value: T { get }
func print()
}
struct TypeBPrinter<T>: Printer {
var value: T
func print() {
debugPrint("\(value)")
}
}
func test() {
test1(TypeBPrinter(value: "字符串"))
test1(TypeBPrinter(value: 10))
}
func test1<T>(_ p: TypeBPrinter<T>) {
p.print()
}
func test1<T>(_ p: inout TypeBPrinter<T>, value: T) {
p.print()
p.value = value
}-
专门化（Specialization）：
- Swift 编译器会对泛型函数和类型进行专门化处理，根据具体的类型生成优化的代码。
- 专门化可以提高性能，减少运行时开销。
-
类型参数传递：
- 在运行时，通过元类型（metatype）传递泛型的类型信息。
- 这种机制允许泛型在运行时仍然保留类型信息，实现类型安全的操作。
-
关联类型（Associated Types）：
- 协议可以定义一个或多个关联类型，用于表示协议中的类型占位符。
- 关联类型使得协议更加灵活，可以适应不同类型的实现。
- 使用
associatedtype关键字定义关联类型。
protocol Container { associatedtype Item func append(_ item: Item) var count: Int { get } subscript(i: Int) -> Item { get } }
-
存在类型（Existential Types）：
- 存在类型表示一种可以持有任何符合某协议的类型的值。
- 使用协议类型作为类型标注，即表示存在类型。
- 存在类型在运行时通过协议表实现动态派发，支持多态性。
func printDescription(of value: CustomStringConvertible) { print(value.description) }
-
区别与联系：
- 关联类型用于定义协议的类型占位符，使协议适应不同类型的实现，通常在编译时确定具体类型。
- 存在类型用于表示任意符合协议的类型的值，通过协议表实现动态派发，支持运行时的多态性。
- Swift 的协议通过协议表实现动态派发，提供多态性和灵活性。
- 泛型通过类型擦除和专门化在编译时和运行时实现类型安全和性能优化。
- 关联类型和存在类型分别用于协议的类型占位符和运行时的多态性，实现灵活的类型处理。
函数式编程是一种编程范式，强调使用函数来进行计算。它通常包含以下几个核心概念：
- 纯函数：函数的输出只依赖于输入参数，不依赖于外部状态，也不修改外部状态。
- 高阶函数：可以接受函数作为参数或返回函数。
- 不可变性：数据不可变，即创建后不能修改。
- 函数组合：通过组合小的函数来构建复杂的操作。
在 Swift 中，函数式编程的底层实现依赖于 Swift 的类型系统和编译器优化。Swift 提供了丰富的标准库支持函数式编程，例如 map、filter 和 reduce 等高阶函数。Swift 的函数是第一类公民，可以赋值给变量、作为参数传递和返回。
高阶函数是指可以接受其他函数作为参数或返回值的函数。Swift 中的高阶函数利用了函数类型的灵活性。以下是几个常用的高阶函数及其实现原理：
-
map：对集合中的每个元素应用一个函数，并返回一个新的集合。
let numbers = [1, 2, 3, 4, 5] let doubled = numbers.map { $0 * 2 } // doubled: [2, 4, 6, 8, 10]
-
filter：根据条件过滤集合中的元素，返回符合条件的元素组成的集合。
let numbers = [1, 2, 3, 4, 5] let evenNumbers = numbers.filter { $0 % 2 == 0 } // evenNumbers: [2, 4]
-
reduce：将集合中的所有元素合并成一个值。
let numbers = [1, 2, 3, 4, 5] let sum = numbers.reduce(0) { $0 + $1 } // sum: 15
高阶函数的实现原理主要依赖于闭包（Closure）和泛型（Generic）。闭包捕获上下文环境中的变量，使得函数可以灵活地传递和组合。泛型使得高阶函数能够处理不同类型的集合和操作。
闭包是自包含的代码块，可以在代码中传递和调用。闭包可以捕获和存储其所在上下文中的常量和变量，称为捕获值。捕获列表用于明确地控制捕获的值。
-
捕获列表：在闭包表达式的前面，使用方括号包裹的捕获列表，可以指定捕获的变量和捕获方式（强引用、弱引用或无主引用）。
class Example { var value = 0 deinit { print("Example deinitialized") } } var example: Example? = Example() let closure = { [weak example] in print(example?.value ?? "no value") } example = nil closure() // 输出 "no value"
-
内存管理：Swift 使用自动引用计数（ARC）来管理内存。闭包和捕获的变量之间可能会形成强引用循环，导致内存泄漏。使用捕获列表中的弱引用（
weak）或无主引用（unowned）可以避免这种情况。 -
循环引用：当闭包和捕获的对象互相引用时，会导致循环引用。
class Example { var value = 0 lazy var closure: () -> Void = { [unowned self] in print(self.value) } }
使用 unowned 表示捕获的引用不会变为 nil，但在对象被释放后访问捕获的引用会导致崩溃。使用 weak 表示捕获的引用可以变为 nil，需要处理可选类型。
Swift 的函数式编程特性通过高阶函数和闭包提供了强大的工具，使得代码更加简洁和模块化。通过了解底层实现原理，可以更好地掌握和优化这些特性，提高代码的性能和安全性。
Grand Central Dispatch (GCD) 是 Apple 提供的一套并发编程框架，旨在简化多线程编程，优化系统性能。GCD 底层实现包括以下几个关键点：
-
队列（Queue）：GCD 使用不同类型的队列来管理任务的执行。主要包括串行队列（serial queue）和并行队列（concurrent queue）。
- 串行队列：一次只执行一个任务，任务按添加顺序执行。
- 并行队列：可以同时执行多个任务，但任务的开始顺序不确定。
-
线程池（Thread Pool）：GCD 底层维护一个全局的线程池，通过调度任务到这些线程上执行来实现并发。线程池会动态调整线程的数量，以最佳利用系统资源。
-
任务块（Block）：在 GCD 中，任务通常以 block（闭包）的形式定义。block 捕获其上下文中的变量和状态，并在队列中排队等待执行。
-
调度和执行：GCD 使用 FIFO（先入先出）策略调度任务。任务被分配到可用线程并运行。GCD 还支持同步和异步执行模式，分别通过
dispatch_sync和dispatch_async实现。 -
QoS（Quality of Service）：GCD 提供不同的服务质量等级，如用户交互（User Interactive）、用户发起（User Initiated）、默认（Default）、实用（Utility）和后台（Background），以帮助系统合理分配资源。
Operation 和 OperationQueue 是 Foundation 框架提供的并发编程工具，基于 GCD 实现，但提供了更高层次的抽象。
-
Operation：
Operation是一个抽象类，代表一个可执行的任务。可以通过继承Operation类并实现main方法来定义自定义任务。- 支持任务间的依赖关系，可以控制任务的执行顺序。
- 可以取消任务，支持任务状态（如准备、执行、完成）的管理。
-
OperationQueue：
OperationQueue是一个并发队列，用于管理和调度Operation对象。- 支持最大并发操作数的设置，限制同时执行的任务数量。
- 使用 GCD 的并行队列实现，但提供了更细粒度的任务控制和管理。
-
并发和同步：
OperationQueue会根据设置的并发数和任务的依赖关系调度任务。任务可以是同步或异步执行，依赖关系确保任务按指定顺序执行。
Swift 5.5 引入了新的并发编程模型，包含 async/await 语法和 Actor 模型，旨在简化并发编程，增强安全性。
-
Async/Await：
async/await语法用于简化异步代码，使其看起来像同步代码。- Async 函数：定义一个异步函数，使用
async关键字，表示该函数可以暂停执行，等待异步任务完成。 - Await 关键字：在调用异步函数时，使用
await关键字，暂停当前任务，直到异步函数完成。 - 运行时支持：底层实现通过 Swift 运行时支持，利用协程（coroutines）机制，将异步任务分解成多个小任务，在任务间切换时保持状态。
- Async 函数：定义一个异步函数，使用
-
Actor 模型：Actor 提供了一种方式来确保共享状态的并发访问安全。
- Actor 定义：使用
actor关键字定义一个 Actor 类，其内部状态只能由该 Actor 自己访问和修改。 - 消息传递：通过发送消息来与 Actor 交互，确保线程安全。
- 隔离：每个 Actor 运行在一个独立的执行环境中，避免数据竞争和死锁问题。
- Actor 定义：使用
// 使用并行队列执行任务
let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)
concurrentQueue.async {
print("Task 1")
}
concurrentQueue.async {
print("Task 2")
}// 定义自定义 Operation
class CustomOperation: Operation {
override func main() {
if isCancelled { return }
print("Custom Operation")
}
}
// 使用 OperationQueue 调度任务
let operationQueue = OperationQueue()
let operation = CustomOperation()
operationQueue.addOperation(operation)// 定义异步函数
func fetchData() async throws -> Data {
// 模拟网络请求
try await Task.sleep(nanoseconds: 1_000_000_000)
return Data()
}
// 使用 async/await 调用异步函数
Task {
do {
let data = try await fetchData()
print("Data received: \(data)")
} catch {
print("Failed to fetch data: \(error)")
}
}// 定义 Actor
actor Counter {
private var value = 0
func increment() {
value += 1
}
func getValue() -> Int {
return value
}
}
// 使用 Actor
let counter = Counter()
Task {
await counter.increment()
let value = await counter.getValue()
print("Counter value: \(value)")
}Swift 的并发编程模型，包括 GCD、OperationQueue 和新的 Swift Concurrency 特性，提供了从低级别到高级别的多种工具，简化了多线程编程，提升了代码的安全性和可维护性。理解这些工具的底层实现，有助于在实际开发中合理选择并发模型，提高应用的性能和可靠性。
-
编译期特性：
- 类型推断：Swift 编译器能够根据上下文推断变量类型，减少类型声明的冗余。
- 内存管理：Swift 使用自动引用计数（ARC）来管理内存，编译器在编译时分析对象的生命周期。
- 错误处理：编译器检查可选类型，确保在使用之前处理潜在的 nil 值。
-
运行期特性：
- 动态特性：Swift 允许动态派发和运行时反射，通过
Mirror类型访问类型信息。 - 高阶函数和闭包：支持将函数作为参数传递或返回，提高灵活性。
- 类型安全：运行时检查确保类型安全，避免类型错误。
- 动态特性：Swift 允许动态派发和运行时反射，通过
- ABI（应用二进制接口）：指二进制文件之间的接口规范，确保不同版本的 Swift 编译器能够互操作。
- ABI 稳定性：Swift 在 5.0 版本引入 ABI 稳定性，确保库和应用程序能够在不同 Swift 版本间保持兼容，简化了库的分发和版本管理。
- 影响：ABI 稳定性提高了 Swift 的生态系统，减少了因 Swift 版本升级导致的兼容性问题，允许开发者在更高的层次上关注功能实现而非底层细节。
-
模块系统：
- Swift 使用模块来组织代码，模块是一个包含代码和资源的单元，类似于 C/C++ 的头文件和实现文件。
- 模块可以包含类、结构体、枚举、函数等，提供了更好的封装性和命名空间管理。
-
跨模块优化：
- Swift 的编译器支持跨模块优化（Whole Module Optimization），在编译时对整个模块进行优化，提高了性能。
- 在编译时分析跨模块的函数调用关系，能够消除冗余代码和提高内联效率。
Swift 的语言特性为开发者提供了强大的编译期和运行期功能，ABI 的稳定性保障了不同版本间的兼容性，而模块系统和跨模块优化则增强了代码组织和性能优化的能力。这些特性共同促进了 Swift 的发展，使其成为一个高效、灵活且易于维护的现代编程语言。
Swift 提供五种访问控制级别来保护代码的不同部分：
- open：最高权限，可以在任何模块中访问和继承。
- public：可以在任何模块中访问，但不能在其他模块中继承。
- internal：默认权限，只能在同一模块内访问。
- fileprivate：只能在同一源文件内访问。
- private：最严格的权限，只能在声明它的作用域内访问。
访问控制的底层实现基于编译器在编译时插入的访问控制检查。编译器在生成代码时会检查每个符号的访问级别，确保符号在合适的范围内使用。
-
编译期检查：在编译时，Swift 编译器会根据访问控制级别检查符号的访问权限。如果访问权限不符，编译器将生成错误，阻止代码编译。这有助于在开发过程中及早发现权限错误。
class MyClass { private var privateProperty = 0 } let myClass = MyClass() // 下面的代码会报错，因为 privateProperty 是 private 级别，不能在类外部访问 print(myClass.privateProperty)
-
优化：访问控制可以帮助编译器进行优化。内部的（internal、fileprivate 和 private）代码在编译时可以进行更多的优化，因为编译器知道这些代码的调用范围有限。例如，编译器可以更积极地进行内联优化。
-
模块边界：访问控制在模块边界提供了更好的封装和安全性。public 和 open 修饰的符号可以跨模块访问，而内部的符号则只能在模块内部使用。这样可以限制 API 的暴露，避免意外使用内部实现。
// 模块 A public class PublicClass { public func publicMethod() {} internal func internalMethod() {} } // 模块 B import ModuleA let publicClass = PublicClass() publicClass.publicMethod() // 可以访问 // publicClass.internalMethod() // 报错，无法访问
Swift 的访问控制通过编译期检查和运行期优化，确保代码的封装性和安全性。不同的访问控制级别（open、public、internal、fileprivate、private）提供了灵活的权限管理，使开发者能够更好地控制符号的可见性和模块间的交互，从而提高代码的健壮性和可维护性。
Swift 提供了一种结构化的错误处理机制，主要使用 Error 协议、do-catch 语句、try 和 throw 关键字来处理和传播错误。
-
Error 协议：
- Swift 中的错误类型必须遵循
Error协议。
enum MyError: Error { case invalidInput case networkError }
- Swift 中的错误类型必须遵循
-
throw 关键字：
- 使用
throw关键字抛出错误。
func performTask() throws { throw MyError.invalidInput }
- 使用
-
try 关键字：
- 在调用可能抛出错误的函数时使用
try关键字。
do { try performTask() } catch { print("Caught an error: \(error)") }
- 在调用可能抛出错误的函数时使用
-
do-catch 语句：
- 使用
do-catch语句捕获和处理错误。
do { try performTask() } catch MyError.invalidInput { print("Invalid input error") } catch MyError.networkError { print("Network error") } catch { print("Other error: \(error)") }
- 使用
Swift 的错误处理机制是通过在编译期和运行期对函数调用的特殊处理来实现的。
-
编译期实现：
- 当一个函数声明为
throws时，编译器会生成额外的代码来处理错误的传播。 - 如果调用的函数可能抛出错误，编译器会强制要求在调用点使用
try关键字，并确保错误被捕获或传播。 - 这确保了错误处理的严格性和一致性。
- 当一个函数声明为
-
运行期实现：
- 在运行时，当一个函数抛出错误时，Swift 的运行时系统会自动寻找调用栈中最近的
catch块来处理这个错误。 - 通过
do-catch语句，错误可以被捕获并处理，或者被传播到调用链的上层。 - 如果错误未被捕获并传播到顶层，程序会崩溃并报告未处理的错误。
- 在运行时，当一个函数抛出错误时，Swift 的运行时系统会自动寻找调用栈中最近的
enum FileError: Error {
case fileNotFound
case unreadable
case encodingFailed
}
func readFile(at path: String) throws -> String {
guard path == "validPath" else {
throw FileError.fileNotFound
}
return "File content"
}
func processFile() throws {
let content = try readFile(at: "invalidPath")
print(content)
}
do {
try processFile()
} catch FileError.fileNotFound {
print("File not found")
} catch {
print("An unexpected error occurred: \(error)")
}在这个示例中，readFile 函数可能抛出 FileError.fileNotFound 错误，而 processFile 函数则会调用 readFile 并传播错误。在 do-catch 块中，捕获和处理了 FileError.fileNotFound 错误，同时也捕获并处理了所有其他未指定的错误。
Swift 的错误处理机制通过编译期的严格检查和运行期的错误传播，实现了安全且结构化的错误处理。使用 Error 协议、throw、try 和 do-catch，开发者可以定义和处理不同类型的错误，提高代码的健壮性和可维护性。
-
使用 Bridging Header：
- Swift 项目可以通过桥接头文件（Bridging Header）来导入和使用 C 代码。在桥接头文件中，声明你需要使用的 C 头文件。
// Bridging-Header.h #include "MyCCode.h"
-
直接调用 C 函数：
- 在 Swift 代码中，可以直接调用桥接头文件中声明的 C 函数。
// 使用 C 函数 let result = myCFunction()
-
使用
@convention(c)修饰符：- 如果需要将 Swift 函数暴露给 C 代码，可以使用
@convention(c)修饰符定义函数。
@convention(c) func swiftFunction() -> Int { return 42 }
- 如果需要将 Swift 函数暴露给 C 代码，可以使用
-
使用
@objc修饰符：- 在 Swift 中，可以使用
@objc修饰符将 Swift 类、方法、属性、初始化方法等暴露给 Objective-C 代码。
@objc class MyClass: NSObject { @objc func myMethod() { print("Called from Objective-C") } }
- 在 Swift 中，可以使用
-
继承
NSObject：- Swift 类必须继承自
NSObject才能在 Objective-C 中使用。
@objc class MyClass: NSObject { // 实现代码 }
- Swift 类必须继承自
-
导入 Objective-C 代码：
- 在 Swift 项目中，可以通过桥接头文件导入 Objective-C 代码。在桥接头文件中声明你需要使用的 Objective-C 头文件。
// Bridging-Header.h #import "MyObjectiveCCode.h"
-
使用
@objcMembers：- 可以使用
@objcMembers为整个类启用 Objective-C 兼容性，使得所有成员都能在 Objective-C 中使用。
@objcMembers class MyClass: NSObject { // 实现代码 }
- 可以使用
-
自动桥接：
- Swift 和 Objective-C 类型之间的桥接是自动的。常见的桥接类型有
NSString与String、NSArray与Array、NSDictionary与Dictionary等。
let swiftString: String = "Hello, World!" let objcString: NSString = swiftString as NSString
- Swift 和 Objective-C 类型之间的桥接是自动的。常见的桥接类型有
-
桥接头文件：
- 在 Swift 项目中创建一个桥接头文件，导入需要使用的 C 和 Objective-C 代码。
// Bridging-Header.h #import "MyObjectiveCCode.h" #include "MyCCode.h"
-
Swift 和 Objective-C 混编项目：
- 在混编项目中，Objective-C 代码可以通过生成的
-Swift.h头文件访问 Swift 代码。Swift 代码可以通过桥接头文件访问 Objective-C 代码。
// 在 Objective-C 文件中 #import "ProjectName-Swift.h"
- 在混编项目中，Objective-C 代码可以通过生成的
-
NS_ASSUME_NONNULL 和 NS_ASSUME_NONNULL_BEGIN：
- 在 Objective-C 代码中使用
NS_ASSUME_NONNULL_BEGIN和NS_ASSUME_NONNULL_END宏定义可以简化与 Swift 的互操作。 - NS_ASSUME_NONNULL 和 NS_ASSUME_NONNULL_BEGIN 宏通过编译器预处理指令 _Pragma 实现，在 Objective-C 代码中提供了一个明确的方式来默认指定指针类型的 non-nullable 属性。这不仅增强了代码的安全性和可读性，还使得 Objective-C 代码与 Swift 的互操作性更好。
NS_ASSUME_NONNULL_BEGIN @interface MyClass : NSObject - (void)myMethod:(NSString *)string; @end NS_ASSUME_NONNULL_END
- 在 Objective-C 代码中使用
Swift 提供了与 C 和 Objective-C 代码的紧密互操作性，通过桥接头文件、@objc 修饰符、@convention(c) 修饰符等机制，使得在 Swift 项目中可以方便地使用现有的 C 和 Objective-C 代码。同时，Swift 和 Objective-C 之间的自动桥接功能大大简化了类型转换和数据传递，为开发者提供了灵活且高效的混编开发体验。
-
使用 Instruments 进行内存分析：
- Instruments 是 Xcode 提供的一个性能分析和调试工具，可以用于检测应用程序的内存使用情况和性能瓶颈。
- 内存泄漏检测：使用 Leaks 模板检测应用程序中未释放的内存块。
- 内存分配分析：使用 Allocations 模板查看内存分配的情况，分析哪些对象占用了大量内存。
- 内存生命周期分析：使用 Allocations 和 VM Tracker 模板监视对象的创建、持有和释放过程。
-
使用 Address Sanitizer 检测内存错误：
- Address Sanitizer（ASan）是一个快速内存错误检测工具，可以检测诸如缓冲区溢出、使用未初始化的内存、重复释放内存等错误。
- 通过在 Xcode 中启用 Address Sanitizer，可以在运行时捕获并报告内存访问错误。
- 详细的错误报告帮助开发者快速定位和修复内存管理问题。
-
使用 Static Analyzer 进行静态代码分析：
- Static Analyzer 是 Xcode 内置的静态分析工具，用于在编译时检查代码中的潜在错误。
- 它可以检测到可能的内存泄漏、未使用的变量、未捕获的异常等问题。
- 在 Xcode 中，通过 Product -> Analyze 菜单项运行静态分析工具，可以在问题变得严重之前发现并修复潜在的错误。
-
使用 MLeaksFinder 进行内存泄露检测：
- MLeaksFinder 会在对象销毁时自动检测内存泄漏。如果一个对象在预期销毁时没有被释放，它会报告内存泄漏。
- MLeaksFinder 可以精确定位到具体的泄漏对象和泄漏的代码位置，帮助开发者快速找到问题根源。
- 集成和使用 MLeaksFinder 非常简单，只需几行代码就能开始检测内存泄漏。
Combine 和 RxSwift 都是响应式编程框架，用于处理异步事件和数据流。虽然它们在概念和功能上有很多相似之处，但也有一些显著的区别。以下是两者之间的一些主要区别：
-
官方框架：
- Combine 是 Apple 官方提供的响应式编程框架，集成在 iOS 13 和 macOS 10.15 及以后的系统中。
-
集成和支持：
- 由于是官方框架，Combine 与 Swift 语言和 SwiftUI 有更好的集成和支持。
-
架构：
- Combine 使用了
Publisher和Subscriber模式，并提供了丰富的操作符，如map、filter、flatMap等。
- Combine 使用了
-
语法和接口：
- Combine 的 API 设计更加贴近 Swift 语言本身，使用起来更自然和简洁。
-
调度器：
- Combine 提供了调度器（Scheduler）来控制代码执行的线程和时机，例如
DispatchQueue.main、RunLoop.main等。
- Combine 提供了调度器（Scheduler）来控制代码执行的线程和时机，例如
-
性能：
- 由于是官方框架，Combine 在性能和资源使用方面有较好的优化。
-
第三方库：
- RxSwift 是一个由社区开发和维护的第三方响应式编程框架，灵感来自于 ReactiveX 项目。
-
跨平台支持：
- RxSwift 可以在 iOS、macOS、tvOS 和 watchOS 上使用，并且与其他平台上的 ReactiveX 实现（如 RxJava、RxJS）有相似的 API。
-
架构：
- RxSwift 也使用了
Observable和Observer模式，并提供了丰富的操作符，如map、filter、flatMap、combineLatest等。
- RxSwift 也使用了
-
语法和接口：
- RxSwift 的 API 更加通用和灵活，但在某些情况下可能显得较为复杂。
-
调度器：
- RxSwift 提供了调度器（Scheduler）来控制代码执行的线程和时机，例如
MainScheduler.instance、ConcurrentDispatchQueueScheduler等。
- RxSwift 提供了调度器（Scheduler）来控制代码执行的线程和时机，例如
-
社区支持和扩展：
- RxSwift 拥有一个庞大的社区和丰富的扩展库，如 RxCocoa（用于绑定 UIKit 和 Cocoa 控件）、RxDataSources（用于高效处理表视图和集合视图的数据源）等。
| 特性 | Combine | RxSwift |
|---|---|---|
| 发布者和订阅者模式 | Publisher 和 Subscriber | Observable 和 Observer |
| 操作符 | 丰富的操作符，如 map、filter、flatMap |
丰富的操作符，如 map、filter、flatMap、combineLatest 等 |
| 线程调度 | 调度器（Scheduler），如 DispatchQueue.main、RunLoop.main |
调度器（Scheduler），如 MainScheduler.instance、ConcurrentDispatchQueueScheduler |
| 官方支持 | Apple 官方框架，集成在 iOS 13 和 macOS 10.15 及以后 | 第三方库，由社区开发和维护 |
| 语法和接口 | 更贴近 Swift 语言本身，使用自然简洁 | 通用和灵活，但在某些情况下较为复杂 |
| 性能和资源优化 | 官方框架，性能优化较好 | 依赖社区贡献，性能优化需视具体实现 |
| 社区支持和扩展 | 社区支持较少，扩展库有限 | 拥有庞大的社区和丰富的扩展库，如 RxCocoa、RxDataSources 等 |
-
Combine：如果你在开发仅支持 iOS 13+ 和 macOS 10.15+ 的应用，并且希望使用 Apple 官方提供的框架，Combine 是一个很好的选择。它与 Swift 和 SwiftUI 的集成度高，性能优化好。
-
RxSwift：如果你需要支持更广泛的 iOS 和 macOS 版本，或者希望利用社区提供的丰富扩展库和跨平台支持，RxSwift 是一个不错的选择。它在多个平台上具有一致的 API，并且拥有一个活跃的社区。