# 一、概述本系列文章旨在复习`Swift5`核心语法且适当进行底层原理探索,属于阶段性复习和巩固,以供日后进一步探索`Swift`语言的底层原理做铺垫。整个系列文章如下，每一文章知识点独立成篇,欢迎各位按需或按兴趣点击阅读: * **[01-📝Swift5常用核心语法|了解Swift【Swift简介、Swift的版本、Swift编译原理】](https://juejin.cn/post/7119020967430455327)** * **[02-📝Swift5常用核心语法|基础语法【Playground、常量与变量、常见数据类型、字面量、元组、流程控制、函数、枚举、可选项、guard语句、区间】](https://juejin.cn/post/7119510159109390343)** * **[03-📝Swift5常用核心语法|面向对象【闭包、结构体、类、枚举】](https://juejin.cn/post/7119513630550261774)** * **[04-📝Swift5常用核心语法|面向对象【属性、inout、类型属性、单例模式、方法、下标、继承、初始化】](https://juejin.cn/post/7119714488181325860)** * **[05-📝Swift5常用核心语法|高级语法【可选链、协议、错误处理、泛型、String与Array、高级运算符、扩展、访问控制、内存管理、字面量、模式匹配】](https://juejin.cn/post/7119722433589805064)** * **[06-📝Swift5常用核心语法|编程范式与Swift源码【从OC到Swift、函数式编程、面向协议编程、响应式编程、Swift源码分析】](https://juejin.cn/post/7253350009289424933)** # 二、从OC到Swift ## 1. 标记我们可以通过一些注释标记来特殊标明注释的含义 * `// MARK:` 类似`OC`中的`#pragma mark` * `// MARK: -` 类似`OC`中的`#pragma mark -` * `// TODO:` 用于标记未完成的任务 * `// FIXME:` 用于标记待修复的问题使用示例如下 ![-w370](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/503e1e80a2264029b79524650dc62c74~tplv-k3u1fbpfcp-zoom-1.image#?w=740\&h=766\&s=25182\&e=webp\&b=211f27) ![-w440](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/34ed563f13d74c0f92d8ed1336b66231~tplv-k3u1fbpfcp-zoom-1.image#?w=880\&h=1562\&s=57386\&e=webp\&b=222028) 我们还可以使用`#warning`来作为警告的提示，效果更为显著 ![-w714](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c05a9f610fd149389b6d9719617ab47c~tplv-k3u1fbpfcp-zoom-1.image#?w=1428\&h=218\&s=13822\&e=webp\&b=211f27) ## 2. 条件编译 ![-w720](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5157980e7c574b31a5c37d39667d3c10~tplv-k3u1fbpfcp-zoom-1.image#?w=1440\&h=644\&s=43498\&e=webp\&b=211f27) 我们还可以在`Build Settings-> Swift Compiler -Custom Flags`自定义标记在`Other Swift Flags`里自定义的标记要以`-D`开头 ![-w716](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5a8057e99b664fd1b4125b33a0be75f0~tplv-k3u1fbpfcp-zoom-1.image#?w=1432\&h=496\&s=32538\&e=webp\&b=fcfcfc) ![-w278](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5eaf1ed438f24cda8833e9e6a2182470~tplv-k3u1fbpfcp-zoom-1.image#?w=556\&h=342\&s=12998\&e=webp\&b=211f27) ## 3. 打印我们可以自定义打印的内容，便于开发中的详情观察 ```swift /* * msg: 打印的内容 * file: 文件名 * line: 所在行数 * fn: 执行的函数名 */ func log(_ msg: T, file: NSString = #file, line: Int = #line, fn: String = #function) { #if DEBUG let prefix = "(file.lastPathComponent)_(line)_(fn):" print(prefix, msg) #endif } func test() { log("哈哈") } // 输出： // main.swift_66_test(): 哈哈 ``` ## 4. 系统的版本检测 ```swift if #available(iOS 10, macOS 10.12, *) { // 对于iOS平台，只在iOS10及以上版本执行 // 对于macOS平台，只在macOS 10.12以上版本执行 // 最后的*表示在其他所有平台都执行 } ``` ## 5. API可用性说明 ```swift @available(iOS 10, macOS 10.12, *) class Person {} struct Student { // 旧的方法名更改，使用者用到时就会报错 @available(*, unavailable, renamed: "study") func study_() {} func study() {} // 表示该方法在这个平台已经过期 @available(iOS, deprecated: 11) @available(macOS, deprecated: 10.12) func run() {} } ``` ![-w642](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1aae54a5a9b34e69a0f5b0ad58548a54~tplv-k3u1fbpfcp-zoom-1.image#?w=1284\&h=244\&s=18342\&e=webp\&b=232028) 更多用法参考：[docs.swift.org/swift-book/…](https://link.juejin.cn?target=https%3A%2F%2Fdocs.swift.org%2Fswift-book%2FReferenceManual%2FAttributes.html "https://docs.swift.org/swift-book/ReferenceManual/Attributes.html") ## 6. 程序入口在`AppDelegate`上面默认有个`@main`标记，这表示编译器自动生成入口代码（main函数代码），自动设置`AppDelegate`为APP的代理 ![-w776](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1c7e5d9b0a024687be380d5f3e31c3ed~tplv-k3u1fbpfcp-zoom-1.image#?w=1552\&h=818\&s=66294\&e=webp\&b=211f27) 之前的`Xcode`版本会生成`@UIApplicationMain`标记，和`@main`的作用一样 ![-w776](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7232bfd8d235474daec8a836b6536209~tplv-k3u1fbpfcp-zoom-1.image#?w=1552\&h=916\&s=76096\&e=webp\&b=211f27) 也可以删掉`@main`或者`@UIApplicationMain`，自定义入口代码 1.创建`main.swift`文件 ![-w728](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7645c407f7cf4f48a9e30d01ffc5830a~tplv-k3u1fbpfcp-zoom-1.image#?w=1456\&h=1042\&s=29324\&e=webp\&b=dbdbdb) 2.去掉`AppDelegate`里的标记 ![-w775](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/34896ddcd5ea4639b69827eadba0f9a1~tplv-k3u1fbpfcp-zoom-1.image#?w=1550\&h=958\&s=70662\&e=webp\&b=211f27) 3.在`main.swift`里面自定义`UIApplication`并增加入口代码 ![-w748](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f1cfff66a40a49c8bb4b8212148fb761~tplv-k3u1fbpfcp-zoom-1.image#?w=1496\&h=462\&s=33118\&e=webp\&b=211f27) ## 7. Swift调用OC 如果我们在Swift项目中需要调用到OC的代码，需要建立一个桥接头文件，文件名格式为`{targetName}-Bridging-Header.h` 在桥接文件里引用需要的OC头文件 ![-w1119](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/37741c059c2042fe91899f89c2216886~tplv-k3u1fbpfcp-zoom-1.image#?w=2238\&h=906\&s=39798\&e=webp\&b=211f27) 在`Build Setting -> Swift Compiler - General`中写好桥接文件路径 ![-w849](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4598ea94c3e7465d81630f451ed8e7b2~tplv-k3u1fbpfcp-zoom-1.image#?w=1698\&h=504\&s=38864\&e=webp\&b=fdfdfd) 如果我们是在Swift项目里第一次创建OC文件，`Xcode`会提示是否需要帮助创建桥接文件 ![-w731](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e57cadadbef147678501a38b0aa6f9b8~tplv-k3u1fbpfcp-zoom-1.image#?w=1462\&h=1038\&s=34112\&e=webp\&b=d0d0d0) 然后我们就可以在Swift文件里调用OC的代码了 ![-w532](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1d68d5363bf6452d91a438f5ebae0b00~tplv-k3u1fbpfcp-zoom-1.image#?w=1064\&h=908\&s=30548\&e=webp\&b=211f27) ![-w728](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1c2b5a1e962843c5a651b6f7107a6b1e~tplv-k3u1fbpfcp-zoom-1.image#?w=1456\&h=574\&s=23726\&e=webp\&b=211f27) 如果C语言暴露给Swift的函数名和Swift中的其他函数名冲突了，可以在Swift中使用`@_silgen_name`修改C语言的函数名 ```swift // C文件 int sum(int a, int b) { return a + b; } // Swift文件 func sum(_ a: Int, _ b: Int) -> Int { a - b } @_silgen_name("sum") func swift_sum(_ a: Int32, _ b: Int32) -> Int32 print(sum(5, 6)) print(swift_sum(5, 6)) ``` `@_silgen_name`还可以用来调用C的私有函数 ## 8. OC调用Swift 我们要是想在OC文件中调用Swift代码，需要引用一个隐藏文件`{targetName}-Swift.h` ![-w847](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b7ee3e67cbd64afbafd980f77c1275ed~tplv-k3u1fbpfcp-zoom-1.image#?w=1694\&h=460\&s=36544\&e=webp\&b=fdfdfd) Swift暴露给OC的类最终都要继承自`NSObject` 使用`@objc`修饰需要暴露给OC的成员 ![-w400](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/95b10b0c07a54d3bb366dbfc0603da69~tplv-k3u1fbpfcp-zoom-1.image#?w=800\&h=674\&s=18166\&e=webp\&b=211f27) ![-w592](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c09a72f8d1764594a8fe7abf349c3d01~tplv-k3u1fbpfcp-zoom-1.image#?w=1184\&h=786\&s=28450\&e=webp\&b=211f27) 使用`@objcMembers`修饰类，代表默认所有成员都会暴露给OC（包括扩展中定义的成员）最终是否成功暴露，还需要考虑成员自身的权限问题 ![-w496](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a03455cdbec8415ca2c8efa0cc7281c6~tplv-k3u1fbpfcp-zoom-1.image#?w=992\&h=708\&s=19178\&e=webp\&b=211f27) 我们进入到`test-Swift.h`里看看编译器默认帮我们转成的OC代码是怎样的 ![-w722](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f3c621b1d7854c529d8596c0d4345821~tplv-k3u1fbpfcp-zoom-1.image#?w=1444\&h=344\&s=28246\&e=webp\&b=211f27) 我们还可以通过`@objc`来对Swift文件里的类和成员重命名，来更适应于OC的代码规范 ![-w573](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9d7c4fff781e464dbfd50177c7b2a0b8~tplv-k3u1fbpfcp-zoom-1.image#?w=1146\&h=866\&s=26530\&e=webp\&b=211f27) ![-w635](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/bdf387dd03044e158df292505ce6730d~tplv-k3u1fbpfcp-zoom-1.image#?w=1270\&h=770\&s=27486\&e=webp\&b=211f27) ## 9. 选择器 Swift中依然可以使用选择器，使用`#selector(name)`定义一个选择器必须是被`@objcMembers`或`@objc`修饰的方法才可以定义选择器 ![-w728](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a485a1206acd4edc93cc8a20fa927aee~tplv-k3u1fbpfcp-zoom-1.image#?w=1456\&h=1522\&s=50440\&e=webp\&b=211f27) 如果不加`@objcMembers`或`@objc`是会报错的 ![-w777](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ffbcaad964884810b40513cba3491bcf~tplv-k3u1fbpfcp-zoom-1.image#?w=1554\&h=1528\&s=65522\&e=webp\&b=242029) ## 10. 混编调用的本质 **我们先来思考一个问题，为什么Swift暴露给OC的类最终要继承NSObject？** 只有OC调用最后还是走的消息发送机制，要想能够实现消息机制，就需要有`isa指针`，所以要继承`NSObject` 我们在调用的地方打上断点，然后进行反汇编 ![-w557](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4574b5b5d78347169f7dbe634f696c13~tplv-k3u1fbpfcp-zoom-1.image#?w=1114\&h=310\&s=16644\&e=webp\&b=222028) 我们发现，反汇编内部最终调用了`objc_msgSend`，很明显是消息发送机制 ![-w846](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/0ebd29213bfc4c6fb9fecd82a89fb3a8~tplv-k3u1fbpfcp-zoom-1.image#?w=1692\&h=438\&s=62822\&e=webp\&b=222027) **那Swift调用OC的方法，是走的消息发送机制，还是Swift本身的调用方式呢？** 我们在调用的地方打上断点，然后进行反汇编 ![-w781](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3305857dbdb44dab9df8b61d78e72bc5~tplv-k3u1fbpfcp-zoom-1.image#?w=1562\&h=474\&s=26510\&e=webp\&b=222028) 我们发现，反汇编内部最终调用了`objc_msgSend`，很明显是消息发送机制 ![-w846](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c3240ca290794899999dd1d823160a82~tplv-k3u1fbpfcp-zoom-1.image#?w=1692\&h=388\&s=52152\&e=webp\&b=222027) **暴露给OC使用的Swift函数和类，如果被Swift调用，是走的消息发送机制，还是Swift本身的调用方式呢？** 我们在调用的地方打上断点，然后进行反汇编 ![-w784](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/99cab04169314f668cdd7830050e3836~tplv-k3u1fbpfcp-zoom-1.image#?w=1568\&h=652\&s=30684\&e=webp\&b=222028) 我们发现，反汇编内部是按照根据元类信息里的函数地址去调用的方式，没有`Runtime`相关的调用 ![-w841](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e0ad94a0f0e548079899cf2e491551e6~tplv-k3u1fbpfcp-zoom-1.image#?w=1682\&h=532\&s=80798\&e=webp\&b=222027) ![-w847](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/17a8bb7f1d7445f0b865c5ade381ff21~tplv-k3u1fbpfcp-zoom-1.image#?w=1694\&h=392\&s=56408\&e=webp\&b=222027) 我们可以加上`dynamic`关键字，这样不管是OC调用还是Swift调用都会走`Runtime`的消息发送机制 ![-w505](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/cffbba28d0e842c38114d4b205789d0c~tplv-k3u1fbpfcp-zoom-1.image#?w=1010\&h=736\&s=21992\&e=webp\&b=211f27) 反汇编之后 ![-w843](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ba276810bb6b4858b5ab13c4606f3bb3~tplv-k3u1fbpfcp-zoom-1.image#?w=1686\&h=836\&s=90342\&e=webp\&b=222027) ## 11. String Swift的字符串类型`String`，和OC的`NSString`，在API设计上还是有较大差异的 ```swift // 空字符串 var emptyStr1 = "" var emptyStr2 = String() ``` ```swift // 拼接字符串 var str: String = "1" str.append("_2") // 重载运算符 str = str + "_3" str += "_4" // 插值 str = "(str)_5" print(str, str.count) // 1_2_3_4_5, 9 ``` ```swift // 字符串的判断 var str = "123456" print(str.hasPrefix("123")) // true print(str.hasSuffix("456")) // true ``` ### 11.1 String的插入和删除 ```swift var str = "1_2" str.insert("_", at: str.endIndex) // 1_2_ str.insert(contentsOf: "3_4", at: str.endIndex) // 1_2_3_4 str.insert(contentsOf: "666", at: str.index(after: str.startIndex)) // 1666_2_3_4 str.insert(contentsOf: "888", at: str.index(before: str.endIndex)) // 1666_2_3_8884 str.insert(contentsOf: "hello", at: str.index(str.startIndex, offsetBy: 4)) // 1666hello_2_3_8884 ``` ```swift str.remove(at: str.firstIndex(of: "1")!) // 666hello_2_3_8884 str.removeAll { $0 == "6" } // hello_2_3_8884 let range = str.index(str.endIndex, offsetBy: -4).. String var str2 = String(substr3) ``` * `Substring`和它的`base`，共享字符串数据 * 其本质是`Substring`内部有一个指针指向`String`对应的区域 * `Substring`发生修改或者转为`String`时，会分配新的内存存储字符串数据，不会影响到最初的`String`的内容，编译器会自动做优化 ![-w467](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/6fbefa1a85e4471abcca65a83ef20b47~tplv-k3u1fbpfcp-zoom-1.image#?w=934\&h=766\&s=15106\&e=webp\&b=fdfcfc) ### 11.3 String与Character ```swift for c in "jack" { // c是Character类型 print(c) } ``` ```swift var str = "jack" var c = str[str.startIndex] // c是Character类型 ``` ### 11.4 String相关的协议 * `BidirectionalCollection`协议包含的部分内容 * `startIndex`、`endIndex`属性、`index`方法 * `String`、`Array`都遵守了这个协议 * `RangeReplaceableCollection`协议包含的部分内容 * `append`、`insert`、`remove`方法 * `String`、`Array`都遵守了这个协议 * `Dictionary`、`Set`也有实现上述协议中声明的一些方法，只是并没有遵守上述协议 ### 11.5 多行String ```swift let str = """ 1 ”2“ 3 '4' """ ``` 如果要显示3引号，至少转义1个引号 ```swift let str = """ Escaping the first quote """ Escaping two quotes """ Escaping all three quotes """ """ ``` 以下两个字符是等价的 ```swift let str1 = "These are the same." let str2 = """ These are the same. """ ``` 缩进以结尾的3引号为对齐线 ```swift let str = """ 1 2 3 4 """ ``` ### 11.6 String和NSString * `String`和`NSString`之间可以随时随地的桥接转换 * 如果你觉得`String`的API过于复杂难用，可以考虑将`String`转为`NSString` ```swift var str1: String = "jack" var str2: NSString = "rose" var str3 = str1 as NSString var str4 = str2 as String var str5 = str3.substring(with: NSRange(location: 0, length: 2)) print(str5) // ja ``` 我们通过反汇编发现，`String`和`NSString`的转换会调用函数来实现的，相对会有性能的消耗，但由于编译器的优化，消耗的成本可以忽略不计 ![-w715](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ebe0ffeb017440ad8bdba06af9d07524~tplv-k3u1fbpfcp-zoom-1.image#?w=1430\&h=296\&s=37542\&e=webp\&b=404a4c) **比较字符串内容是否等价** * `String`使用`==`运算符 * `NSString`使用`isEqual`方法，也可以使用`==`运算符（本质还是调用了`isEqual`方法） ```swift var str1: NSString = "jack" var str2: String = "rose" var str5: String = "rose" var str6: NSString = "jack" print(str2 == str5) print(str1 == str6) ``` 通过反汇编，我们可以看到`==`运算符的本质还是调用了`isEqual`方法 ![-w714](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/54a041f55100495d9d08b9ad2a82e727~tplv-k3u1fbpfcp-zoom-1.image#?w=1428\&h=634\&s=88738\&e=webp\&b=222027) ![-w714](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/70eb10bfdbff485d90798d2806b3fe11~tplv-k3u1fbpfcp-zoom-1.image#?w=1428\&h=284\&s=29264\&e=webp\&b=212027) \![-w713](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/bf842a9f550e41ea875c8b7aa0fc7fc7~tplv-k3u1fbpfcp-zoom-1.image) **下面是Swift和OC的几个类型的转换表格** `String`和`NSString`可以相互转换，而`NSMutableString`就只能单向转换成`String` 其他类型同理 ![-w506](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/045b94548fa64169ad7bbd9c1d0a839f~tplv-k3u1fbpfcp-zoom-1.image#?w=1012\&h=546\&s=27458\&e=webp\&b=fdfdfd) ## 12. 只能被class继承的协议 * 如果协议对应`AnyObject、class、@objc`来修饰，那么只能被类所遵守 ![-w654](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/157c85f4208741afa8daba0486044620~tplv-k3u1fbpfcp-zoom-1.image#?w=1308\&h=706\&s=51184\&e=webp\&b=2c252e) * 被`@objc`修饰的协议，还可以暴露给OC去遵守协议实现 ```swift // Swift文件 @objc protocol Runnable4 { func run() } // OC文件 @interface LLTest : NSObject @end @implementation LLTest - (void)run { } @end ``` 可以通过`@objc`定义可选协议，这种协议只能被`class`遵守 ```swift @objc protocol Runnable4 { func run() @objc optional func eat() } class Person: Runnable4 { func run() { print("run") } } ``` ## 13. dynamic 被`@objc dynamic`修饰的内容会具有动态性，比如调用方法会走`Runtime`的消息发送机制 ```swift class Dog { @objc dynamic func test1() {} func test2() {} } var d = Dog() d.test1() d.test2() ``` 具体汇报调用过程可以参考上文`混编调用的本质` ## 14. KVC、KVO * 1. Swift支持`KVC、KVO`的条件需要属性所在的类、监听器最终继承自`NSObject` * 2. 用`@objc dynamic`修饰对应的属性 ```swift 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() addObserver(observer, forKeyPath: "age", options: .new, context: nil) } deinit { removeObserver(observer, forKeyPath: "age") } } var p = Person() p.age = 20 p.setValue(25, forKey: "age") // Optional(20) // Optional(25) ``` * 3. `block`方式的\`KVO ```swift class Person: NSObject { @objc dynamic var age: Int = 0 var observation: NSKeyValueObservation? override init() { super.init() observation = observe(\Person.age, options: .new, changeHandler: { (person, change) in print(change.newValue as Any) }) } } var p = Person() p.age = 20 p.setValue(25, forKey: "age") // Optional(20) // Optional(25) ``` ## 15. 关联对象（Associated Object） * 在Swift中，`class`依然可以使用关联对象 * 默认情况下，`extension`不可以增加存储属性 * 借助关联对象，可以实现类似`extension`为`class`增加存储属性的效果 ```swift class Person {} extension Person { // Void类型只占一个字节 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, newValue, .OBJC_ASSOCIATION_ASSIGN) } } } var p = Person() print(p.age) // 0 p.age = 10 print(p.age) // 10 ``` ## 16. 资源名管理我们日常在代码中对资源的使用如下 ```swift let img = UIImage(named: "logo") let btn = UIButton(type: .custom) btn.setTitle("添加", for: .normal) performSegue(withIdentifier: "login_main", sender: self) ``` * 我们采用`枚举`的方式对资源名进行管理 * 这种方式是参考了`Android`的资源名管理方式 ```swift enum R { enum string: String { case add = "添加" } enum image: String { case logo } enum segue: String { case login_main } } class ViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() let img = UIImage(named: R.image.logo) let btn = UIButton(type: .custom) btn.setTitle(R.string.add, for: .normal) performSegue(withIdentifier: R.segue.login_main, sender: self) } } extension UIImage { convenience init?(named 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) } } ``` 资源名管理的其他思路原始写法如下 ```swift let img = UIImage(named: "logo") let font = UIFont(name: "Arial", size: 14) ``` ```swift enum R { enum image { static var logo = UIImage(named: "logo") } enum font { static func arial(_ size: CGFloat) -> UIFont? { UIFont(name: "Arial", size: size) } } } class ViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() let img = R.image.logo let font = R.font.arial(14) } } ``` 更多优秀的思路请参考以下链接： * [github.com/mac-cain13/R.swift](https://github.com/mac-cain13/R.swift) * [github.com/SwiftGen/SwiftGen](https://github.com/SwiftGen/SwiftGen) ## 17. 多线程开发 * 利用`DispatchWorkItem`封装常用多线程执行函数 ```swift public typealias Task = () -> Void public struct Asyncs { /// 异步执行 public static func async(_ task: @escaping Task) { _async(task) } public static func async(_ task: @escaping Task, _ mainTask: @escaping Task) { _async(task, mainTask) } /// 主线程延迟执行 @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 { _asyncDelay(seconds, task) } @discardableResult public static func asyncDelay(_ seconds: Double, _ task: @escaping Task, _ mainTask: @escaping Task) -> DispatchWorkItem { _asyncDelay(seconds, task, mainTask) } } // MARK: - 私有API extension Asyncs { 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) } } 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 } } ``` * `dispatch_once`在Swift中已被废弃，取而代之的是用`类型属性`或者`全局变量\常量` * 默认自带`lazy+dispatch_once`效果 ```swift fileprivate let initTask2: Void = { print("initTask2") }() class ViewController: UIViewController { static let initTask1: Void = { print("initTask1------------") }() override func viewDidLoad() { super.viewDidLoad() let _ = Self.initTask1 let _ = initTask2 } } ``` * 多个线程操作同一份数据会有资源抢夺问题，需要进行加锁 ```swift 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 } } ``` ```swift private static var lock = NSLock() static func set(_ key: String, _ value: Any) { lock.lock() defer { lock.unlock() } } ``` ```swift private static var lock = NSRecursiveLock() static func set(_ key: String, _ value: Any) { lock.lock() defer { lock.unlock() } } ``` # 三、函数式编程（Funtional Programming） ## 1. 基本概念函数式编程（Funtional Programming，简称FP）是一种编程范式，也就是如何编写程序的方法论 * 主要思想：把计算过程尽量分解成一系列可复用函数的调用 * 主要特征：”函数的第一等公民“，函数与其他数据类型一样的地位，可以赋值给其他变量，也可以作为函数参数、函数返回值函数式编程最早出现在`LISP`语言，绝大部分的现代编程语言也对函数式编程做了不同程度的支持，比如`Haskell、JavaScript、Swift、Python、Kotlin、Scala`等函数式编程中几个常用概念 * Higher-Order Function、Function Currying * Functor、Applicative Functor、Monad 参考资料： * [adit.io/posts/2013-…](http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html) * [mokacoding.com/blog/functor-applicative-monads-in-pictures](https://mokacoding.com/blog/functor-applicative-monads-in-pictures/) ## 2. Array的常见操作 ```swift var array = [1, 2, 3, 4] // map：遍历数组，可以将每个元素对应做调整变成新的元素，放入新的数组中 var array2 = array.map { $0 * 2 } // [2, 4, 6, 8] // filter：遍历数组，选出符合条件的元素放入新的数组中 var array3 = array.filter { $0 % 2 == 0 } // reduce：首先设定一个初始值（0） // $0：上一次遍历返回的结果（0，1，3，10） //$1：每次遍历到的数组元素（1，2，3，4） var array4 = array.reduce(0) { $0 + $1 } // 10 var array5 = array.reduce(0, +) // 同array4一样 ``` ```swift var array = [1, 2, 3, 4] func double(_ i: Int) -> Int { i * 2 } print(array.map(double)) // [2, 4, 6, 8] print(array.map { double($0) }) // [2, 4, 6, 8] ``` * 1. `map`和`flatMap、compactMap`的区别 ```swift var arr = [1, 2, 3] var arr2 = arr.map { Array(repeating: $0, count: $0) } // [[1], [2, 2], [3, 3, 3]] // flatMap会将处理完的新元素都放在同一个数组中 var arr3 = arr.flatMap { Array(repeating: $0, count: $0) } // [1, 2, 2, 3, 3, 3] ``` ```swift var arr = ["123", "test", "jack", "-30"] var arr1 = arr.map { Int($0) } // [Optional(123), nil, nil, Optional(-30)] var arr2 = arr.compactMap { Int($0) } // [123, -30] var arr3 = arr.flatMap(Int.init) ``` * 2. 使用`reduce`分别实现`map、filter`功能 ```swift var arr = [1, 2, 3, 4] // map var arr1 = arr.map { $0 * 2 } print(arr1) var arr2 = arr.reduce([]) { $0 + [$1 * 2] } print(arr1) // filter var arr3 = arr.filter { $0 % 2 == 0 } print(arr3) var arr4 = arr.reduce([]) { $1 % 2 == 0 ? $0 + [$1] : $0 } print(arr4) ``` * 3. `lazy`的优化 ```swift let arr = [1, 2, 3] let result = arr.lazy.map { (i: Int) -> Int in print("mapping (i)") return i * 2 } print("begin-----") print("mapped", result[0]) print("mapped", result[1]) print("mapped", result[2]) print("end-----") //begin----- //mapping 1 //mapped 2 //mapping 2 //mapped 4 //mapping 3 //mapped 6 //end----- ``` * 4. `Optional`的`map`和`flatMap`\ 会先将可选类型解包，处理完会再进行包装返回出去 ```swift var num1: Int? = 10 var num2 = num1.map { $0 * 2 } // Optional(20) var num3: Int? = nil var num4 = num3.map { $0 * 2 } // nil ``` ```swift var num1: Int? = 10 var num2 = num1.map { Optional.some($0 * 2) } // Optional(Optional(20)) //flatMap发现其为可选项，不会再进行包装 var num3 = num1.flatMap { Optional.some($0 * 2) } // Optional(20) var num4 = num1.flatMap { $0 * 2 } // Optional(20) ``` ```swift var num1: Int? = 10 var num2 = (num1 != nil) ? (num1! + 10) : nil // Optional(20) var num3 = num1.map { $0 + 10 } // Optional(20) ``` ```swift var fmt = DateFormatter() fmt.dateFormat = "yyyy-MM-dd" var str: String? = "2011-09-10" var date1 = str != nil ? fmt.date(from: str!) : nil // Optional(2011-09-09 16:00:00 +0000) var date2 = str.flatMap(fmt.date) // Optional(2011-09-09 16:00:00 +0000) ``` ```swift var score: Int? = 98 var str1 = score != nil ? "score is (score!)" : "No score" // score is 98 var str2 = score.map { "score is ($0)"} ?? "No score" // score is 98 ``` ```swift struct Person { var name: String var age: Int } var items = [ Person(name: "jack", age: 20), Person(name: "rose", age: 21), Person(name: "kate", age: 22) ] func getPerson1(_ name: String) -> Person? { // 遍历数组找到对应的索引 let index = items.firstIndex { $0.name == name } return index != nil ? items[index!] : nil } func getPerson2(_ name: String) -> Person? { items.firstIndex { $0.name == name } .map { items[$0] } } let p1 = getPerson1("rose") let p2 = getPerson2("rose") ``` ```swift struct Person { var name: String var age: Int init?(_ json: [String : Any]) { guard let name = json["name"] as? String, let age = json["age"] as? Int else { return nil } self.name = name self.age = age } } var json: Dictionary? = ["name" : "Jack", "age" : 10] var p1 = json != nil ? Person(json!) : nil // Optional(__lldb_expr_36.Person(name: "Jack", age: 10)) var p2 = json.flatMap(Person.init) // Optional(__lldb_expr_36.Person(name: "Jack", age: 10)) ``` ## 3. 函数式的写法 * 假如要实现以下功能: `[(num + 3) * 5 - 1] % 10 / 2` * 传统写法 ```swift var num = 1 func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 } func sub(_ v1: Int, _ v2: Int) -> Int { v1 - v2 } func multiple(_ v1: Int, _ v2: Int) -> Int { v1 * v2 } func divide(_ v1: Int, _ v2: Int) -> Int { v1 / v2 } func mod(_ v1: Int, _ v2: Int) -> Int { v1 % v2 } divide(mod(sub(multiple(add(num, 3), 5), 1), 10), 2) ``` * 函数式写法 ```swift func add(_ v: Int) -> (Int) -> Int {{ $0 + v }} func sub(_ v: Int) -> (Int) -> Int {{ $0 - v }} func multiple(_ v: Int) -> (Int) -> Int {{ $0 * v }} func divide(_ v: Int) -> (Int) -> Int {{ $0 / v }} func mod(_ v: Int) -> (Int) -> Int {{ $0 % v }} infix operator >>> : AdditionPrecedence func >>>(_ f1: @escaping (A) -> B, _ f2: @escaping (B) -> C) -> (A) -> C {{ f2(f1($0)) }} var fn = add(3) >>> multiple(5) >>> sub(1) >>> mod(10) >>> divide(2) fn(num) ``` ## 4. 高阶函数（Higher-Order Function）高阶函数至少满足下列一个条件的函数： * 接受一个或多个函数作为输入（map、filter、reduce等） * 返回一个函数 FP中到处都是高阶函数 ## 5. 柯里化（Currying） * 什么是柯里化？ * 将一个接受多参数的函数变换为一系列只接受单个参数的函数 ![-w633](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c65a4b56a69341e4831147a7e9b8de02~tplv-k3u1fbpfcp-zoom-1.image#?w=1266\&h=486\&s=19456\&e=webp\&b=fdfdfd) * `Array、Optional`的`map`方法接收的参数就是一个柯里化函数 ![-w619](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e3c435264b624d8bb4f46d786935e08e~tplv-k3u1fbpfcp-zoom-1.image#?w=1238\&h=110\&s=14802\&e=webp\&b=211f27) 演变示例 ```swift func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 } add(2 + 4) 变为函数式的写法： func add(_ v2: Int) -> (Int) -> Int { return { v1 in return v1 + v2 } } add(4)(2) 再精简： func add(_ v2: Int) -> (Int) -> Int {{ v1 in v1 + v2 }} add(4)(2) 再精简： func add(_ v: Int) -> (Int) -> Int {{ $0 + v }} add(4)(2) 柯里化： func currying(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C {{ b in { a in fn(a, b) }}} let curriedAdd = currying(add) print(curriedAdd(4)(2)) ``` ```swift func add(_ v1: Int, _ v2: Int, _ v3: Int) -> Int { v1 + v2 + v3 } add(2, 3, 5) 变为函数式的写法： func add(_ v3: Int) -> (Int) -> (Int) -> Int { // v2是3 return { v2 in // v1是2 return { v1 in return v1 + v2 + v3 } } } add(5)(3)(2) 再精简： func add(_ v3: Int) -> (Int) -> (Int) -> Int {{ v2 in { v1 in v1 + v2 + v3 }}} add(5)(3)(2) 柯里化： func currying(_ fn: @escaping (A, B, C) -> D) -> (C) -> (B) -> (A) -> D {{ c in { b in { a in fn(a, b, c) }}}} let curriedAdd = currying(add) print(curriedAdd(10)(20)(30)) ``` 一开始的示例就可以都保留旧的方法，然后通过柯里化来调用 ```swift func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 } func sub(_ v1: Int, _ v2: Int) -> Int { v1 - v2 } func multiple(_ v1: Int, _ v2: Int) -> Int { v1 * v2 } func divide(_ v1: Int, _ v2: Int) -> Int { v1 / v2 } func mod(_ v1: Int, _ v2: Int) -> Int { v1 % v2 } prefix func ~(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C {{ b in { a in fn(a, b) }}} infix operator >>> : AdditionPrecedence func >>>(_ f1: @escaping (A) -> B, _ f2: @escaping (B) -> C) -> (A) -> C {{ f2(f1($0)) }} var num = 1 var fn = (~add)(3) >>> (~multiple)(5) >>> (~sub)(1) >>> (~mod)(10) >>> (~divide)(2) fn(num) ``` ## 6. 函子（Functor） * 像`Array、Optional`这样支持`map运算`的类型，称为函子（Functor） ![-w619](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a65a70a9420e450e888edc51d3ce8fd2~tplv-k3u1fbpfcp-zoom-1.image#?w=1238\&h=110\&s=14802\&e=webp\&b=211f27) ![-w601](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3dc25bf331ae44c99d28f270dec602bf~tplv-k3u1fbpfcp-zoom-1.image#?w=1202\&h=108\&s=14936\&e=webp\&b=211f27) 下图充分解释了函子 ![-w910](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b3eff77056f149afac3c5e1a2c6b7304~tplv-k3u1fbpfcp-zoom-1.image#?w=1820\&h=838\&s=45722\&e=webp\&b=fefefe) ## 7. 适用函子（Applicative Functor）对任意一个函子`F`，如果能支持以下运算，该函子就是一个适用函子 ```swift func pure(_ value: A) -> F func <*>(fn: F<(A) -> B>, value: F ) -> F ``` * `Optional`可以成为适用函子 ```swift func pure(_ value: A) -> A? { value } infix operator <*> : AdditionPrecedence func <*>(fn: ((A) -> B)?, value: A?) -> B? { guard let f = fn, let v = value else { return nil } return f(v) } var value: Int? = 10 var fn: ((Int) -> Int)? = { $0 * 2 } print(fn <*> value as Any) // Optional(20) ``` * `Array`可以成为适用函子 ```swift func pure (_ value: A) -> [A] { [value] } infix operator <*> : AdditionPrecedence func <*>(fn: [(A) -> B], value: [A]) -> [B] { var arr: [B] = [] if fn.count == value.count { for i in fn.startIndex.. [1, 2 , 3] print(arr) // [2, 12, -2] ``` ## 8. 单子（Monad）对任意一共类型`F`，如果能支持以下运算，那么就可以称为是一个单子 ```swift func pure (_ value: A) -> F func flatMap(_ value: F , _ fn: (A) -> F) -> F ``` 很显然，`Array、Optional`都是单子 # 四、面向协议编程（Protocol Oriented Programming） ## 1. 基本概念面向协议编程（Protocol Oriented Programming，简称POP） * 是Swift的一种编程范式，`Apple`于2015年`WWDC`提出 * 在Swift标准库中，能见到大量`POP`的影子同时，Swift也是一门面向对象的编程语言（Object Oriented Programming，简称OOP）在Swift开发中，`OOP`和`POP`是相辅相成的，任何一方并不能取代另一方 `POP`能弥补`OOP`一些设计上的不足 ## 2. OOP和POP **回顾OOP** * `OOP`的三大特性：`封装`、**继承**、`多态` * 继承的经典使用场合:\ 当多个类（比如A、B、C类）具有很大共性时，可以将这些共性抽取到一个父类中（比如D类），最后A、B、C类继承D类 ![-w514](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/346429b4d3da44dd9518b93f365e4cb4~tplv-k3u1fbpfcp-zoom-1.image#?w=1028\&h=426\&s=9236\&e=webp\&b=ffffff) * **OOP的不足** * 但有些问题，使用`OOP`并不能很好解决，比如如何将BVC、DVC的`公共方法run`抽出来 ```swift class BVC: UIViewController { func run() { print("run") } } class DVC: UITableViewController { func run() { print("run") } } ``` * **基于`OOP`想到的一些解决方案：** 1.将`run方法`放到另一个对象A中，然后BVC、DVC拥有对象A属性 * 多了一些额外的依赖关系 2.将`run方法`增加到`UIViewController分类`中 * `UIViewController`会越来越臃肿，而且会影响它的其他所有子类 3.将`run方法`抽取到新的父类，采用多继承（`C++`支持多继承） * 会增加程序设计的复杂度，产生菱形继承等问题，需要开发者额外解决 **POP的解决方案** ```swift protocol Runnable { func run() } extension Runnable { func run() { print("run") } } class BVC: UIViewController, Runnable {} class DVC: UITableViewController, Runnable {} ``` ![-w447](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/73c69593f53f4225ab370615f9449cee~tplv-k3u1fbpfcp-zoom-1.image#?w=894\&h=556\&s=12426\&e=webp\&b=fefefe) **POP的注意点** * 优先考虑创建协议，而不是父类（基类） * 优先考虑值类型（struct、enum），而不是引用类型（class） * 巧用协议的扩展功能 * 不要为了面向协议而使用协议 ## 3. POP的应用下面我们利用协议来实现前缀效果 ```swift var string = "123fdsf434" protocol NameSpaceWrapperProtocol { associatedtype WrappedType var wrappedValue: WrappedType { get set } init(value: WrappedType) } struct NameSpaceWrapper: NameSpaceWrapperProtocol { var wrappedValue: T init(value: T) { self.wrappedValue = value } } protocol NamespaceWrappable { } extension NamespaceWrappable { var ll: NameSpaceWrapper { get { NameSpaceWrapper(value: self) } set {} } static var ll: NameSpaceWrapper.Type { get { NameSpaceWrapper.self } set {} } } extension NameSpaceWrapperProtocol where WrappedType: ExpressibleByStringLiteral { var numberCount: Int { (wrappedValue as? String)?.filter { ("0"..."9").contains($0) }.count ?? 0 } } extension String: NamespaceWrappable {} extension NSString: NamespaceWrappable {} print(string.ll.numberCount) print((string as NSString).ll.numberCount) // 6 ``` 利用协议实现类型判断 ```swift func isArray(_ value: Any) -> Bool { value is [Any] } print(isArray([1, 2])) // true print(isArray(["1", 2])) // true print(isArray(NSArray())) // true print(isArray(NSMutableArray())) // true protocol ArrayType {} func isArrayType(_ type: Any.Type) -> Bool { type is ArrayType.Type } extension Array: ArrayType {} extension NSArray: ArrayType {} print(isArrayType([Int].self)) // true print(isArrayType([Any].self)) // true print(isArrayType(NSArray.self)) // true print(isArrayType(NSMutableArray.self)) // true print(isArrayType(String.self)) // false ``` # 五、响应式编程（Reactive Programming） ## 1. 基本概念响应式编程（Reactive Programming，简称RP），是一种编程范式，于1997年提出，可以简化异步编程，提供更优雅的数据绑定一般与函数式融合在一起，所以也会叫做：函数响应式编程（Functional Reactive Programming，简称FRP）比较著名的、成熟的响应式框架 * **ReactiveCocoa**：简称RAC，有Objective-C、Swift版本 * **ReactiveX**：简称Rx，有众多编程语言版本，比如RxJava、RxKotlin、RxJS、RxCpp、RxPHP、RxGo、RxSwift等 ## 2. RxSwift `RxSwift`（ReactiveX for Swift），`ReactiveX`的`Swift`版本源码： [github.com/ReactiveX/R…](https://link.juejin.cn?target=https%3A%2F%2Fgithub.com%2FReactiveX%2FRxSwift "https://github.com/ReactiveX/RxSwift") [beeth0ven.github.io/RxSwift-Chi…](https://link.juejin.cn?target=https%3A%2F%2Fbeeth0ven.github.io%2FRxSwift-Chinese-Documentation%2F "https://beeth0ven.github.io/RxSwift-Chinese-Documentation/") # 六、Swift源码分析我们通过分析`Swift标准库源码`来更近一步了解Swift的语法 ## 1.Array相关 **map、filter**的源码路径:`/swift-main/stdlib/public/core/Sequence.swift` **flatMap、compactMap、reduce**的源码路径:`/swift-main/stdlib/public/core/SequenceAlgorithms.swift` ### 1.1 map ```swift @inlinable public func map( _ transform: (Element) throws -> T ) rethrows -> [T] { let initialCapacity = underestimatedCount var result = ContiguousArray() result.reserveCapacity(initialCapacity) var iterator = self.makeIterator() // Add elements up to the initial capacity without checking for regrowth. for _ in 0..( _ transform: (Element) throws -> SegmentOfResult ) rethrows -> [SegmentOfResult.Element] { var result: [SegmentOfResult.Element] = [] for element in self { // 将数组元素添加到新数组中 result.append(contentsOf: try transform(element)) } return result } ``` ### 1.3 filter ```swift @inlinable public __consuming func filter( _ isIncluded: (Element) throws -> Bool ) rethrows -> [Element] { return try _filter(isIncluded) } @_transparent public func _filter( _ isIncluded: (Element) throws -> Bool ) rethrows -> [Element] { var result = ContiguousArray() var iterator = self.makeIterator() while let element = iterator.next() { if try isIncluded(element) { result.append(element) } } return Array(result) } ``` ### 1.4 compactMap ```swift @inlinable // protocol-only public func compactMap( _ transform: (Element) throws -> ElementOfResult? ) rethrows -> [ElementOfResult] { return try _compactMap(transform) } @inlinable // protocol-only @inline(__always) public func _compactMap( _ transform: (Element) throws -> ElementOfResult? ) rethrows -> [ElementOfResult] { var result: [ElementOfResult] = [] for element in self { // 会进行解包，只有不为空才会被加到数组中 if let newElement = try transform(element) { result.append(newElement) } } return result } ``` ### 1.5 reduce ```swift @inlinable public func reduce( _ initialResult: Result, _ nextPartialResult: (_ partialResult: Result, Element) throws -> Result ) rethrows -> Result { // 上一次的结果 var accumulator = initialResult for element in self { accumulator = try nextPartialResult(accumulator, element) } return accumulator } ``` ## 2. Substring相关 **Substring**的源码路径:`/swift-main/stdlib/public/core/Substring.swift` ### 2.1初始化 ```swift @frozen public struct Substring: ConcurrentValue { @usableFromInline internal var _slice: Slice @inlinable internal init(_ slice: Slice) { let _guts = slice.base._guts let start = _guts.scalarAlign(slice.startIndex) let end = _guts.scalarAlign(slice.endIndex) // 保存传进来的字符串的内容和位置 self._slice = Slice( base: slice.base, bounds: Range(_uncheckedBounds: (start, end))) _invariantCheck() } @inline(__always) internal init(_ slice: _StringGutsSlice) { self.init(String(slice._guts)[slice.range]) } /// Creates an empty substring. @inlinable @inline(__always) public init() { self.init(Slice()) } } extension Substring { /// Returns the underlying string from which this Substring was derived. @_alwaysEmitIntoClient // _slice.base就是初始化传进来的字符串 public var base: String { return _slice.base } @inlinable @inline(__always) internal var _wholeGuts: _StringGuts { return base._guts } @inlinable @inline(__always) // 从这里也能看出和传进来的String共有的是同一块区域，在这块区域进行偏移获取Substring的内容 internal var _offsetRange: Range { return Range( _uncheckedBounds: (startIndex._encodedOffset, endIndex._encodedOffset)) } #if !INTERNAL_CHECKS_ENABLED @inlinable @inline(__always) internal func _invariantCheck() {} #else @usableFromInline @inline(never) @_effects(releasenone) internal func _invariantCheck() { // Indices are always scalar aligned _internalInvariant( _slice.startIndex == base._guts.scalarAlign(_slice.startIndex) && _slice.endIndex == base._guts.scalarAlign(_slice.endIndex)) self.base._invariantCheck() } #endif // INTERNAL_CHECKS_ENABLED } ``` ### 2.2 append ```swift extension Substring: RangeReplaceableCollection { @_specialize(where S == String) @_specialize(where S == Substring) @_specialize(where S == Array) public init(_ elements: S) where S.Element == Character { if let str = elements as? String { self.init(str) return } if let subStr = elements as? Substring { self = subStr return } self.init(String(elements)) } // Substring的拼接 @inlinable // specialize public mutating func append(contentsOf elements: S) where S.Element == Character { // 拼接时会创建一个新的字符串 var string = String(self) self = Substring() // Keep unique storage if possible string.append(contentsOf: elements) self = Substring(string) } } ``` ### 2.3 lowercased、uppercased ```swift extension Substring { public func lowercased() -> String { return String(self).lowercased() } public func uppercased() -> String { return String(self).uppercased() } public func filter( _ isIncluded: (Element) throws -> Bool ) rethrows -> String { return try String(self.lazy.filter(isIncluded)) } } ``` ## 3. Optional相关 **Optional**的源码路径:`/swift-main/stdlib/public/core/Optional.swift` ### 3.1 map ```swift @inlinable public func map( _ transform: (Wrapped) throws -> U ) rethrows -> U? { switch self { case .some(let y): // 先解包进行处理 return .some(try transform(y)) // 然后再包装一层可选类型返回出去 case .none: return .none } } ``` ### 3.2flatMap ```swift @inlinable public func flatMap( _ transform: (Wrapped) throws -> U? ) rethrows -> U? { switch self { case .some(let y): // 先进行解包 return try transform(y) // 将解包后的处理完直接给出去 case .none: return .none } } ``` ### 3.3 == * `==`两边都为`可选项` ```swift @inlinable public static func ==(lhs: Wrapped?, rhs: Wrapped?) -> Bool { switch (lhs, rhs) { case let (l?, r?): return l == r case (nil, nil): return true default: return false } } ``` * `==`左边为`可选项`，右边为`nil` ```swift @_transparent public static func ==(lhs: Wrapped?, rhs: _OptionalNilComparisonType) -> Bool { switch lhs { case .some: return false case .none: return true } } ``` * `==`左边为`nil`，右边为`可选项` ```swift @_transparent public static func ==(lhs: _OptionalNilComparisonType, rhs: Wrapped?) -> Bool { switch rhs { case .some: return false case .none: return true } } ``` * `_OptionalNilComparisonType`是一个遵守`ExpressibleByNilLiteral`协议的结构体，可以用`nil`来进行初始化 ```swift // 遵守ExpressibleByNilLiteral协议的结构体，可以用nil来进行初始化 @frozen public struct _OptionalNilComparisonType: ExpressibleByNilLiteral { /// Create an instance initialized with `nil`. @_transparent public init(nilLiteral: ()) { } } ``` ### 3.4 ?? ```swift @_transparent public func ?? (optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T { switch optional { case .some(let value): return value case .none: return try defaultValue() } } ``` ```swift @_transparent public func ?? (optional: T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T? { switch optional { case .some(let value): return value case .none: return try defaultValue() } } ``` ## 4. Metadata相关 ### 4.1 了解Metadata 首先,我们引入Apple的Metadata文档截图,了解一下 Metadata 是什么: * ![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/373359b2dadd4abf8b8e88fd2469d609~tplv-k3u1fbpfcp-watermark.image#?w=2238\&h=1680\&s=512248\&e=png\&b=0f1217) * 从上面附图中,我们不难得出结论: * **`Swift 运行时为程序中使用的每种数据类型(包括泛型类型的每个实例) 保留元数据(Metadata)记录`** * 换句话说,**Metadata就是用于保留类型信息** * （TODO：`反射`和）`调试器工具`可以使用这些元数据记录来了解有关类型的信息 * 应用:`字典转模型`、`类的底层信息获取`、`调试器调试类信息` 等 * 对于`非泛型`标称类型，这些元数据记录由**编译器静态生成** * 对于`泛型`类型的实例以及内部类型（例如元组、函数、协议组合等），元数据记录由**运行时根据需要延迟创建** * 每种类型**都有唯一的元数据记录**； * **两个元数据指针值相等，当且仅当类型相等** ### 4.2 Metadata通用信息布局 > **所有元数据记录共享一个公共标头，其中包含以下字段：** * 虚函数表的地址值，提供基本操作，例如分配、复制和销毁 * 记录类型的大小、对齐方式、步幅和其他基本属性 * 记录指针位于距元数据指针的偏移量 -1 处，即紧邻指针所引用地址之前的指针大小的字。 * `kind 字段`是一个指针大小的整数 * 描述元数据所描述的类型的种类 * 该字段位于元数据指针的偏移量 0 处 ### 4.3 当前kind值与类型关系如下： ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ee00c0a84caa4f769e4b680d1743b080~tplv-k3u1fbpfcp-watermark.image#?w=1576\&h=680\&s=209597\&e=png\&b=0e1116) * 类元数据的类型为 0，除非该类需要与 Objective-C 互操作。 * 如果类需要与 Objective-C 互操作，则 kind 字段是指向 Objective-C 元类的 isa 指针。 * 这样的指针可以与枚举元数据类型区分开来，因为它保证具有大于 2047 的值。 * 请注意，这是比 @objc 属性含义更基本的互操作意义： * 它是支持 Objective-C 所需的内容消息发送和保留/释放。 * 在为 Apple 平台构建时，所有类都需要在此级别上与 Objective-C 进行互操作。 ## 4.4 简单介绍`Class Metadata` 源码路径: * `/swift-main/include/swift/ABI/Metadata.h` * `/swift-main/include/swift/ABI/MetadataKind.def` * `/swift-main/include/swift/ABI/MetadataValues.h` * `/swift-main/include/swift/Reflection/Records.h` 文档路径: * `/swift-main/docs/ABI/TypeMetadata.rst` 在下面的布局描述中，相对于元数据指针的偏移量作为指针数组的索引给出。 * 在32位平台上，偏移1表示偏移4字节 * 在64位平台上，偏移1表示偏移8字节 **Class Metadata** 我们可以从第三方库`KaKaJSON`中的`ClassType`，以及对应`Metadata`的相关文档来分析`Class Metadata`信息 ```swift struct ClassLayout: ModelLayout { let kind: UnsafeRawPointer /// 指向父类类型的指针 let superclass: Any.Type /// The cache data is used for certain dynamic lookups; it is owned by the runtime and generally needs to interoperate with Objective-C's use /// 缓存数据用于某些动态查找；它属于运行时，通常需要与Objective-C的使用进行互操作 let runtimeReserved0: UInt let runtimeReserved1: UInt /// The data pointer is used for out-of-line metadata and is generally opaque, except that the compiler sets the low bit in order to indicate that this is a Swift metatype and therefore that the type metadata header is present let rodata: UInt /// Swift-specific class flags /// 类标志 let flags: UInt32 /// The address point of instances of this type /// 实例的地址值 let instanceAddressPoint: UInt32 /// The required size of instances of this type. 'InstanceAddressPoint' bytes go before the address point; 'InstanceSize - InstanceAddressPoint' bytes go after it /// 实例大小 let instanceSize: UInt32 /// The alignment mask of the address point of instances of this type /// 实例对齐掩码 let instanceAlignMask: UInt16 /// Reserved for runtime use /// 运行时保留字段 let reserved: UInt16 /// The total size of the class object, including prefix and suffix extents /// 类对象的大小 let classSize: UInt32 /// The offset of the address point within the class object /// 类对象地址 let classAddressPoint: UInt32 // Description is by far the most likely field for a client to try to access directly, so we force access to go through accessors /// An out-of-line Swift-specific description of the type, or null if this is an artificial subclass. We currently provide no supported mechanism for making a non-artificial subclass dynamically var description: UnsafeMutablePointer /// A function for destroying instance variables, used to clean up after an early return from a constructor. If null, no clean up will be performed and all ivars must be trivial let iVarDestroyer: UnsafeRawPointer var genericTypeOffset: Int { let descriptor = description.pointee // don't have resilient superclass if (0x4000 & flags) == 0 { return (flags & 0x800) == 0 ? Int(descriptor.metadataPositiveSizeInWords - descriptor.numImmediateMembers) : -Int(descriptor.metadataNegativeSizeInWords) } return GenenicTypeOffset.wrong } } ``` 关于MetaData的内容,若您感兴趣，可以进一步进入官方文档了解: # 七、 Swift语言特性 ## 1. 面向协议 - 从Swift基础库的角度来说，定义的协议数量远比定义的类多很多 - Swift协议可扩展，并通过扩展提供默认实现，这也是Swift面向协议的核心 - Swift协议支持泛型 - Swift协议使用范围更广，并非像OC中只有类才能遵循协议，Swift中结构体(Int、String、Array等也是结构体)、枚举、类都能遵循协议 ## 2. 枚举增强 - OC中枚举，枚举量的值都是整型数据，而Swift中，枚举量的值，除了Int，可以是字符串等类型(只能是字符串、整形、浮点型这三种) - Swift中枚举，可以增加参数 - Swift中枚举，可以增加方法 - Swift中枚举，可以遵循协议 - 很多功能的设计都依赖于Swift的枚举，如可选型的定义、Alamofire中的Result等 - 经常会遇到枚举量想跟字符串绑定，OC中枚举，需要单独去定义字典去映射，Swift则不需要，甚至可以在定义枚举的时候就处理好这种映射 ## 3. Swift中的类有更多特性 - swift中的类就是普通的一个类，并没有特定意义的基类(OC中是NSObject) - swift中的类一般不具备运行时特性，除非是继承自NSObject的类，或者是增加@objc修饰 - swift类支持内部类 - swift类泛型支持远比OC灵活和强大 - swift类支持方法重载 ## 4. 函数更灵活 - 支持函数嵌套 - 支持多返回值(新增了元组数据类型) - 支持参数默认值 ## 5. for\switch等语句更灵活 - for遍历方式更多 - switch不仅仅只支持整型，也支持字符串等类型 - 代码示例： 1、for循环 ```swift //在swift之前的版本中，声明一个空数组变量，如果不指定元素类型，会默认为元素是NSObject类型，但是现在不行，必须指定元素类型 var arr:[Int] = [1,3,2,8,6,7] //直接遍历 for i in arr{ print(i) } //元组方式遍历 for (indexTemp,valueTemp) in arr.enumerated(){ print("元素下标：(indexTemp)，元素值：(valueTemp)") } //常规方式遍历,在swift3之中已经被移除了 //for var i = 0; i0 { print(whileInt) whileInt -= 1 } print("\n\nrepeat while循环") whileInt = 10 repeat{ print(whileInt) whileInt -= 1 }while whileInt>0 /* 控制转移语句： break，终止本层循环，如一个for循环，会直接终止这个for循环 continue，只终止本轮循环，不会终止整层循环，不再执行continue之后的语句，直接开启下一次循环 return 函数体中调用，结束整个函数 */ ``` ## 6. if else ```swift // if条件语句，必须是bool值，并不是像其他语言那样非0就默认为true if cConditon1 == 1{ print(cConditon1) } else{ } //例外的情况是，if let解包可以用=号，否则必须传入bool值或进行逻辑运算 ### Switch swift中switch语句十分强大，并不限定于整型， swift中switch的case语句会默认break，不需要显示写但可以通过fallthrough，取消掉break中断，达到OC中继续执行之后的case的效果
/* */ var switchInt = 4 switch switchInt { //case 3.1..<10.2: // print("5") case let x where x<10: print("case let 的形式直接取值") case 1..<5,6...10: print("switchInt = (switchInt)") case 2: print("condition = (2)") default: print("No Result") } var switchStr = "Abc" switch switchStr { case "a","AB": print("a") //case 5: // print("5tt") case "Abc": print(switchStr) default: print("default") } var switchTuple = (5,"tuple") switch switchTuple { case (1..<6,_): print("YES") fallthrough case (_ , _): print(switchTuple) fallthrough case (4 , _): print("fallthrough 4") case (let x,"tuple")://可以用var修饰 print(x) case (let x, let y): print(x,y,"YES") default: print("default") } var switchArray = ["A","ab","AG"] switch switchArray { case ["A"]: print("A") default: print("default") } var switchRange = 1..<10 switch switchRange { case 2..<5://必须为半开区间，不能为闭区间 print(switchRange) default: print("default") } //需要注意的是 //但case变量需要和条件变量类型一致（或者case 变量所表示的区间值类型，需要和条件变量类型一致），这点是相同的， //并且比如switch条件为区间，那么case条件必须为区间，而switch条件为整型，case条件可以为整型也可以为整型区间 //switch的case下，必须携带一句可执行的语句，可以是空语句 //switch的每个case，默认包含break，不会因为漏写break而继续执行下一个case，如果想像其他语言一样，达到某个case条件时继续向下执行case，那么可以使用fallthrough关键字 //switch中的的每个case语句，条件可以是多个，表示或，用逗号隔开，只要满足其中一项，就达到这个case执行的条件 //switch中，default语句可以不写，但是必须满足所有列出的case已经穷举出switch条件所有的可能性 ``` ## 7. 类型安全 - 强类型语言：swift在变量声明的时候，必须显示的声明类型，类型一旦确定，不可更改 - 可选性的定义，使得开发者必须去考虑空的情况 - Swift是静态语言，有类型诊断，OC是动态语言 ## 8. 注重值类型 - swift与OC很大的区别之一在于，Array、Dictionary、Set等，不再是引用类型，而是基于结构体的值类型 - 我们在OC看到的绝大多数常见的数据类型，在Swift中都是值类型，甚至针对UIKit，还出了一套侧重于值类型的SwiftUI框架 ## 9. 支持运算符重载 ## 10. 变量名称更灵活 ```swift var 名字 = "name" var 🏷 = "表情" print(名字,🏷) //变量名不局限于字母 ``` ## 11. 强大的泛型支持 - 协议支持泛型 - 泛型约束更灵活多样 ## 12. 支持多种派发方式 - swift支持`静态派发（效率高）`、`动态派发`（`函数表派发`、`消息派发`）方式，OC支持`动态派发`（`消息派发`）方式。 - **1、直接派发(Direct Dispatch**)\ `静态派发`，又叫做`早期绑定`，是指在**编译期**将方法调用绑定到方法的实现上，这种派发方式非常快。\ 在编译期，编译器可以看到调用方和被调方的所有信息，直接生成跳转代码，这样在运行期就不会有其它额外的开销。并且编译器可以根据自己知道的信息进行优化，比如内联，可以极大提高程序运行效率。\ 在 Swift 中，结构体和枚举的方法调用，以及被 `final` 标记的类和类的方法，都会采用这种派发方式。\ `直接派发`是最快的,不止是因为需要调用的指令集会更少,并且编译器还能够有很大的优化空间,例如函数内联等,直接派发也有人称为静态调用。然而,对于编程来说直接调用也是最大的局限,而且因为缺乏动态性所以没办法支持继承和多态。 - **2、函数表派发(Table Dispatch)**\ `函数表派发`是编译型语言实现动态行为最常见的实现方式函数表使用了一个数组来存储类声明的每一个函数的指针.大部分语言把这个称为virtual table"虚函数表), Swift里称为“witness table.\ 每一个类都会维护一个函数表,里面记录着类所有的函数,如果父类函数被 override的话,表里面只会保存被 override之后的函数.一个子类新添加的函数,都会被插入到这个数组的最后运行时会根据这一个表去决定实际要被调用的函数查表是一种简单,易实现,而且性能可预知的方式.然而,这种派发方式比起直接派发还是慢一点从字节码角度来看,多了两次读和一次跳转,由此带来了性能的损耗.另一个慢的原因在于编译器可能会由于函数内执行的任务导致无法优化(如果函数带有副作用的话) 这种基于数组的实现,缺陷在于函数表无法拓展.子类会在虚数函数表的最后插入新的函数,没有位置可以让 extension安全地插入函数. - **3、消息机制派发(Message Dispatch)**\ `消息机制`是调用函数最动态的方式.也是Cocoa的基石,这样的机制催生了KVO, UIAppearence和 CoreData等功能.\ 这种运作方式的关键在于开发者可以在运行时改变函数的行为.不止可以通过 `swizzling`来改变,甚至可以用 `isa-swizzling`修改对象的继承关系可以在面向对象的基础上实现自定义派发.\ Swift运行时纯 Swift类的函数调用已经不再是 Objective-c的行时发消息,而是类似C++的vtable,在编译时就确定了调用哪个函数,所以没法通过 runtime获取方法、属性。\ 而Swift为了兼容 Objective-C,凡是继承自 NSObjec的类都会保留其动态性,所以我们能通过 runtime拿到他的方法。这里有一点说明:老版本的 Swift(如2.2)是编译器隐式的自动帮你加上了@objc,而4.0以后版本的 Swift编译器去掉了隐式特性,必须使用显式添加。\ 不管是纯Swift类还是继承自 NSObject的类只要在属性和方法前面添加@objc关键字就可以使用 runtime. 项目原始定义扩展值类型直接派发直接派发协议函数表派发直接派发类函数表派发直接派发继承自NSObject的类函数表派发消息机制派发 - 小结值类型总是会使用直接派发,简单易懂而`协议`和`类`的 extension都会使用直接派发 NSObject的 extension会使用消息机制进行派发 NSObject声明作用域里的函数都会使用函数表进行派发. \ 协议里声明的,并且带有默认实现的函数会使用函数表进行派发一些关键字的派发机制关键字机制 final 直接派发 dynamic 消息机制派发 @objc & @nonobjc 改变在OC里的可见性 @inline 告诉编译器可以直接派发 Swift 运行时-final @objc 可以在标记为 final的同时,也使用@objc让函数可以使用消息机制派发.这么做的结果就是,调用函数的时候会使用直接派发,但也会在 Objective-c的运行时里注册响应的 selector.函数可以响应 perform(selector)以及别的 Objective-C特性但在直接调用时又可以有直接派发的性能. ## 13. 能更灵活地支持函数式编程(链式调用) ## 14. 有命名空间 - 使得一个项目中同名文件或者同名类可以存在 ## 15. 有更严格的访问控制 - open>public>internal(默认，无需显示声明)>fileprivate>private - OC中，我们一般很少去使用访问控制符，并且OC的类，都是能被子类继承的 - Swift中，如果一个类不想被子类继承，可以用final修饰 - Swift中，open修饰的类，才能在其他模块中被访问和继承，并且open修饰的类中，如果方法或者属性有open修饰，也才能被重写 - Swift中，public修饰的类型，在其他模块只能访问，如果是类，只能被访问，不能被继承 - Swift中，internal修饰的类型（默认修饰符，无须显示声明）是默认权限. 在模块内的文件,其类定义和函数定义是互相可见的,但是模块外是不可见的,所以它又可理解为:对模块私有. - Swift中，private修饰的类型，只能在当前private修饰类型（或者变量、方法）的所在作用域内被访问 - Swift中，fileprivate修饰的类型，只能当前文件内被访问 ## 15. 代码简洁 ## 16. 写时拷贝特性(COW:CopyOnWrite) - 简而言之，写时拷贝，就是指只是单纯赋值时，不进行拷贝，而只有发生内容修改的时候才拷贝 - 如a、b、c三个变量，指向同一个值类型，此时并不会发生内容拷贝，三个变量都用的同一份内存地址 - 但是当修改b的时候，只有b的内存地址发生变化，a、c保持不变 ## 17. 区间符 [n,m]闭区间，用...表示 [n,m)半开区间，用..<表示
## 18. 语法糖 `[1, 2, 3].map{ $0 * 2 }` [1, 2, 3] 使用了, Array 实现的ExpressibleByArrayLiteral 协议, 用于接收数组的字面值 map{xxx} 使用了闭包作为作为最后一个参数时, 可以直接写在调用后面, 而且, 如果是唯一参数的话, 圆括号也可以省略闭包没有声明函数参数, 返回值类型, 数量, 依靠的是闭包类型的自动推断闭包中语句只有一句时, 自动将这一句的结果作为返回值 [图片上传失败...(image-ce962-1708916876270)] 0, 后续参数以此类推 ## 19. print函数(打印更灵活) 比OC的NSLog函数跟灵活（1）支持直接打印一个变量，不局限于NSLog只能格式化输出（2）支持,分割打印多个变量（3）支持"(变量名)"，快速格式化打印变量（4）支持多个变量打印时分隔控制(separator:默认空格 terminator:默认换行) ```swift var a = 12 print(a) print("BGG"+"66666") print("fafjfk","affdf",separator:"---") print("rrrr","hhhhh",separator:"~~",terminator:"!!!") //separator:默认空格 terminator:默认换行 print("新行吗？") print("a=(a)是整数") ``` ## 20. 其他特性 ... # 八、OC 和 Swift 的异同 ## 1. 共同点： - OC出现过的绝大多数概念，在Swift中继续有效,比如: - 内存管理(`引用计数`、自动引用计数`ARC`）、`属性`、`协议`、`接口`、`初始化`、`扩展类`、`命名参数`、`匿名函数` 等 - Swift和Objective-C **共用一套运行时环境** - Swift的类型可以桥接到Objective-C（下面我简称OC） - 反之亦然 ## 2.不同点: - Swift 更加注重安全，OC注重灵活 - Swift 中的可选类型，适用于所有数据类型，而不仅仅局限于类。相比于OC中的nil更加安全和简明 - Swift提供可选绑定、可选链条可以确保属性和方法的访问,是建立在属性值真实存在的情况下 - Swift 中 Class对象的初始化链 - [为了保证初始化过程的安全，设定了`两段式初始化`和`安全检查`](https://juejin.cn/post/7119714488181325860#heading-44) - Swift 可以进行`面向协议`编程、`函数式`编程、`面向对象`编程，OC注重`面向对象`编程 - Swift 有 `值类型`、`引用类型`，OC注重 `指针` 和 `引用` - Swift 既有`静态语言特性`又有`动态语言特性`，OC 仅有 `动态语言特性` - Swift 简洁、易读，文件结构和大部分语法简易化,只有.swift文件. 单行代码结尾不需要分号 - Swift 中的泛型类型更加方便和通用，而非OC中只能为集合类型添加泛型 - Swift 中各种方便快捷的高阶函数（函数式编程） (Swift的标准数组支持三个高阶函数：map， filter和reduce,以及map的扩展flatMap) - Swift 中函数可以当作参数或返回值，OC中不可以 - Swift 中独有的元组类型(tuples)，把多个值组合成复合值。元组内的值可以是任何类型，并不要求是相同类型的。 - ... # Swift相关的官方文档 * **1. [Swift Documentation](https://developer.apple.com/documentation/swift)** * **2. [Type Metadata](https://github.com/apple/swift/blob/main/docs/ABI/TypeMetadata.rst#nominal-type-descriptor)** * **3. [Swift Evolution](https://github.com/apple/swift-evolution)** # 专题系列文章 ## 1. 前知识 * **[01-探究iOS底层原理|综述](https://juejin.cn/post/7089043618803122183/)** * **[02-探究iOS底层原理|编译器LLVM项目【Clang、SwiftC、优化器、LLVM】](https://juejin.cn/post/7093842449998561316/)** * **[03-探究iOS底层原理|LLDB](https://juejin.cn/post/7095079758844674056)** * **[04-探究iOS底层原理|ARM64汇编](https://juejin.cn/post/7115302848270696485/)** ## 2. 基于OC语言探索iOS底层原理 * **[05-探究iOS底层原理|OC的本质](https://juejin.cn/post/7094409219361193997/)** * **[06-探究iOS底层原理|OC对象的本质](https://juejin.cn/post/7094503681684406302)** * **[07-探究iOS底层原理|几种OC对象【实例对象、类对象、元类】、对象的isa指针、superclass、对象的方法调用、Class的底层本质](https://juejin.cn/post/7096087582370431012)** * **[08-探究iOS底层原理|Category底层结构、App启动时Class与Category装载过程、load 和 initialize 执行、关联对象](https://juejin.cn/post/7096480684847415303)** * **[09-探究iOS底层原理|KVO](https://juejin.cn/post/7115318628563550244/)** * **[10-探究iOS底层原理|KVC](https://juejin.cn/post/7115320523805949960/)** * **[11-探究iOS底层原理|探索Block的本质|【Block的数据类型(本质)与内存布局、变量捕获、Block的种类、内存管理、Block的修饰符、循环引用】](https://juejin.cn/post/7115809219319693320/)** * **[12-探究iOS底层原理|Runtime1【isa详解、class的结构、方法缓存cache\_t】](https://juejin.cn/post/7116103432095662111)** * **[13-探究iOS底层原理|Runtime2【消息处理(发送、转发)&&动态方法解析、super的本质】](https://juejin.cn/post/7116147057739431950)** * **[14-探究iOS底层原理|Runtime3【Runtime的相关应用】](https://juejin.cn/post/7116291178365976590/)** * **[15-探究iOS底层原理|RunLoop【两种RunloopMode、RunLoopMode中的Source0、Source1、Timer、Observer】](https://juejin.cn/post/7116515606597206030/)** * **[16-探究iOS底层原理|RunLoop的应用](https://juejin.cn/post/7116521653667889165/)** * **[17-探究iOS底层原理|多线程技术的底层原理【GCD源码分析1:主队列、串行队列&&并行队列、全局并发队列】](https://juejin.cn/post/7116821775127674916/)** * **[18-探究iOS底层原理|多线程技术【GCD源码分析1:dispatch\_get\_global\_queue与dispatch\_(a)sync、单例、线程死锁】](https://juejin.cn/post/7116878578091819045)** * **[19-探究iOS底层原理|多线程技术【GCD源码分析2:栅栏函数dispatch\_barrier\_(a)sync、信号量dispatch\_semaphore】](https://juejin.cn/post/7116897833126625316)** * **[20-探究iOS底层原理|多线程技术【GCD源码分析3:线程调度组dispatch\_group、事件源dispatch Source】](https://juejin.cn/post/7116898446358888485/)** * **[21-探究iOS底层原理|多线程技术【线程锁：自旋锁、互斥锁、递归锁】](https://juejin.cn/post/7116898868737867789/)** * **[22-探究iOS底层原理|多线程技术【原子锁atomic、gcd Timer、NSTimer、CADisplayLink】](https://juejin.cn/post/7116907029465137165)** * **[23-探究iOS底层原理|内存管理【Mach-O文件、Tagged Pointer、对象的内存管理、copy、引用计数、weak指针、autorelease](https://juejin.cn/post/7117274106940096520)** ## 3. 基于Swift语言探索iOS底层原理关于`函数`、`枚举`、`可选项`、`结构体`、`类`、`闭包`、`属性`、`方法`、`swift多态原理`、`String`、`Array`、`Dictionary`、`引用计数`、`MetaData`等Swift基本语法和相关的底层原理文章有如下几篇: * **[01-📝Swift5常用核心语法|了解Swift【Swift简介、Swift的版本、Swift编译原理】](https://juejin.cn/post/7119020967430455327)** * **[02-📝Swift5常用核心语法|基础语法【Playground、常量与变量、常见数据类型、字面量、元组、流程控制、函数、枚举、可选项、guard语句、区间】](https://juejin.cn/post/7119510159109390343)** * **[03-📝Swift5常用核心语法|面向对象【闭包、结构体、类、枚举】](https://juejin.cn/post/7119513630550261774)** * **[04-📝Swift5常用核心语法|面向对象【属性、inout、类型属性、单例模式、方法、下标、继承、初始化】](https://juejin.cn/post/7119714488181325860)** * **[05-📝Swift5常用核心语法|高级语法【可选链、协议、错误处理、泛型、String与Array、高级运算符、扩展、访问控制、内存管理、字面量、模式匹配】](https://juejin.cn/post/7119722433589805064)** * **[06-📝Swift5常用核心语法|编程范式与Swift源码【从OC到Swift、函数式编程、面向协议编程、响应式编程、Swift源码分析】](https://juejin.cn/post/7253350009289424933)** # 其它底层原理专题 ## 1. 底层原理相关专题 * **[01-计算机原理|计算机图形渲染原理这篇文章](https://juejin.cn/post/7018755998823219213)** * **[02-计算机原理|移动终端屏幕成像与卡顿 ](https://juejin.cn/post/7019117942377807908)** ## 2. iOS相关专题 * **[01-iOS底层原理|iOS的各个渲染框架以及iOS图层渲染原理](https://juejin.cn/post/7019193784806146079)** * **[02-iOS底层原理|iOS动画渲染原理](https://juejin.cn/post/7019200157119938590)** * **[03-iOS底层原理|iOS OffScreen Rendering 离屏渲染原理](https://juejin.cn/post/7019497906650497061/)** * **[04-iOS底层原理|因CPU、GPU资源消耗导致卡顿的原因和解决方案](https://juejin.cn/post/7020613901033144351)** ## 3. webApp相关专题 * **[01-Web和类RN大前端的渲染原理](https://juejin.cn/post/7021035020445810718/)** ## 4. 跨平台开发方案相关专题 * **[01-Flutter页面渲染原理](https://juejin.cn/post/7021057396147486750/)** ## 5. 阶段性总结:Native、WebApp、跨平台开发三种方案性能比较 * **[01-Native、WebApp、跨平台开发三种方案性能比较](https://juejin.cn/post/7021071990723182606/)** ## 6. Android、HarmonyOS页面渲染专题 * **[01-Android页面渲染原理](https://juejin.cn/post/7021840737431978020/)** * **[02-HarmonyOS页面渲染原理](#) (`待输出`)** ## 7. 小程序页面渲染专题 * **[01-小程序框架渲染原理](https://juejin.cn/post/7021414123346853919)**