web-dev-qa-db-fra.com

Comment utiliser RxJs distinctUntilChanged?

Je commence avec RxJs (en utilisant la version bêta v5), mais je ne peux pas comprendre comment travailler avec distinctUntilChanged. La sortie du code ci-dessous si je l'exécute dans babel-node est

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

Ce n'est pas ce à quoi je m'attendrais. Pourquoi une seule entrée passe-t-elle distinctUntilChanged? Je m'attendrais à ce que la sortie soit

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

Voici le code

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

Les liens dans les documents v5 pour ces fonctions semblent être morts

------ Éditer -----

Quelques débogages supplémentaires:

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

production:

before [ 'a', 1 ]
after [ 'a', 1 ]
[ 'a', 1 ]
before [ 'a', 1 ]
before [ 'a', 0 ]
before [ 'a', 1 ]
javascriptrxjsrxjs5
19
Thijs Koerselman

J'ai obtenu une réponse ici . Fondamentalement, la signature de fonction est passée de (sélecteur de touches, comparateur) à (comparateur, sélecteur de touches).

Voici comment l'exemple se fait en v5:

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

Voici un exemple avec votre code est Rxjs V4. Vous verrez que cela fonctionne correctement.

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

Il semble donc que ce soit quelque chose avec la nouvelle version bêta. Voici les spécifications pour distinctUntilChanged . L'opérateur lui-même semble fonctionner comme dans la version 4.

Pour tester les choses, je vous recommande de tracer la sortie de chaque fonction en insérant une .do(function(x){console.log(x)}) entre les opérateurs. Je ne peux que penser que l'opérateur of peut ne transmettre que le dernier élément du tableau.

1
user3743222