1. 操作符
  2. 数学和聚合
  3. Concat

Concat

从两个或多个 Observable 发射数据，但不交织它们。

Concat 操作符连接多个 Observable 的输出，使它们像单个 Observable 一样，第一个 Observable 发射的所有数据在第二个 Observable 发射任何数据之前都被发射（如果有超过两个 Observable，则依此类推）。

Concat 等待前面的 Observable 完成，然后再订阅你传递给它的每个额外的 Observable。注意，由于这一点，如果你尝试连接一个“热”Observable（即一个立即开始发射数据，并且在它被订阅之前就開始发射数据的 Observable），Concat 将看不到，因此也不会发射该 Observable 在所有之前的 Observable 完成且 Concat 订阅它之前发射的任何数据。

在一些 ReactiveX 实现中，还有一个 ConcatMap 操作符（也称为 concat_all、concat_map、concatMapObserver、for、forIn/for_in、mapcat、selectConcat 或 selectConcatObserver），它将源 Observable 发射的项目转换为相应的 Observable，然后按观察和转换它们的顺序连接这些 Observable 发射的项目。

The StartWith 操作符类似于 Concat，但它是前置而不是附加项目或项目发射，以源 Observable 发射的项目或项目发射。

The Merge 操作符也类似。它组合两个或多个 Observable 的发射，但可能会交织它们，而 Concat 永远不会交织多个 Observable 的发射。

另请参见

特定语言信息

concat

在 RxClojure 中，concat 将一些单个 Observable 连接在一起，按给定的顺序排列。

concat*

concat* 操作符将 Observable 发射的 Observable 连接在一起，按它们发射的顺序排列。

RxCpp 将此操作符实现为 concat

concat
concat

RxGroovy 将此操作符实现为 concat。此操作符有变体，它们将两个到九个 Observable 作为参数，并按它们在参数列表中出现的顺序连接它们。还有一个变体，它将 Observable 的 Observable 作为参数，并按它们发射的顺序连接这些 Observable 的每一个。

示例代码

odds  = Observable.from([1, 3, 5, 7]);
evens = Observable.from([2, 4, 6]);

Observable.concat(odds, evens).subscribe(
  { println(it); },                          // onNext
  { println("Error: " + it.getMessage()); }, // onError
  { println("Sequence complete"); }          // onCompleted
);
1
3
5
7
2
4
6
Sequence complete

还有一个实例方法 concatWith，使得 Observable.concat(a,b) 等价于 a.concatWith(b)。

concat

RxJava 将此操作符实现为 concat。此操作符有变体，它们将两个到九个 Observable 作为参数，并按它们在参数列表中出现的顺序连接它们。还有一个变体，它将 Observable 的 Observable 作为参数，并按它们发射的顺序连接这些 Observable 的每一个。

还有一个实例方法 concatWith，使得 Observable.concat(a,b) 等价于 a.concatWith(b)。

待定

RxJS 将此操作符实现为 concat 和 concatAll。

concat

concat 将可变数量的 Observable（或 Promise）作为参数（或单个 Observable 或 Promise 数组），并按它们在参数列表（或数组）中出现的顺序连接它们。它既存在于 Observable 原型方法中，也存在于实例方法中。

concatAll

concatAll 是一个实例方法，它对 Observable 的 Observable 进行操作，按它们发射的顺序连接这些 Observable 的每一个。

concat 和 concatAll 存在于以下每个发行版中

  • rx.js
  • rx.all.js
  • rx.all.compat.js
  • rx.compat.js
  • rx.lite.js
  • rx.lite.compat.js
concat

RxKotlin 将此操作符实现为 concat。此操作符有变体，它们将两个到九个 Observable 作为参数，并按它们在参数列表中出现的顺序连接它们。还有一个变体，它将 Observable 的 Observable 作为参数，并按它们发射的顺序连接这些 Observable 的每一个。

还有一个实例方法 concatWith，使得 Observable.concat(a,b) 等价于 a.concatWith(b)。

Concat

Rx.NET 将此操作符实现为 Concat。它接受 Observable 的可枚举对象、Observable 的 Observable 或两个 Observable 作为参数，并按给定的顺序连接它们。

RxPHP 将此操作符实现为 concat。

将一个 Observable 序列连接到源 Observable 的末尾。

示例代码

//from https://github.com/ReactiveX/RxPHP/blob/master/demo/concat/concat.php


$source1 = \Rx\Observable::of(42);
$source2 = \Rx\Observable::of(56);

$source = \Rx\Observable::empty()->concat($source1)->concat($source2);

$subscription = $source->subscribe($stdoutObserver);

   
Next value: 42
Next value: 56
Complete!

RxPHP 还有一个操作符 concatAll。

将一个 Observable 序列序列连接成一个 Observable 序列。

示例代码

//from https://github.com/ReactiveX/RxPHP/blob/master/demo/concat/concatAll.php

$source = Rx\Observable::range(0, 3)
    ->map(function ($x) {
        return \Rx\Observable::range($x, 3);
    })
    ->concatAll();

$subscription = $source->subscribe($stdoutObserver);

   
Next value: 0
Next value: 1
Next value: 2
Next value: 1
Next value: 2
Next value: 3
Next value: 2
Next value: 3
Next value: 4
Complete!
concat

在 RxPY 中，concat 将可变数量的 Observable 作为参数（或 Observable 数组），并按它们在参数列表（或数组）中出现的顺序连接它们。

concat_all

concatAll 对 Observable 的 Observable 进行操作，按它们发射的顺序连接这些 Observable 的每一个。

concat

在 Rx.rb 中，concat 操作符作为实例操作符对两个 Observable 进行操作，或作为类方法对 Observable 数组进行操作。

merge_all

merge_all 操作符，尽管它的名字，但在 Rx.rb 中实际上表现得像 Concat 变体。它接受 Observable 的 Observable 作为参数，并连接这些 Observable 的发射。

RxScala 以两种方式实现了此操作符。有一个 concat 操作符，它接受 Observable 的 Observable 作为参数，然后按它们发射的顺序连接这些 Observable 的每一个。还有一个 ++ 操作符，它将一个 Observable 连接到另一个。

plus-plus

待定