RxSwift地图和flatMap的区别

Question

我无法理解map和flatMap在RxSwift中的区别.在RxSwift操场示例和书籍中,flatMap用作转换Observables,它具有内部Observable属性.

但是我看到flatMap直接用于基本类型的Observable.例如,对于下面的代码,它们都产生相同的输出.有人可以帮我理解map和flatMap之间的区别

struct Student {
    let score:Int
}

let ryan = Student(score:80)
let student = PublishSubject<Student>()

let deneme = student.map({ val in
    return Student(score: val.score+10)
})
deneme.subscribe(onNext: {
    print("StudentMAP: \($0.score)")
})

let deneme2 = student.flatMap({ val -> Observable<Student> in
    return Observable.of(Student(score: val.score + 10))
})

deneme2.subscribe(onNext: {
    print("StudentFlatMAP: \($0.score)")
})

 student.onNext(ryan)

Answer 1

map从流中获取值并返回任何类型的另一个值,结果是Observable <whatever type>.

flatMap从流中获取值并返回任何类型的Observable.

这意味着您可以在以下情况下使用flatMap:

• 你已经声明了一个返回Observable <？的函数.>,所以你可能想在flatMap中使用它

  func foo(_ number: Int) -> Observable<String> {
      return Observable.just(String(number))
  }
  
  Observable.just(1)
      .flatMap { (number) -> Observable<String> in
          return foo(number)
  }
  

• 您需要返回的值在流中推送多个值

  func updates() -> Observable<String> {
      // Something that generates updates
  }
  
  func shouldListenToUpdated() -> Observable<Bool> {
      return Observable.just(true)
  }
  
  shouldListenToUpdated()
      .flatMap { (listenToUpdated) -> Observable<String> in
          return listenToUpdated ? updates() : Observable.empty()
  }
  

而map只会转换流中的下一个值.

希望这能澄清一些事情.

Answer 2

为了简单起见，当您想在流中返回 Observable 时使用 flatMap。使用 map 只是转换 observable 的值并向下传递

平面图：

response.flatMap { response, _ -> Observable<NSString> in
        guard let value = response.allHeaderFields["string"] as? NSString
            else {
                return Observable.empty()
        }

        return Observable.just(value)
        }.subscribe(onNext: { [weak self]  string in
            print(string)
        }).disposed(by: bag)

地图：

 response.filter { response, _  in
            return 200..<300 ~= response.statusCode
            }.map { _ , data -> [[String: Any]] in

                guard let jsonObject = try? JSONSerialization.jsonObject(with: data, options: []),
                    let result = jsonObject as? [[String: Any]] else {
                        return []
                }
                return result
            }.subscribe(onNext: { [weak self] objects in
                print(objects)
            }).disposed(by: bag)

Answer 3

flatMap与map类似，但它将 observable 的元素转换为序列的 observable。您使用的示例相对简单，它只是发送并将 Observable 映射到其他内容。

这是反应式扩展文档的引用，

FlatMap 运算符通过将您指定的函数应用于源 Observable 发出的每个项目来转换 Observable，其中该函数返回一个本身发出项目的 Observable。然后，FlatMap 合并这些生成的 Observables 的发射，将这些合并的结果作为自己的序列发射。

这个方法很有用，例如，当你有一个 Observable 发出一系列本身具有 Observable 成员或以其他方式可转换为 Observable 的项目时，这样你就可以创建一个新的 Observable 来发出由 Observable 发出的项目的完整集合。这些项目的子可观察量。

如果稍微扩展一下这个例子，你就会知道flatMap实际上将每个元素转换成一个序列。

请注意，您使用了，

student.onNext(ryan)

删除 dename2 并在下面添加此代码，

let studentObservable: PublishSubject<Student> = PublishSubject()

let deneme2 = student.flatMap({ val -> Observable<Student> in
    return studentObservable.map { val in Student(score: val.score + 10) }
})

deneme2.subscribe(onNext: {
    print("StudentFlatMAP: \($0.score)")
})

student.onNext(ryan)

studentObservable.onNext(Student(score: 80))
studentObservable.onNext(Student(score: 90))
studentObservable.onNext(Student(score: 100))

现在，您可以看到map会简单地转换序列中的值，并创建新的Observable ，而flatMap将其转换为序列。现在，每个 flatMapped 元素本身都可以发出值，因为它们本身就是流。