Come usare RxJs distinctUntilChanged?

Question

Sto iniziando con RxJs (utilizzando la beta v5), ma in qualche modo non riesco a capire come lavorare con distinctUntilChanged. L'output dal codice qui sotto se lo eseguo in babel-node è

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

Non è quello che mi aspetterei. Perché solo una voce supera distinctUntilChanged? Mi aspetterei l'uscita di essere

[ '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 

Ecco il codice

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') 
    } 
) 

Il links nella documentazione V5 per queste funzioni sembrano essere morti

------ modifica - ---

Alcuni di debug aggiuntivo:

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)) 

uscita:

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

Answer 1

Ho una risposta here. Fondamentalmente la firma della funzione è cambiata da (selettore di chiave, comparatore) a (comparatore, selettore di chiave).

Questo è come l'esempio è fatto in v5:

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

Answer 2

Ecco un sample con il codice è Rxjs V4. Vedrai che funziona correttamente.

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

Quindi sembra essere qualcosa con la nuova versione beta. Ecco le specifiche per distinctUntilChanged. L'operatore stesso sembra funzionare come nella versione 4.

Per verificare le cose, si consiglia di tracciare l'output di ciascuna funzione inserendo uno .do(function(x){console.log(x)}) tra gli operatori. Posso solo pensare che l'operatore of trasmetta solo l'ultimo elemento dell'array.