1. 运算符
  2. 过滤
  3. Distinct

Distinct

抑制 Observable 发出的重复项

Distinct 运算符通过仅允许尚未发出过的项通过来过滤 Observable。

在一些实现中，存在允许您调整两个项被认为“不同”的标准的变体。在一些实现中，该运算符有一个变体，它仅将一个项与其直接前驱项进行比较以判断是否不同，从而从序列中过滤掉仅连续的重复项。

另请参见

特定于语言的信息

待定

待定

distinct

RxGroovy 将此运算符实现为 distinct。

distinct

此运算符还有一个变体，它接受一个函数作为参数。此函数对源 Observable 发出的项进行操作以生成一个“键”。然后是这些键，而不是项本身，distinct 将用于比较以确定两个项是否不同。

distinctUntilChanged

RxGroovy 还实现了 distinctUntilChanged 运算符。它仅将源 Observable 发出的项与其直接前驱项进行比较，以确定它们是否不同。

distinctUntilChanged

与 distinct 一样，distinctUntilChanged 也有一个接受键选择器函数的版本，该函数使用生成的键来确定两个相邻发出的项是否不同。

distinct 和 distinctUntilChanged 默认情况下不会在任何特定的 Scheduler 上运行。

distinct

RxJava 将此运算符实现为 distinct。

示例代码

Observable.just(1, 2, 1, 1, 2, 3)
          .distinct()
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });
Next: 1
Next: 2
Next: 3
Sequence complete.
distinct

此运算符还有一个变体，它接受一个函数作为参数。此函数对源 Observable 发出的项进行操作以生成一个“键”。然后是这些键，而不是项本身，distinct 将用于比较以确定两个项是否不同。

distinctUntilChanged

RxJava 还实现了 distinctUntilChanged 运算符。它仅将源 Observable 发出的项与其直接前驱项进行比较，以确定它们是否不同。

distinctUntilChanged

与 distinct 一样，distinctUntilChanged 也有一个接受键选择器函数的版本，该函数使用生成的键来确定两个相邻发出的项是否不同。

distinct 和 distinctUntilChanged 默认情况下不会在任何特定的 Scheduler 上运行。

待定

distinct

在 RxJS 中，distinct 运算符有两个可选参数

  1. 一个函数，它接受源 Observable 发出的项，并返回一个将在比较两个项以判断是否不同时用于代替项本身的键
  2. 一个函数，它接受两个项（或两个键）并将它们进行比较以判断是否不同，如果它们不同则返回 false（如果这里不提供自己的函数，则默认使用相等函数）

示例代码

/* Without key selector */
var source = Rx.Observable.fromArray([
        42, 24, 42, 24
    ])
    .distinct();

var subscription = source.subscribe(
    function (x) { console.log('Next: ' + x.toString()); },
    function (err) { console.log('Error: ' + err); },
    function () { console.log('Completed'); });
Next: 42
Next: 24
Completed
/* With key selector */
var source = Rx.Observable.fromArray([
        {value: 42}, {value: 24}, {value: 42}, {value: 24}
    ])
    .distinct(function (x) { return x.value; });

var subscription = source.subscribe(
    function (x) {
        console.log('Next: ' + x.toString());
    },
    function (err) {
        console.log('Error: ' + err);
    },
    function () {
        console.log('Completed');
    });
Next: { value: 42 }
Next: { value: 24 }
Completed
distinctUntilChanged

RxJS 还具有 distinctUntilChanged 运算符。它仅将源 Observable 发出的项与其直接前驱项进行比较，以确定它们是否不同。它接受与 distinct 运算符相同的两个可选参数。

示例代码

/* Without key selector */
var source = Rx.Observable.fromArray([
        24, 42, 24, 24
    ])
    .distinctUntilChanged();

var subscription = source.subscribe(
    function (x) { console.log('Next: ' + x); },
    function (err) { console.log('Error: ' + err); },
    function () { console.log('Completed'); });
Next: 24
Next: 42
Next: 24
Completed
/* With key selector */
var source = Rx.Observable.fromArray([
        {value: 24}, {value: 42}, {value: 42}, {value: 24}
    ])
    .distinctUntilChanged(function (x) { return x.value; });

var subscription = source.subscribe(
    function (x) { console.log('Next: ' + x.toString()); },
    function (err) { console.log('Error: ' + err); },
    function () { console.log('Completed'); });
Next: { value: 24 }
Next: { value: 42 }
Next: { value: 24 }
Completed

distinct 和 distinctUntilChanged 存在于以下每个发行版中

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

待定

待定

RxPHP 将此运算符实现为 distinct。

返回一个仅包含根据 keySelector 和 comparer 不同的元素的可观察序列。由于维护内部查找结构，该结构可能变得很大，因此应谨慎考虑使用此运算符。

示例代码

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

$source = \Rx\Observable::fromArray([
    42, 24, 42, 24
])->distinct();

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

   
Next value: 42
Next value: 24
Complete!

RxPHP 还具有运算符 distinctKey。

distinct 的变体，它接受一个键选择器

示例代码

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

$source = \Rx\Observable::fromArray([
    ['id' => '42'],
    ['id' => '24'],
    ['id' => '42'],
    ['id' => '24']
])
    ->distinctKey(function ($x) {
        return $x['id'];
    })
    ->map(function ($x) {
        return $x['id'];
    });

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

   
Next value: 42
Next value: 24
Complete!

RxPHP 还具有运算符 distinctUntilChanged。

distinct 的变体，它仅将源 Observable 发出的项与其直接前驱项进行比较，以确定它们是否不同。

示例代码

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

$source = \Rx\Observable::fromArray([
    24, 42, 24, 24
])->distinctUntilChanged();

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

   
Next value: 24
Next value: 42
Next value: 24
Complete!

RxPHP 还具有运算符 distinctUntilKeyChanged。

distinctUntilChanged 的变体，它接受一个键选择器和 comparer。

示例代码

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

$source = \Rx\Observable::fromArray([
    ['id' => '24'],
    ['id' => '42'],
    ['id' => '24'],
    ['id' => '24']
])
    ->distinctUntilKeyChanged(function ($x) {
        return $x['id'];
    })
    ->map(function ($x) {
        return $x['id'];
    });

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

   
Next value: 24
Next value: 42
Next value: 24
Complete!

待定

待定

待定

待定