Comment attendre deux phénomènes observables dans les RxJS

Dans mon application j'ai quelque chose comme:

this._personService.getName(id)
      .concat(this._documentService.getDocument())
      .subscribe((response) => {
                  console.log(response)
                  this.showForm()
       });

 //Output: 
 //[getnameResult]
 //[getDocumentResult]

 //I want:
 //[getnameResult][getDocumentResult]

Puis-je obtenir deux séparés résultats, d'abord de la _personService et puis le _documentService. Comment puis-je attendre les résultats avant de les appeler this.showForm() pour finir ensuite de manipuler les résultats de chacun.

forkJoin github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/...
pour ce que je comprends, vous l'êtes déjà, en vertu de concat
Dans ce cas, les valeurs sont émettant séparément. L'un après l'autre.
dans forkJoin' abonnez-vous obtiendrez un résultat - tuple avec les première et deuxième réponses - c'est exactement ce que vous avez demandé?
vous pouvez regarder forkJoin de mon blog - medium.com/@juliapassynkova/q-map-to-rxjs-981936a2b22d

OriginalL'auteur gog | 2017-05-16

  1. 33

    Mise À Jour: Oct, 2018

    Je l'ai déjà suggéré l'utilisation de zip méthode. Cependant, depuis lors, je me suis retrouvé à l'aide de combineLatest à la place. Il a donc décidé de l'ajouter combineLatest.

    CombineLatest émet de la dernière émises valeurs à partir des observables. Alors que zip méthode émet émis des éléments dans séquence commande.

    Par exemple, si observables #1 émet son 3ème élément observable et #2 a émis son 5e élément. Le résultat à l'aide de zip méthode sera la 3ème émis des valeurs des deux observables.

    Dans cette situation le résultat à l'aide de combineLatest sera le 5e et 3ème. qui se sent plus naturel.

    combineLatest(observables)

    De reactiveX la documentation:

    Chaque fois qu'une entrée Observables émet une valeur, on calcule une formule en utilisant les dernières valeurs de toutes les entrées, puis émet de la sortie de cette formule.

    //Observables to combine
const name$ = this._personService.getName(id);
const document$ = this._documentService.getDocument();

combineLatest(name$, document$, (name, document) => ({name, document}))
    .subscribe(pair => {
           this.name = pair.name;
           this.document = pair.document;
           this.showForm();
       })

    Observable.zip(observables)

    Observable.zip la méthode est expliquée dans reactiveX documentation:

    Combine plusieurs Observables pour créer une Observable dont les valeurs sont calculées à partir des valeurs, dans l'ordre, de chacun de ses intrants Observables.

    //Observables to combine
const name$ = this._personService.getName(id);
const document$ = this._documentService.getDocument();

Observable
    .zip(name$, document$, (name: string, document: string) => ({name, document}))
    .subscribe(pair => {
           this.name = pair.name;
           this.document = pair.document;
           this.showForm();
       })

    une note de côté (s'applique pour les deux méthodes)

    Le dernier paramètre, où nous avons fourni une fonction, (name: string, document: string) => ({name, document}) est facultatif. Vous pouvez ignorer, ou faire des opérations plus complexes:

    Si le dernier paramètre est une fonction, cette fonction est utilisée pour calculer la valeur créée à partir des valeurs d'entrée. Sinon, un tableau des valeurs d'entrée est retourné.

    Donc, si vous passez la dernière partie, vous obtenez un tableau:

    //Observables to combine
const name$ = this._personService.getName(id);
const document$ = this._documentService.getDocument();

Observable
    .zip(name$, document$)
    .subscribe(pair => {
           this.name = pair['0'];
           this.document = pair['1'];
           this.showForm();
       })
    Est-il possible d'attendre l'achèvement d'une observable ?, mon observables ont une autre intérieure observables, qui à son tour dépend de la un http.obtenir ?

    OriginalL'auteur Hamid Asghari

  2. 13

    Utilisation forkJoin() méthode des observables. Suivez ce lien pour référence

    De la RXJS docs

    Cet opérateur est utilisé au mieux quand vous avez un groupe de phénomènes observables et se soucient seulement de la finale émise valeur de chaque. Une utilisation de ce est si vous souhaitez envoyer plusieurs demandes au chargement de la page (ou d'un autre événement) et voulez seulement de prendre des mesures lorsqu'une réponse a été receieved pour tous. De cette façon, il est semblable à la façon dont vous pouvez utiliser Promesse.tous

    Observable.forkJoin([character, characterHomeworld]).subscribe(results => {
  //results[0] is our character
  //results[1] is our character homeworld
  results[0].homeworld = results[1];
  this.loadedCharacter = results[0];
});

    Code tiré de: https://coryrylan.com/blog/angular-multiple-http-requests-with-rxjs

    Est-il possible d'attendre l'achèvement d'une observable ?, mon observables ont une autre intérieure observables, qui à son tour dépend de la un http.obtenir ?
    Si tu veux faire qqch. après l'obtention d'un observable, vous pouvez utiliser l'imbrication de l'abonnement?

    OriginalL'auteur Prathmesh Dali

  3. 2

    Pour moi ce l'échantillon était la meilleure solution.

    const source = Observable.interval(500);
const example = source.sample(Observable.interval(2000));
const subscribe = example.subscribe(val => console.log('sample', val));

    Donc.. ce n'est que lors de la seconde (exemple) émettent - vous allez voir le dernier dégager de la valeur de la première (source).

    Dans ma tâche, j'attends la validation d'un formulaire et d'autres événements DOM.

    OriginalL'auteur Олег Беликов

  4. 0

    Vous pouvez utiliser l'option " zip " ou "tampon" comme suit.

    function getName() {
    return Observable.of('some name').delay(100);
}

function getDocument() {
    return Observable.of('some document').delay(200);
}

//CASE1 : concurrent requests
Observable.zip(getName(), getDocument(), (name, document) => {
    return `${name}-${document}`;
})
    .subscribe(value => console.log(`concurrent: ${value}`));

//CASE2 : sequential requests
getName().concat(getDocument())
    .bufferCount(2)
    .map(values => `${values[0]}-${values[1]}`)
    .subscribe(value => console.log(`sequential: ${value}`));

    OriginalL'auteur thatseeyou

  5. 0

    Ont un look à la 'combineLatest " méthode", il pourrait être approprié ici.
    http://reactivex.io/rxjs/class/es6/Observable.js~Observables.html#static-méthode-combineLatest

    const { Observable } = Rx

const name$ = this._personService.getName(id);
const document$ = this._documentService.getDocument();

Observable
    .combineLatest(name$, document$, (name, document) => ({ name, document }))
    .first() //or not, implementation detail
    .subscribe(({ name, document }) => {
        //here we have both name and document
        this.showForm()
    })

    OriginalL'auteur Tal