Comment annuler un node.js la promesse de la chaîne à l'aide de Q?

Je suis en utilisant le module Q pour Node.js dans les tentatives pour éviter la "pyramide de la mort" dans les scénarios où j'ai de nombreuses étapes. Par exemple:

function doTask(task, callback)
{
    Q.ncall(task.step1, task)
    .then(function(result1){
        return Q.ncall(task.step2, task);
    })
    .then(function(result2){
        return Q.ncall(task.step3, task);
    })
    .fail(callback).end();
}

Essentiellement, cela semble fonctionner; si une erreur est lancée par toutes les étapes d'une tâche, il est passé à la fonction de rappel (bien que je serais la bienvenue à des améliorations, comme je suis nouvelle node.js des promesses). Cependant, j'ai un problème lorsque j'en ai besoin pour annuler la tâche chaîne tôt. Par exemple, si result1 est retournés avec succès je voudrez peut-être appeler la fonction de rappel précoce et abandonner le reste, mais mes tentatives pour faire échouer...

function doTask(task, callback)
{
    Q.ncall(task.step1, task)
    .then(function(result1){
        if(result1)
        {//the rest of the task chain is unnecessary 
            console.log('aborting!');
            callback(null, result1);
            return null;
        }
        return Q.ncall(task.step2, task);
    })
    .then(function(result2){
        console.log('doing step 3...');
        return Q.ncall(task.step3, task);
    })
    .fail(callback).end();
}

Dans cet exemple, je vois à la fois "l'abandon!" et "faire l'étape 3..." imprimé.

Je suis sûr que je suis contente de l'incompréhension de certains principes de base ici, ce serait reconnaissant de toute aide. Merci!

  • Une solution que j'ai trouvé est de créer une promesse de la chaîne après la première chaîne peut se rompre. Qu'est, dans l'exemple ci-dessus, l' .puis faire une déclaration avec result2 est attachée à la Q. ncall pour l'étape 2, au lieu d'être attaché à la promesse initiale. TOUTEFOIS, le principal inconvénient est qu'il se débarrasse de l'un des principaux avantages de Q à mon avis: éviter la pyramide de doom! C'est toujours mieux que pas de promesses, mais je n'aime pas la solution...
InformationsquelleAutor Zane Claes | 2012-07-02
  1. 17

    Toutes les erreurs qui sont jetés dans la promesse de la chaîne sera la cause de l'ensemble de la pile à être abandonné début et de contrôle de l'erreur de la course. (dans ce cas, le fail() gestionnaire) Lorsque vous détectez un certain état qui provoque vous souhaitez annuler la promesse de la chaîne, puis il suffit de jeter un très spécifique de l'erreur, qui vous piège dans l'erreur-retour et d'ignorer (si vous le souhaitez)

    function doTask(task, callback)
{
    Q.ncall(task.step1, task)
    .then(function(result1){
        if(result1 == 'some failure state I want to cause abortion')
        {//the rest of the task chain is unnecessary 
            console.log('aborting!');
            throw new Error('abort promise chain');
            return null;
        }
        return Q.ncall(task.step2, task);
    })
    .then(function(result2){
        console.log('doing step 3...');
        return Q.ncall(task.step3, task);
    })
    .fail(function(err) {
        if (err.message === 'abort promise chain') {
            //just swallow error because chain was intentionally aborted
        }
        else {
            //else let the error bubble up because it's coming from somewhere else
            throw err;
        } 
    })
    .end();
}
    • Vous êtes à l'aide d'exceptions pour le contrôle de flux, et ce n'est généralement pas recommandé. La solution donnée par Kris Kowal évite ce problème.
    • return null n'est pas nécessaire après le throw
    InformationsquelleAutor Calvin Alvin
  2. 37

    C'est un cas où vous aurez besoin de branche, ce qui signifie soit la nidification ou la création d'une sous-routine.

    function doTask(task, callback) {
    return Q.ncall(task.step1, task)
    .then(function(result1) {
        if (result1) return result1;
        return Q.ncall(task.step2, task)
        .then(function(result2) {
            return Q.ncall(task.step3, task);
        })
    })
    .nodeify(callback)
}

    Ou

    function doTask(task, callback) {
    return Q.ncall(task.step1, task)
    .then(function(result1) {
        if (result1) {
            return result1;
        } else {
            return continueTasks(task);
        }
    })
    .nodeify(callback)
}

function continueTasks(task) {
    return Q.ncall(task.step2, task)
    .then(function(result2) {
        return Q.ncall(task.step3, task);
    })
}
    • Est-ce la meilleure approche pour la ramification? Il semble que cela introduit de l'indentation de nouveau lorsqu'il y a plusieurs branches. Voici un exemple où j'ai effectuer plusieurs opérations sur les fichiers à l'aide de q-io. J'ai d'abord vérifier si un répertoire existe, la liste des fichiers à la recherche pour un certain fichier et le supprimer il suffit qu'un seul fichier de correspondance est trouvée. Il y a plusieurs si-les conditions qu'il doit interrompre la chaîne. J'ai utiliser une valeur de retour à la vérification de cette affaire, mais à vérifier dans chaque fonction. Est-ce une bonne approche?
    • ce que vous décrivez dans cet exemple est une bonne affaire pour les exceptions. Envisagez de gist.github.com/kriskowal/e98774443eb0f1653871
    • J'ai toujours un problème avec cette approche car elle rend plus difficile la gestion d'erreur. Jeter dans une promesse de la chaîne (Calvin Alvin réponse) permet d'avoir un seul .fail() qui prend soin de toute erreur lors de l'écoulement. La rédaction des promesses de cette façon (ramification) me ramène à la fonction de rappel de l'enfer.
    • Merci pour la création de la Q de la bibliothèque, j'ai été en utilisant le bluebird bibliothèque aujourd'hui avec la ligne de flottaison, et, malheureusement, après avoir passé des heures à essayer de mettre fin à l'appel en début je suis arrivé à la même conclusion que Calvin avait fait des années auparavant utilisez simplement les jeter pour sauter directement à la capture. Pouvez-vous expliquer pourquoi le fait que c'est mauvais? Pas un puriste, mais c'est ce que j'ai - gist.github.com/yisyang/047fd95e8c9ffc1af561
    InformationsquelleAutor Kris Kowal
  3. 2

    Je crois que vous n'avez qu'à rejeter la promesse de sortir de la promesse de la chaîne.

    https://github.com/kriskowal/q/wiki/API-Reference#qrejectreason

    aussi qu'il semble .fin() a été modifiée .done()

    function doTask(task, callback)
{
    Q.ncall(task.step1, task)
    .then(function(result1){
        if(result1)
        {//the rest of the task chain is unnecessary 
            console.log('aborting!');
            //by calling Q.reject, your second .then is skipped,
            //only the .fail is executed.
            //result1 will be passed to your callback in the .fail call
            return Q.reject(result1);
        }
        return Q.ncall(task.step2, task);
    })
    .then(function(result2){
        console.log('doing step 3...');
        return Q.ncall(task.step3, task);
    })
    .fail(callback).done();
}
    InformationsquelleAutor George