本文轉載自公眾號“讀芯術”(ID：AI_Discovery)。

想隨時隨地輕松變更數據格式?本文將教你5種解法!我將在Xcode Playground中創建示例函數，運行它們并觀察結果。

[[334295]]

1. map

.map 操作符允許我們轉換閉包中來自發布者的所有元素。

var subscriptions =Set<AnyCancellable>() 
                                            funcmapExample() { 
                          let subject =PassthroughSubject<Int, Never>() 
                          subject 
                              .map { (integer) in 
                                  returnString(integer) 
                          } 
                          .sink(receiveValue: { 
                              print("Value: \($0), Type: \(type(of: $0))") 
                          }) 
                          .store(in: &subscriptions) 
                          subject.send(12) 
                          subject.send(31) 
                          subject.send(55) 
                          subject.send(4) 
                          subject.send(18) 
                      } 

下面是這段代碼的作用：

• 創建一個接受Int 值的PassthroughSubject。
• 使用.map 操作符將每個接收到的Int 值轉換為String。
• 然后，訂閱發布者并打印轉換后的元素的值和類型。

向受試者發送隨機數以觀察以下結果：

還有一種巧妙的方法來使用對象的鍵路徑獲取對象的屬性：

funcmapKeyPathExample() { 
                        structCarBrand { 
                            let title:String 
                            let country:String 
                        } 
                               let carBrandsSubject =PassthroughSubject<CarBrand, Never>() 
                          carBrandsSubject 
                            .map(\.country) 
                            .sink(receiveValue: { country in 
                                print("Country:\(country)") 
                            }) 
                            .store(in: &subscriptions) 
                               carBrandsSubject.send( 
                            CarBrand(title: "MercedesBenz", country: "Germany") 
                        ) 
                               carBrandsSubject.send( 
                            CarBrand(title: "Ford", country: "USA") 
                        ) 
                               carBrandsSubject.send( 
                            CarBrand(title: "Honda", country: "Japan") 
                        ) 
                    } 

使用.map(\.country)，可以訪問CarBrand的國家屬性。然后只需打印每個國家：

2. replaceNil

顧名思義，.replaceNil 操作符將每個接收到的nil元素轉換為指定的元素：

funcreplaceNilExample() { 
                        let values: [Int?] = [123, nil, nil, 12, 10] 
                        let valuesvaluesPublisher =values.publisher 
                               valuesPublisher 
                            .replaceNil(with: 0) 
                            .map { $0! } 
                            .collect() 
                            .sink(receiveValue: { print($0) }) 
                            .store(in: &subscriptions) 
                    } 

請注意，還可以將多個操作符組合在一起以達到必要的結果。首先將每個nil 值替換為0，然后強制解開值，最后將所有值收集在一個數組中：

需要注意的是在.map 操作符中使用強制展開的方法。如果你不喜歡強行解包該怎么辦?我們還有一個.map協變量：.compactMap，它能自動轉發僅非零的那些元素：

funcreplaceNilExample() { 
                        let values: [Int?] = [123, nil, nil, 12, 10] 
                        let valuesvaluesPublisher = values.publisher 
                               valuesPublisher 
                            .replaceNil(with: 0) 
                            .compactMap { $0 } 
                            .collect() 
                            .sink(receiveValue: { print($0) }) 
                            .store(in: &subscriptions) 
    } 

3. collect

使用.collect操作符可以很容易地收集所有接收到的元素，并發出一個包含所有元素的數組：

funccollectExample() { 
                     let integers = [1, 4, 5, 12, 24, 44] 
                           let integerPublisher =integers.publisher 
                           integerPublisher 
                         .collect() 
                         .sink(receiveValue: { print($0) }) 
                         .store(in: &subscriptions) 
                 } 

于是我們得到了想要的結果：

注意，發布者必須發出.completed事件才能實現這個操作，因為.collect會一直等待，直到所有元素都發出并且發布者完成操作為止。例如，如果使用PassthroughSubject，需要在發送所有元素后發送.finished事件：

funccollectExample() { 
                     let integerPublisher =PassthroughSubject<Int, Never>() 
                           integerPublisher 
                         .collect() 
                         .sink(receiveValue: { print($0) }) 
                         .store(in: &subscriptions) 
                           integerPublisher.send(1) 
                     integerPublisher.send(4) 
                     integerPublisher.send(5) 
                     integerPublisher.send(12) 
                     integerPublisher.send(24) 
                     integerPublisher.send(44) 
                           integerPublisher.send(completion: .finished) 
                 } 

4. flatMap

.flatMap操作符允許我們將給定的發布者轉換為另一個發布者。來看看它是如何將觀察結果從Network更改為isAvailable主題：

funccollectExample() { 
                     let integerPublisher =PassthroughSubject<Int, Never>() 
                           integerPublisher 
                         .collect() 
                         .sink(receiveValue: { print($0) }) 
                         .store(in: &subscriptions) 
                           integerPublisher.send(1) 
                     integerPublisher.send(4) 
                     integerPublisher.send(5) 
                     integerPublisher.send(12) 
                     integerPublisher.send(24) 
                     integerPublisher.send(44) 
                           integerPublisher.send(completion: .finished) 
                 } 

當更改它的值時，我們要打印出isAvailable值。首先，它打印初始值(正在使用CurrentValueSubject)，一旦為其分配了新值，就會發生以下情況：

5. scan

.scan操作符能夠在閉包中公開當前發出的值以及最新的值。可以使用它來累積值并打印總結果：

funcflatMapExample() { 
                     structNetwork { 
                         let title:String 
                         let isAvailable =CurrentValueSubject<Bool, Never>(false) 
                     } 
                           let wifi =Network(title: "Wi-Fi") 
                           let networkSubject = CurrentValueSubject<Network, Never>(wifi) 
                           networkSubject 
                         .flatMap ({ 
                             return$0.isAvailable 
                         }) 
                         .sink(receiveValue: { 
                             print("Is networkenabled: \($0)") 
                         }) 
                         .store(in: &subscriptions) 
                           wifi.isAvailable.value=true 
                           wifi.isAvailable.value=false 
                 } 

在這里，執行的是以下操作：

• 創建收益數組(下劃線是將數字中的千單位分開的好方法)。
• 創建這些收益的發布者。
• 使用.scan操作符，將當前發出的值($0)添加到從零開始的最新值($1)。

最后，計算出總收益：

【責任編輯：趙寧寧 TEL：（010）68476606】