# 招聘 > 如果你看完觉得这篇文章对你有帮助，想和我们一起共事，欢迎加入字节跳动国际化短视频产品研发团队，团队与岗位介绍在文末 > # 正文开始现代高级语言中，一般都会对集合类型提供高阶函数来简化开发者的代码，大幅提高代码逻辑的可读性。`Swift`也是如此，像在Swift的数组中的`filter`，`forEach`，`map`，`compactMap`，`flatMap`, `reduce`等。接下来让我们一个一个来看他内部源码，剖析实现逻辑。 1. # `filter` `filter`函数的作用类似一个元素过滤器，传入一个过滤规则的闭包，返回满足过滤条件的数组在我们解决调试环境的时候已经得知`filter`函数会调用内部`_filter`函数,不过如果我们去搜`filter`方法会发现好多地方实现了这个方法，而且实现方式还不太一样。我们还是一步一步来。通过断点，我们首先会进入如下代码： ``` extension _ArrayProtocol { // Since RangeReplaceableCollection now has a version of filter that is less // efficient, we should make the default implementation coming from Sequence // preferred. @inlinable public __consuming func filter( _ isIncluded: (Element) throws -> Bool ) rethrows -> [Element] { return try _filter(isIncluded) } } ``` 先不着急着进`_filter`，看看注释，大致意思是说由于 `RangeReplaceableCollection` 现在有一个效率较低的过滤器版本，我们应该首选来自 `Sequence` 的默认实现。盲猜感觉是`_ArrayProtocol`的父协议，父协议的`_filter`实现的不好，然后要用`Sequence` 的默认实现，也就是我们调用的`_filter`是`Sequence`的默认实现。这个时候我们step into`_filter`方法可以看到如下代码： ``` extension Sequence { @inlinable public __consuming func filter( _ isIncluded: (Element) throws -> Bool ) rethrows -> [Element] { return try _filter(isIncluded) } public func _filter( _ isIncluded: (Element) throws -> Bool ) rethrows -> [Element] { // 定义一个连续数组`result`，用于存储过滤后的元素 var result = ContiguousArray() // 使用`makeIterator()`方法创建一个迭代器，用于访问集合中的每一个元素 var iterator = self.makeIterator() // 使用`while let`结构，通过调用迭代器的`next()`方法在集合中不断取下一个元素 while let element = iterator.next() { // 如果闭包`isIncluded`返回`true`，那么就将这个元素添加到`result`数组中 if try isIncluded(element) { result.append(element) } } // 将连续数组`result`转换为数组并返回 return Array(result) } } ``` `_filter`本身的逻辑不复杂，笔者也加了注释，创建一个`ContiguousArray`数组，然后通过迭代器逐个迭代匹配，能够匹配到就放到`ContiguousArray`中，最后将`ContiguousArray`转成`Array`返回。这边主要还是剖析其他内容，首先至少说明`_ArrayProtocol`协议继承自`Sequence`，不然咱们进不到这个方法.另外我们看到`Sequence`里有`_ArrayProtocol`一模一样的`filter`方法，先不纠结，我们来看看`_ArrayProtocol`的定义 ``` @usableFromInline internal protocol _ArrayProtocol : RangeReplaceableCollection, ExpressibleByArrayLiteral where Indices == Range { ... } ``` 没看到`Sequence`，倒是看到了之前注释里说的有个效率较低的`filter`版本的`RangeReplaceableCollection`。没关系，一路往上找我们可以看到如下定义： ``` public protocol RangeReplaceableCollection: Collection where SubSequence: RangeReplaceableCollection { ... } public protocol Collection: Sequence { } ``` 所以这些协议的继承关系是: `Sequence` -> `Collection` -> `RangeReplaceableCollection` -> `_ArrayProtocol`。所以注释的意思其实是`RangeReplaceableCollection`重写了`filter`，但是效率低，所以我要继续重写调用效率高的`Sequence`里的`filter`逻辑。那么，我们来看看效率低的和效率高的方法有什么区别 ``` extension RangeReplaceableCollection { //效率低的 @inlinable @available(swift, introduced: 4.0) public __consuming func filter( _ isIncluded: (Element) throws -> Bool ) rethrows -> Self { var result = Self() for element in self where try isIncluded(element) { result.append(element) } return result } } extension Sequence { //效率高的 public func _filter( _ isIncluded: (Element) throws -> Bool ) rethrows -> [Element] { // 定义一个连续数组`result`，用于存储过滤后的元素 var result = ContiguousArray() // 使用`makeIterator()`方法创建一个迭代器，用于访问集合中的每一个元素 var iterator = self.makeIterator() // 使用`while let`结构，通过调用迭代器的`next()`方法在集合中不断取下一个元素 while let element = iterator.next() { // 如果闭包`isIncluded`返回`true`，那么就将这个元素添加到`result`数组中 if try isIncluded(element) { result.append(element) } } // 将连续数组`result`转换为数组并返回 return Array(result) } } ``` 这边主要的区别就是一个是用`ContiguousArray`连续数组来提高性能,`ContiguousArray`可以更好的利用CPU缓存，尤其在处理大量数据时会更加明显，内部细节咱们可以后续探究，暂时先不展开。另外一个是用迭代器来替代`for-in`循环，目前了解到的信息(From GPT4.0)`for-in`底层实际上也是使用 iterator 来实现的，这边估计对性能应该没啥影响，这个实现应该在编译阶段就处理了。 - 笔者认为`filter`设计的比较好的点 - `isIncluded`会`throws`异常，通过`if try`和`rethrows`将异常回抛给调用层处理 - 使用`ContiguousArray`连续数组来提高性能 - 笔者还有疑惑的点 - 既然`RangeReplaceableCollection`里的`filter`效率低，为啥不删了他，直接用`Sequence`的 - https://forums.swift.org/t/why-not-delete-the-filter-of-rangereplaceablecollection-and-use-sequence-filter-directly/67063 2. # `forEach` `forEach`函数的作用就像他的函数名字定义，就是一个遍历，每个元素会按顺序逐个调用传入的闭包 ``` @_semantics("sequence.forEach") @inlinable public func forEach( _ body: (Element) throws -> Void ) rethrows { for element in self { try body(element) } } ``` 这个原理相当简单了，就是`for`循环，然后每次循环中去调用传递进来的闭包。 - 设计的比较好的点 - 和`filter`一样的异常回抛机制 3. # `map` `map`是Swift 集合类型的函数，用于将集合的每一个元素通过某个函数进行转换，然后返回一个新的包含已转换元素的集合以下是 code for debug： ``` let numbers = [1, 2, 3, 4, 5] let squaredNumbers = numbers.map { $0 * $0 } print(squaredNumbers) // 输出: [1, 4, 9, 16, 25] ``` 当我们断点调试进入map方法时可以看到如下代码（笔者加了注释）： ``` @inlinable public func map( _ transform: (Element) throws -> T ) rethrows -> [T] { // 获取集合元素的数量 let n = self.count // 如果元素数量为0，则直接返回一个空数组 if n == 0 { return [] } // 初始化一个连续数组结果，用于储存转换后的元素 var result = ContiguousArray() // 因为总数已知，预先分配内存空间，以优化性能 result.reserveCapacity(n) // 获取集合的起始索引，这边是array，其实就是0。如果是一些数组切片的类这里就不是0了 var i = self.startIndex // 遍历集合中的每个元素 for _ in 0.. - 函数巧妙的定义了`Element`和`T`,让我们返回的元素类型可以和之前的不一样 - 定义在了`Collection`协议中，并且使用通用的index遍历方式适配各种`Collection`类型 4. # `compactMap` `compactMap`同样用于将集合的元素进行转换，但它和map的区别是会自动移除转换结果为 nil 的元素。即，它不仅可以转换数组元素，还会过滤掉转换结果为 nil 的元素，返回不含 nil 的新数组。以下是code for debug： ``` let stringArray: [String] = ["1", "2", "three", "4", "five"] let intArray: [Int] = stringArray.compactMap { Int($0) } print(intArray) // 输出: [1, 2, 4] ``` 当我们断点调试进入`compactMap`方法的时候可以看到： ``` extension Sequence { @inlinable public func compactMap( _ transform: (Element) throws -> ElementOfResult? ) rethrows -> [ElementOfResult] { return try _compactMap(transform) } @inlinable @inline(__always) public func _compactMap( _ transform: (Element) throws -> ElementOfResult? ) rethrows -> [ElementOfResult] { // 创建一个空数组 result，此数组用于存储经过转换并成功解包的元素。 var result: [ElementOfResult] = [] // 使用 for-in 循环遍历 Sequence 中的每一个元素。 for element in self { // 尝试用闭包 transform 来转换每一个元素， // 如果转换成功并且结果不为 nil，则将解包后的结果添加到结果数组中。 if let newElement = try transform(element) { result.append(newElement) } } // 返回结果数组。 return result } } ``` 可以看到`compactMap`调用了内部的`_compactMap`方法，正在的实现在`_compactMap`中。最关键的是这里： ``` if let newElement = try transform(element) { result.append(newElement) } ``` 增加了对`newElement`的判断，空的话就不会`append`了。 - 设计的比较好的点 - `compactMap`的遍历采用了` for element in self `的方式，个人感觉比map的遍历要简洁易读。 5. # `flatMap` 在 Swift 4.1 之前，`flatMap` 有两个版本，一种用于消除嵌套（平铺数组），另一种用于移除 nil。但在 Swift 4.1 之后，处理 nil 的那个版本被 compactMap 取代了。现在 flatMap 主要用于处理嵌套的数组。对于Swift历史不了解的可能比较懵，其实我们上面看的`compactMap`就是从flatMap里分化出来的，分化的点就是传递的闭包函数会不会返回空，会就走`compactMap`，不会就走`flatMap`的`平铺数组`能力。分化点的设计相当巧妙，让我们一起来看下，这里先埋个伏笔。我们把之前`compactMap`的测试代码直接替换成调用`flatMap`: ``` let stringArray: [String] = ["1", "2", "three", "4", "five"] let intArray: [Int] = stringArray.flatMap { Int($0) } //compactMap{Int($0)} print(intArray) // 输出: [1, 2, 4] ``` 然后断点调试进入`flatMap`方法： ``` extension Sequence { @available(swift, deprecated: 4.1/*, obsoleted: 5.1 */, renamed: "compactMap(_:)", message: "Please use compactMap(_:) for the case where closure returns an optional value") public func flatMap( _ transform: (Element) throws -> ElementOfResult? ) rethrows -> [ElementOfResult] { return try _compactMap(transform) } } ``` 很简单直接左手转右手调用了`compactMap`一样调用的`_compactMap`方法。从定义上看apple更希望这种情况让我们直接调用`compactMap(_:)`方法。好接下去我们注释掉刚刚的测试代码，添加下面的测试代码： ``` //let stringArray: [String] = ["1", "2", "three", "4", "five"] //let intArray: [Int] = stringArray.flatMap { Int($0) } //print(intArray) // 输出: [1, 2, 4] let nestedArray = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] let flatArray = nestedArray.flatMap { $0 } print(flatArray) // 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9] ``` 当我们再次断点调试进来的时候，会发现我们进了另外一个方法 ``` extension Sequence { @inlinable public func flatMap( _ transform: (Element) throws -> SegmentOfResult ) rethrows -> [SegmentOfResult.Element] { var result: [SegmentOfResult.Element] = [] for element in self { result.append(contentsOf: try transform(element)) } return result } } ``` 方法体实现不难理解，就是遍历后通过调用`append(contentsOf:)`来实现平铺的能力。但是为什么会进这里呢？其实仔细看实现会发现，方法定义是有区别的： ``` _ transform: (Element) throws -> ElementOfResult? _ transform: (Element) throws -> SegmentOfResult ``` 对，区别就是传递的闭包会不会返回nil，如果编译器判断会返回nil，那么编译阶段就会确定调用上面的方法，否则就调用平铺的方法。的确很容易混淆，难怪apple要分离出`compactMap` - 设计的比较好的点 - 巧妙的运用了闭包的返回值是否会nil，将接口方法的两个实现分离。不过个人认为这样违背了设计上的单一职责的原则，apple后续做分离是正确的。 6. # `reduce` `reduce` 常用于将所有元素组合成一个值。它使用一个初始的累加值和一个闭包作为参数。闭包接受两个参数，一个是之前调用的结果（对于第一次调用则是初始值），另一个是集合中的元素。返回的结果会在下次调用这个闭包时作为输入参数 code for debug ``` let numbers = [1, 2, 3, 4, 5] let sum = numbers.reduce(0, { (total, num) in return total + num }) print(sum) // 输出 15 ``` 当我们断点进入reduce方法的时候可以看到如下代码： ``` extension Sequence { @inlinable public func reduce( _ initialResult: Result, _ nextPartialResult: (_ partialResult: Result, Element) throws -> Result ) rethrows -> Result { // 初始化累加器为 initialResult var accumulator = initialResult // 使用 for-in 循环来遍历序列中的每一项 for element in self { // 使用闭包 nextPartialResult 来处理每一个元素，更新accumulator的值 accumulator = try nextPartialResult(accumulator, element) } // 返回累加器的结果，也就是把所有元素reduce之后的结果 return accumulator } } ``` 逻辑并不复杂，通过持续的传入`accumulator`给累加器来达到累加的目的。 # 总结一下 Array系列的高阶函数其实是Collection的高阶函数，同样适合与Dictionary，Set等其他集合类型。整体的设计也比较巧妙，用到了很多Swift特有的Protocol特性，对我们日后设计Swift代码也会有一些启发。另外，了解了高阶函数的原理对于我们对高阶函数的理解会更深刻，合理使用后续能简化我们日常的代码。 # 招聘 > 如果你看完觉得这篇文章对你有帮助，想和我们一起共事，欢迎加入字节跳动国际化短视频产品研发团队 ## 团队介绍国际化短视频产品研发团队，旨在实现字节跳动国际化短视频业务的研发工作，搭建及维护业界领先的产品。加入我们，你能接触到包括用户增长、社交直播、内容创造、内容消费等核心业务场景，支持产品在全球赛道上高速发展；也能接触到包括服务架构、基础技术等方向上的技术挑战，保障业务持续高质量、高效率、且安全地为用户服务；同时还能为不同业务场景提供全面的技术解决方案，优化各项产品指标及用户体验。在这里，有大牛带队与大家一同不断探索前沿，突破想象空间。在这里，你的每一行代码都将服务亿万用户。在这里，团队专业且纯粹，合作氛围平等且轻松。以下岗位可base上海、杭州、北京。 ## iOS 高级研发工程师 #### 岗位描述 1. 负责国际化短视频产品内容发现方向的iOS研发、功能实现和产品迭代； 2. 与产品设计配合，深度参与需求评审，功能定义，体验优化等关键讨论； 3. 设计良好的技术架构，推进并优化代码的健壮性、可维护性，并编写清晰的技术文档。 #### 岗位要求 1. 本科及以上计算机相关专业毕业，2年以上相关工作经验； 1. 有较强的学习能力，将新技术应用到业务实际场景中，推动技术迭代； 1. 有良好的编程习惯，代码结构清晰，命名规范； 1. 熟练掌握 Objective-C 或 Swift 语言，熟悉App开发的主流框架和开发模式； 1. 对软件产品有强烈的责任心，具备良好的沟通能力和优秀的团队协作能力。 ##