Comment puis-je gérer les erreurs avec des promesses?

Comme un nœud de programmeur. J'ai l'habitude d'utiliser "nodebacks" pour la gestion des erreurs dans mon code:

myFn(param, function(err, data) {
    if (err){
        //error handling logic
     }
     else {
        //business logic
    }
});

Lors de l'écriture de cette fonction, je peux faire quelque chose comme:

var myFn = function(param, callback){
    var calc = doSomeCalculation(param);
    if(calc === null) { //or some other way to detect error
        callback(new Error("error with calculation"), null);
    }
    ...
    someAsyncOp(calcN,function(err, finalResult){
        if(err) return callback(err, null);
        callback(null, finalResult); //the error is null to signal no error
    });

};

Comment pourrais-je faire ce genre d'erreur de manipulation avec des promesses?

OriginalL'auteur Benjamin Gruenbaum | 2014-02-15

  1. 35

    Règle de base

    Chaque fois que vous avez un doute sur la façon de faire quelque chose avec des promesses - pensez à la version synchrone.

    try{
   var result = myFn(param);
   //business logic with result
} catch(e) {
    //error handling logic
}

    Cela, au moins, me semble beaucoup plus clair qu'un rappel avec un premier paramètre qui est parfois null.

    Les promesses façon est presque toujours très similaire à la version synchrone du problème:

    myFn(param).then(function(result){
    //business logic with result
}).catch(function(e){
    //error handling logic
});

    Où myFn ressemblerait à quelque chose comme lorsque l'on travaille avec des rappels:

    var myFn = function(param){
    return new Promise(function(resolve, reject){
        var calc = doSomeCalculation(param);
        if(calc === null) { //or some other way to detect error
            reject(new Error("error with calculation"), null);
        }
        someAsyncOp(calcN,function(err, finalResult){
            if(err) reject(err);
            resolve(finalResult);
        })
    });
};

    De travail avec des rappels/nodebacks

    C'est seulement quelque chose que vous devez faire lorsque vous travaillez avec des rappels, lorsque l'on travaille avec des promesses, il est beaucoup plus simple, et vous pouvez le faire:

    var myFn = function(param){
    var calc = doSomeCalculation(param);
    ...
    return someAsyncOp(calcN); //returning a promise.
}

    En outre, lorsque l'on travaille à l'intérieur de la promesse de chaînes, vous obtenez jeter de sécurité:

    myFn(param).then(function(calcN){
   //here, you throw to raise an error and return to resolve
   //new Promise should be used only when starting a chain.
}).catch(function(err){
    //handle error
}).then(function(){
   //ready to go again, we're out of the catch
});

    Remarque, certaines bibliothèques, comme Bluebird , RSVP et Q offrir sucre syntaxique automatique et promisification de méthodes de sorte que vous ont rarement à utiliser new Promise vous-même.

    Aussi, pensez à lire cette et que pour en savoir plus sur la promesse d'erreur de manipulation.

    OriginalL'auteur Benjamin Gruenbaum