Mehrere Versprechen Anforderungen verkettet in Javascript

Question

Ich versuche mehrere asynchrone Anforderungen in JS zusammen zu ketten. Im Grunde möchte ich die Künstlerinformationen von der LastFM-API abrufen und dann diese Informationen nach ihren besten Titeln durchsuchen.

Bis jetzt kann ich die Künstlerinfo erfolgreich erhalten, es zurückgeben lassen, und es druckt die Info im folgenden Schritt aus. Sobald ich jedoch versuche, meine zweite Anfrage für die Top-Tracks zu machen, wird der Body nie gedruckt und es geht sofort weiter zum nächsten Schritt.

Ich habe viele verschiedene Kombinationen dieses Codes mit verschiedenen Arten von Anfragen und dergleichen ausprobiert, aber ich habe kein Glück bekommen. Ich möchte nur erfolgreich 1 anfordern, wenn es erfolgreich ist, dann folge es von anderen in einer ordnungsgemäßen Reihenfolge.

 var artistInfo = { 
      method: 'GET', 
      url: 'http://localhost:3000/users/db/artistInfo/' + artistName 
     }; 


     var topTracks = { method: 'GET', 
      url: 'http://localhost:3000/users/db/topTracks/' + artistName 
     }; 

     /* Dependencies */ 
     var Promise = require('bluebird'); 
     var reqP = Promise.promisifyAll(require('request-promise')); 

     reqP(artistInfo) 
      .then(function(info) { 

       console.log("got here 1"); 
       return info; 
      }) 
      .then(function(artist) { 

       console.log(artist); 

       reqP(topTracks) 
        .then(function(body) { 

         console.log(body); 

         console.log("got here 2"); 
         return body; 
       }); 

       return 'test'; 
      }) 
      .then(function(content) { 

       console.log(content); 

       return 'test2'; 
      }) 
      .catch(function(err) { 
       throw err; 
      }); 

Answer 1

diese beiden Anfragen sequenzieren und die äußere .then() warten beide haben, müssen Sie sie die interne Versprechen (die eine in der .then() Handler), um Kette zurückzukehren. Wenn Sie sie nicht zurückgeben, dann ist nichts an das Elternversprechen gebunden und deshalb wartet das Elternversprechen nicht auf das Kinderversprechen. Siehe die Linie, wo ich return-return reqP(topTracks) hinzugefügt:

var artistInfo = { 
     method: 'GET', 
     url: 'http://localhost:3000/users/db/artistInfo/' + artistName 
    }; 


    var topTracks = { method: 'GET', 
     url: 'http://localhost:3000/users/db/topTracks/' + artistName 
    }; 

    /* Dependencies */ 
    var Promise = require('bluebird'); 
    var reqP = Promise.promisifyAll(require('request-promise')); 

    reqP(artistInfo) 
     .then(function(info) { 

      console.log("got here 1"); 
      return info; 
     }) 
     .then(function(artist) { 

      console.log(artist); 

      // *** add return here *** 
      return reqP(topTracks) 
       .then(function(body) { 

        console.log(body); 

        console.log("got here 2"); 
        return body; 
      }); 
     }) 
     .then(function(content) { 

      console.log(content); 

      return 'test2'; 
     }) 
     .catch(function(err) { 
      throw err; 
     }); 

---

FYI, sieht es nicht wie Ihre zwei Anforderungen hängen von einander so könnten Sie auch tun, um sie parallel:

var artistInfo = { 
     method: 'GET', 
     url: 'http://localhost:3000/users/db/artistInfo/' + artistName 
    }; 

    var topTracks = { method: 'GET', 
     url: 'http://localhost:3000/users/db/topTracks/' + artistName 
    }; 

    /* Dependencies */ 
    var Promise = require('bluebird'); 
    var reqP = Promise.promisifyAll(require('request-promise')); 

    Promise.all([reqP(artistInfo), reqP(topTracks)]).then(function(results){ 
     // results[0] is artist 
     // results[1] is tracks 
    }, function(err){ 
     // error here 
    }); 

Answer 2

Erstens, ich weiß nicht, warum Sie eine Versprechen-basierte Bibliothek versprechen. Es gibt ein paar Möglichkeiten, dies zu tun, aber ich werde Ihnen geben, was ich denke, ist der sauberste Weg, aber es erfordert Bluebird (die Sie in Ihrem Beispiel sowieso verwenden, sollte also kein Problem sein)

Es sieht nicht so aus wie Ihre zweite Anfrage an Ihrem ersten abhängt, Sie Promise.props()

/* Dependencies */ 
 
var Promise = require('bluebird'); 
 
var request = require('request-promise'); 
 

 
var artistInfo = request({ 
 
    method: 'GET', 
 
    url: 'http://localhost:3000/users/db/artistInfo/' + artistName 
 
}); 
 

 

 
var topTracks = request({ 
 
    method: 'GET', 
 
    url: 'http://localhost:3000/users/db/topTracks/' + artistName 
 
}); 
 

 

 

 
Promise.props({ 
 
    artistInfo: artistInfo, 
 
    topTracks: topTracks 
 
}).then(function(result) { 
 
    console.log(JSON.stringify(result.artistInfo,null,2)); 
 
    console.log(JSON.stringify(result.topTracks,null,2)); 
 
}) 
 
.catch(function(err) { 
 
    console.error(err); 
 
});

So verwenden können, was hier vor sich geht? Promise.props können Sie ein Objekt übergeben, dessen Eigenschaften Versprechen sind. Diese Versprechungen werden dann parallel ausgeführt und das Versprechen wird nicht gelöst, bis beide gelöst sind (oder es wird fallengelassen, wenn eines der beiden fehlschlägt).

Wie für die Verkettung Versprechen, müssen Sie sicherstellen, dass Sie ein Versprechen zurückgeben. Dies ist, was können Sie die hässliche Verschachtelung

/* Dependencies */ 
 
var Promise = require('bluebird'); 
 
var request = require('request-promise'); 
 

 
request({ 
 
    method: 'GET', 
 
    url: 'http://localhost:3000/users/db/artistInfo/' + artistName 
 
}) 
 
.then(function(artistInfo) { 
 
    console.log(artistInfo); 
 
    
 
    return request({ 
 
    method: 'GET', 
 
    url: 'http://localhost:3000/users/db/topTracks/' + artistName 
 
    }); 
 
}) 
 
.then(function(topTracks) { 
 
    console.log(topTracks); 
 
}) 
 
.catch(function(err) { 
 
    console.error(err); 
 
});