Comment attendre et retourner le résultat d'une adresse http.demande(), de sorte que plusieurs demandes exécuté en série?

Supposons qu'il existe une fonction doRequest(options), qui est censé effectuer une requête HTTP et utilise http.request().

Si doRequest() est appelée dans une boucle, je veux que la prochaine demande est faite après le précédent terminé (exécution en série, l'un après l'autre). Afin de ne pas salir avec les rappels et les Promesses, je veux utiliser la async/await modèle (transpiled avec Babel.js courir avec Nœud 6+).

Cependant, il est clair pour moi, comment attendre la réponse de l'objet pour la poursuite du traitement et de la façon de le retourner comme résultat de doRequest():

var doRequest = async function (options) {

    var req = await http.request(options);

    //do we need "await" here somehow?
    req.on('response', res => {
        console.log('response received');
        return res.statusCode;
    });
    req.end(); //make the request, returns just a boolean

    //return some result here?!
};

Si j'exécute mon code actuel à l'aide de moka à l'aide de diverses options pour les requêtes HTTP, toutes les demandes sont faites simultanément, il me semble. Ils ont tous échoué, probablement parce que doRequest() ne fait pas de retourner quoi que ce soit:

describe('Requests', function() {
    var t = [ /* request options */ ];
    t.forEach(function(options) {
        it('should return 200: ' + options.path, () => {
            chai.assert.equal(doRequest(options), 200);
        });
    });
});

OriginalL'auteur CoDEmanX | 2017-01-04

  1. 17

    async/await travail avec des promesses. Ils ne fonctionneront que si le async fonction de votre awaiting retourne une Promesse.

    Pour résoudre votre problème, vous pouvez soit utiliser une bibliothèque comme request-promise ou le retour d'une promesse de votre doRequest fonction.

    Voici une solution à l'aide de ce dernier.

    function doRequest(options) {
  return new Promise ((resolve, reject) => {
    let req = http.request(options);

    req.on('response', res => {
      resolve(res);
    });

    req.on('error', err => {
      reject(err);
    });
  }); 
}

describe('Requests', function() {
  var t = [ /* request options */ ];
  t.forEach(function(options) {
    it('should return 200: ' + options.path, async function () {
      try {
        let res = await doRequest(options);
        chai.assert.equal(res.statusCode, 200);
      } catch (err) {
        console.log('some error occurred...');
      }
    });
  });
});
    La deuxième fonction doit être un async func je pense. Aussi, il n'y a pas de gestion d'erreur ici.
    Edité pour ajouter vos suggestions. Merci!
    Aussi, la fonction de retour de la Promise n'a pas besoin d'être déclarée async comme il n'a pas de awaiting de son propre 🙂 Et attraper quelque chose juste pour jeter de nouveau n'est guère gestion des erreurs 😀 console.log('oh noes!') est clairement la façon de faire de la gestion des erreurs 😉
    Ou tout simplement utiliser les demande-promesse-natif comme return request(options).catch((e) => { });

    OriginalL'auteur mkhanoyan

  2. 0

    vous devriez être en mesure de passer juste fait pour votre il fonction. puis, après un async req est fait, vous devez ajouter la ligne done() après votre affirme. Si il y a une erreur, vous devez passer à la faire fonctionner comme fait(myError)

    https://mochajs.org/#asynchronous-code pour plus d'info

    OriginalL'auteur LostJon