Différents rappels d'erreur ou d'erreur comme premier argument?

Nous (et la salle de discussion JS SO) avons eu il y a quelques jours avec @rlemon sa bibliothèque Little-XHR sur la gestion des erreurs.

Fondamentalement, nous voulions décider du modèle de gestion des erreurs à utiliser:

xhr.get({
    // Some parameters, and then
    success: function(data) {},
    failure: function(data) {}
})

Ou:

xhr.get({
    // Some parameters, and then
    callback: function(err, data) {}
})

L'un ressemble plus à jQuery, tandis que l'autre ressemble davantage à Node. Certains disent que le premier motif vous fait penser davantage à la gestion des erreurs. Je pense le contraire, car vous pouvez oublier l'autre fonction de rappel, tandis que l'argument est toujours là sur le deuxième motif.

Avez-vous une opinion / un avantage / un inconvénient sur ces deux modèles?

La véritable fonctionnalité importante est la cohérence du style afin que vous puissiez écrire du code dans le même style et vous pouvez faire des hypothèses de méta-programmation sur la façon dont les situations asynchrones sont gérées.

Je préfère personnellement

(err, data)parce que c'est une façon standard de gérer les choses. Il permet la composition des fonctions.

Par exemple, after.maputilise ce modèle. Donc, du code comme

after.map(["foo.js", "bar.js"], function (fileName, callback) {
    fs.readFile(fileName, function (err, file) {
        callback(err, file)
    })
}, function (err, files) {
    // handle files
})

peut être simplifié en

after.map(["foo.js", "bar.js", fs.readFile, function (err, files) {
    // handle files
})

Un autre avantage est que vous pouvez passer un rappel comme dernier paramètre

asyncOperation(options, function (err, data) {
    // not nested inside an object literal
})

La dernière approche de rappel est une belle approche de familiarité avec l'API.

Un autre avantage est que vous pouvez facilement oublier de définir le errorgestionnaire dans votre littéral objet, ou le définir sur une sorte de gestionnaire d'erreur par défaut.

Lorsque vous l'utilisez, (err, data)cela vous rappelle de réfléchir à la façon de gérer efficacement cette erreur à chaque fois.

Généralement, j'aime me rappeler qu'explicite est toujours meilleur qu'implicite.

En utilisant cela, je préfère généralement les fonctions explicites successet failure- vous savez exactement à quoi vous avez affaire au moment où vous ouvrez ce code - le succès traite les appels qui se sont terminés avec succès, tandis que l'erreur traite les appels qui ont eu un problème.

L'alternative, utilisant une seule méthode, prendra plus de temps à lire lorsque vous allez modifier ce code. En outre, vous vous retrouveriez probablement avec quelque chose comme ça;

xhr.get({
    callback: function(err, data) {
        if (err) {
            // handle that error somehow
        }
        else {
            // deal with success somehow
        }
    }
})

Et ce genre de passe-partout devient vite ennuyeux.

Sans oublier, si vous oubliez d'ajouter ce passe-partout, et par exemple, vous ne gérez que le succès, alors un nouveau développeur entrant dans la base de code ne verra peut-être pas de problème. Mais ayant des rappels explicites d'erreur / succès, ils pourraient voir assez rapidement que vous manquez un errorrappel et commencer à travailler sur un moyen de le gérer, ou du moins de comprendre "bien, cela ne fait que gérer le succès - je dois trouver un moyen de gérer les erreurs ". Cela rend le code moins magique.

Rappels séparés

Si l' xhr.get()appel réussit, il errest alors redondant. Si l'appel échoue. dataest redondant. Plutôt que de forcer le code client à vérifier l'état de l'un ou de l'autre, ne passez pas les deux.

S'il s'avère que le succès pourrait représenter un succès partiel, indiquez-le séparément. L'échec est généralement l'option de renflouement.

J'ai travaillé avec des développeurs qui ne traitent que le cas de réussite et dans de nombreux scénarios, l'implémentation d'un rappel de succès suffirait dans ce cas. Un rappel multi-états serait une option catastrophique pour ce style de programmation car ils supposeraient le succès.