Jak korzystać z RxJs distinctUntilChanged?

Question

Zaczynam z RxJs (przy użyciu wersji beta wersji beta), ale jakoś nie mogę wymyślić, jak pracować z distinctUntilChanged. Dane wyjściowe z poniższego kodu, jeśli uruchomię go w węźle Babel, to:

[ 'a', 1 ] 
{ key: 'a', state: 1 } 
Next: { value: 42 } 
Completed 

Nie tego się spodziewać. Dlaczego tylko jedna pozycja przechodzi distinctUntilChanged? Spodziewam się, wyjście będzie

[ 'a', 1 ] 
[ 'a', 0 ] 
[ 'a', 1 ] 
{ key: 'a', state: 1 } 
{ key: 'a', state: 2 } 
{ key: 'a', state: 0 } 
{ key: 'a', state: 1 } 
Next: { value: 42 } 
Next: { value: 24 } 
Completed 

Oto kod

import {Observable} from 'rxjs' 

Observable.of(['a', 1], ['a', 1], ['a', 0], ['a', 1]) 
    .distinctUntilChanged(x => x[1]) 
    .subscribe(x => console.log(x)) 

Observable.of({key: 'a', state: 1}, {key: 'a', state: 2}, {key: 'a', state: 0}, {key: 'a', state: 1}) 
    .distinctUntilChanged(x => x.state) 
    .subscribe(x => console.log(x)) 

Observable.of({value: 42}, {value: 42}, {value: 24}, {value: 24}) 
    .distinctUntilChanged(x => x.value) 
    .subscribe(
    function (x) { 
     console.log('Next: ', x) 
    }, 
    function (err) { 
     console.log('Error: ' + err) 
    }, 
    function() { 
     console.log('Completed') 
    } 
) 

links w docs V5 dla tych funkcji wydaje się być martwy

------ edit - ---

Niektóre dodatkowe debugowanie:

Observable.of(['a', 1], ['a', 1], ['a', 0], ['a', 1]) 
    .do(x => console.log('before', x)) 
    .distinctUntilChanged(x => x[1]) 
    .do(x => console.log('after', x)) 
    .subscribe(x => console.log(x)) 

wyjściowa:

before [ 'a', 1 ] 
after [ 'a', 1 ] 
[ 'a', 1 ] 
before [ 'a', 1 ] 
before [ 'a', 0 ] 
before [ 'a', 1 ] 

Answer 1

Dostałem odpowiedź here. Zasadniczo zmieniono sygnaturę funkcji z (wybieraka klawiszy, komparatora) na (komparator, selektor klawiszy).

ten sposób przykładem jest wykonywana w v5:

Observable.of(['a', 1], ['a', 1], ['a', 0], ['a', 1]) 
    .distinctUntilChanged(null, x => x[1]) 
    .subscribe(x => console.log(x)) 

Answer 2

Oto sample z kodem jest Rxjs V4. Przekonasz się, że działa poprawnie.

Observable.of(['a', 1], ['a', 1], ['a', 0], ['a', 1]) 
    .distinctUntilChanged(x => x[1]) 
    .subscribe(x => console.log(x)) 
... 

Wygląda więc na to, że jest coś w nowej wersji beta. Oto specyfikacje dla distinctUntilChanged. Sam operator wydaje się działać tak jak w wersji 4.

Aby przetestować różne rzeczy, polecam prześledzić wyjście każdej funkcji, wstawiając .do(function(x){console.log(x)}) pomiędzy operatorami. Mogę myśleć tylko o tym, że operator of może przekazać tylko ostatni element tablicy.