Comment puis-je résoudre une Observable à l'intérieur d'un autre Observable? - rxjs

J'ai un Observable dans lequel je consommer une autre observable, mais la 2ème Observable je n'arrive pas à résoudre. Voici le code:

return Observable.fromPromise(axios(config))
        .map(res => {
            return {
                accessToken: res.data.access_token,
                refreshToken: res.data.refresh_token                
            }
        })
        .map(res => {
            return {
                me: getMe(res.accessToken),
                accessToken: res.accessToken,
                refreshToken: res.refreshToken                
            }
        })

function getMe(accessToken) {
    return Observable.fromPromise(axios.get({
        url: 'https://api.spotify.com/v1/me',
    }));
}

La getMe fonction renvoie un Observable, mais il n'est jamais résolu. J'ai essayé d'ajouter un flatMap et un concat, mais il n'est toujours pas résolu. Comment puis-je obtenir le getMe à résoudre?

InformationsquelleAutor jhamm | 2015-12-09
  1. 8

    Avez-vous essayez les solutions suivantes (Également non testé):

    function getMe(accessToken) {
  return Rx.Observable.fromPromise(axios.get({
    url: 'https://api.spotify.com/v1/me',
  }));
}    

Rx.Observable.fromPromise(axios(config))
    .map((res) => {
        return {
            accessToken: res.data.access_token,
            refreshToken: res.data.refresh_token                
        }
    })
    .flatMap((res) => {
        return getMe(res.accessToken).map((res2) => {
          res.me = res2;
          return res;
        }
    })
    .subscribe((data) => console.log(data));

    Comme mentionné dans le post ci-dessus, flatMap renvoie une observable. map est par la suite utilisé pour fusionner res avec le résultat res2 retourné à partir de la deuxième promesse.

    Également noter que fromPromise est un froid observables. Cela signifie que vous devez avoir un abonnement pour lancer les choses. Dans votre cas, je suppose que vous avez déjà quelque chose comme ceci:

    someFunction = () => {
  return Rx.Observable.fromPromise(axios(config))
     ...
     ...
}

someFunction.subscribe((data) => console.log(data));
    • Proposition intéressante. Pourrait être utile pour le tester. À mon avis, un problème possible est l'accès res de la fermeture. Je ne suis pas sûr à ce sujet, mais la fonction anonyme avec res.me dans son corps, est exécuté/évalué que lorsque getMe émet une valeur, au moment où je me demande si le res toujours variable conserve sa valeur. Je code avec précaution autour de cela, à l'aide de pures fonctions en rapport avec les phénomènes observables. Donc, je suis intéressé de savoir si je suis trop prudent.
    • À partir d'un point de vue de la fermeture, res gardera sa valeur (j'ai utilisé cette technique). Je ne le pensons qu'il est préférable d'avoir un style défensif de codage et de test de profondeur. Comme une note de côté, si il y a un deuxième Rx.Observable.fromPromise(axios(config)) exécution avant getMe() résout alors vous aurez 2 abonnez-vous à des exécutions. Ceci peut être facilement résolu en utilisant flatMapLatest qui permettra d'assurer que vous aurez toujours la dernière getMe() réponse avec un abonnez-vous de l'exécution.
    • juste assez. Merci pour la clarification.
    • Soyez prudent dans votre description de fromPromise comme un froid Observables. Bien que la valeur elle-même sera mis en cache, le faisant apparaître comme un froid Observable à toutes les flux d'abonnés. Le promise lui-même est impatient et commencer l'exécution immédiatement, indépendamment de l'abonnement.
    InformationsquelleAutor Jeremy
  2. 2

    Comme @user3743222 l'a souligné, un Observable ne pas resolve dans le sens où un Promise n'. Si vous voulez que la valeur de la getMe méthode, vous aurez besoin de vous abonner à la Observable retournés par elle. 

    return Observable.fromPromise(axios(config))
        .map(res => {
            return {
                accessToken: res.data.access_token,
                refreshToken: res.data.refresh_token                
            }
        })
        .flatMap(function(tokens) {

          //FlatMap can implicitly accept a Promise return, so I showed that here
          //for brevity
          return axios.get({url : 'https://api.spotify.com/v1/me'});
        },

        //The second method gives you both the item passed into the first function
        //paired with every item emitted from the returned Observable`
        //i.e. axios.get(...)
        function(tokens, response) {
          return {
            accessToken: tokens.accessToken,
            refreshToken: tokens.accessToken,
            //Here response is a value not an Observable
            me: response
          };
        });
    InformationsquelleAutor paulpdaniels
  3. 0

    Exemple de code à trouver, ci-dessous (non testé!!). Quelques explications :

    • observables retourné par getMe n'est pas aplati, ('résoudre' appartiennent au monde de promesses), parce que le map opérateur de ne pas aplatir les phénomènes observables. flatMap faire, mais vous avez besoin de l'utiliser dans le formulaire source.flatMap(function(x){return observable}) et voici ce que vous retournez est un POJO pas un Rx.Observable.
    • Donc, pour aplatir les getMe nous utilisons un flatMap.
    • Rajouter les champs manquants (accessToken et refreshToken) nous utilisons withLatestFrom sur les observables qui a émis le res objet (res$).

    • Nous utilisons share que nous vous abonner à deux reprises pour res$, et nous voulons tous les abonnés de voir les mêmes valeurs.

      var res$ = Observable
  .fromPromise(axios(config))
  .map(function ( res ) {
       return {
         accessToken  : res.data.access_token,
         refreshToken : res.data.refresh_token
       }
     })
  .share();
var getMe$ = res$.flatMap(function ( res ) {return getMe(res.accessToken)});
var finalRes$ = getMe$.withLatestFrom(res$, function ( getMe, res ) {
return {
   me           : getMe,
   accessToken  : res.accessToken,
   refreshToken : res.refreshToken
 }
});

function getMe ( accessToken ) {
  return Observable.fromPromise(axios.get({url : 'https://api.spotify.com/v1/me'}));
}
    • POJO = Plain Old Objet Javascript
    • Merci pour l'aide, mais cela semble plus complexe que l'utilisation de Promises. Il y a une manière plus concise.
    • Assurez-vous, voyons ce que d'autres viennent avec. Question : pourquoi n'utilisez-vous pas les promesses, et ensuite de les convertir à observable lorsque vous avez le résultat que vous voulez? Rx.Observable.fromPromise n'est que de cette façon que vous avez le meilleur des deux mondes.
    • POJO a été pris très longue, très longue, par JAVA => Plain Old Java Object. Javascript n'était pas de la POO en arrière alors ....
    InformationsquelleAutor user3743222