Puis-je faire une promesse synchrone dans la bibliothèque JavaScript Q?

Je veux faire quelque chose comme ce qui suit:

delay( 2500 )
  .then( function () { console.log( "Step 1 done" ) } )
  .then( delay( 7500 ) )
  .then( function () { console.log( "Step 2 done" ) } );

Donc la mise en œuvre de retard a été démontré à de nombreuses reprises avant:

function delay( ms ) {
  var deferred = Q.defer();
  setTimeout( deferred.resolve, ms );
  return deferred.promise;
}

Mais si je lance le ci-dessus dans node.js j'obtiens:

... delay of 2500ms
Step 1 done
Step 2 done
... delay of ~7500ms

plutôt que de ce que j'attends de voir:

... delay of 2500ms
Step 1 done
... delay of 7500ms
Step 2 done

Dans les exemples fournis sur https://github.com/kriskowal/q/wiki/Examples-Gallery je ne peux pas trouver des exemples de synchrone fonctions (les fonctions qui renvoient une valeur, sans les rappels impliqués) enchaîné avec la promesse fonctions.

Toutes les idées sur la façon de mélanger dans des actions synchrones avec asynchrone promesses?

J'ai essayé:

function synchronousPromise() {
  var deferred = Q.defer();
  console.log( "Synchronous function call" );
  deferred.resolve();
  return deferred.promise;
}

delay( 2500 )
  .then( function(){synchronousPromise()} )
  .then( function(){delay( 7500 )} )
  .then( function(){synchronousPromise()} );

Et ce sorties:

... delay of 2500ms
Time now is 2013-06-20
Time now is 2013-06-20
... delay of 7500ms

.. toujours pas ce que je suis en train de réaliser.

source d'informationauteur PP.

  1. 13

    Si vous voulez à la chaîne les rappels, vous devez retour une nouvelle promesse d'objet de l'un des rappels. Dans ton premier exemple, vous écrivez

    .then( delay( 7500 ) )

    ce qui signifie que vous êtes de passage à une promesse objet de .thenpas une fonction. Selon le Promesse/Un+ proposition (Q), tous les non-arguments de la fonction doit être ignorée. Donc, fondamentalement, c'est la même que si vous venez d'écrire:

    delay( 2500 )
  .then( function () { console.log( "Step 1 done" ) } )
  .then( function () { console.log( "Step 2 done" ) } );

    Au lieu de cela, passer de la fonction qui appelle delay et renvoie la promesse de l'objet:

    delay( 2500 )
  .then( function () { console.log( "Step 1 done" ); } ) 
  .then( function () { return delay( 7500 ); } )
  .then( function () { console.log( "Step 2 done" ); } );

    Maintenant le dernier rappel ne sera appelée qu'une fois la promesse de l'objet renvoyé par delay dans le deuxième rappel est résolu.

  2. 3

    Google m'a amené ici, tout en travaillant par l'intermédiaire d'un problème similaire (mais l'utilisation de Kris Kowal Q), j'ai fini avec un très petit cadre qui vous permet d'effectuer les opérations suivantes:

    var chain = [
  doNext(delay, 2500),
  doNext(console.log, "Step 1 done"),
  doNext(delay, 7500),
  doNext(console.log, "Step 2 done")
];

doInOrder(chain);

    Le cadre est à seulement 12 lignes, et peuvent probablement être adapté pour d'autres promesse de bibliothèques:

    var Q = require('q');

function doNext(fn /* , arguments */){
  var args =  Array.prototype.splice.call(arguments, 1);
  return function(prevRetVal){
    //For my needs I didn't need the results from previous fns
    return fn.apply(null, args)
  }
}

function doInOrder(doNexters, init){
  return doNexters.reduce(Q.when, init);
}
  3. 0

    Si vous travaillez avec Babel ou Tapuscrit vous pouvez utiliser le ES6 Générateurs:

      'use strict';

  let asyncTask = () =>
    new Promise(resolve => {
      let delay = Math.floor(Math.random() * 1000);

      setTimeout(function () {
        resolve(delay);
      }, delay);
    });

  let makeMeLookSync = fn => {
    let iterator = fn();
    let loop = result => {
      !result.done && result.value.then(res =>
        loop(iterator.next(res)));
    };

    loop(iterator.next());
  };

  makeMeLookSync(function* () {
    let result = yield asyncTask();

    console.log(result);
  });