Richiamate diverse per errore o errore come primo argomento?


12

Noi (e la chat room di JS SO) abbiamo parlato con @rlemon alcuni giorni fa della sua libreria Little-XHR sulla gestione degli errori.

Fondamentalmente, volevamo decidere quale modello di gestione degli errori usare:

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

O:

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

Uno è più simile a jQuery, mentre l'altro è più simile a un nodo. Alcuni dicono che il primo modello ti fa pensare di più sulla gestione degli errori. Penso il contrario, dal momento che potresti dimenticare l'altra funzione di callback, mentre l'argomento è sempre presente sul secondo modello.

Qualche opinione / vantaggio / svantaggio su entrambi questi schemi?


xhr.get({ ... }, function (err, data) {})Almeno fai lo schema giusto
Raynos,

Risposte:


5

La vera caratteristica importante è la coerenza dello stile in modo da poter scrivere codice nello stesso stile e fare ipotesi di meta-programmazione su come vengono gestite le situazioni asincrone.

Personalmente preferisco

(err, data)perché è un modo standard di gestire le cose. Permette la composizione della funzione.

Ad esempio after.mapusa questo modello. Quindi codice come

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

può essere semplificato a

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

Un altro vantaggio è che è possibile passare un callback come ultimo parametro

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

L'ultimo approccio di callback è un simpatico approccio di familiarità API.

Un ulteriore vantaggio è che puoi facilmente dimenticare di impostare il errorgestore nel tuo oggetto letterale o impostarlo su una sorta di gestore di errori predefinito.

Quando (err, data)lo usi ti ricorda di pensare a come gestire in modo efficiente questo errore ogni volta.


2

In generale, mi piace ricordare che esplicito è sempre meglio di implicito.

Usando questo, di solito mi schiererei con esplicite successe failurefunzioni - sai esattamente con cosa hai a che fare nel momento in cui apri quel codice - il successo gestisce le chiamate che sono finite con successo, mentre l'errore si occupa delle chiamate che hanno avuto un problema.

L'alternativa, usando un solo metodo, richiederà più tempo per leggere quando si va a modificare quel codice. Inoltre, probabilmente finiresti con qualcosa del genere;

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

E quel tipo di piastra di cottura diventa noiosa, veloce.

Per non parlare del fatto che, se si dimentica di aggiungere questa piastra della caldaia e, ad esempio, si sta solo gestendo il successo, un nuovo sviluppatore che entra nella base di codice potrebbe non vedere un problema. Ma avendo espliciti callback di errori / successi, sarebbero in grado di vedere abbastanza rapidamente che ti manca un errorcallback e iniziare a lavorare su un modo per gestirlo, o almeno capire "bene, questo è solo gestire il successo - Devo trova un modo per gestire gli errori ". Rende il codice meno magico.


è più difficile vedere la mancanza di un callback di errore e più facile vedere che non si gestisce il primo errparametro
Raynos

1

Callback separati

Se la xhr.get()chiamata ha esito positivo, errè ridondante. Se la chiamata fallisce. dataè ridondante. Invece di forzare il codice client per verificare lo stato dell'uno o dell'altro, non passare entrambi.

Se si scopre che il successo potrebbe rappresentare un successo parziale, indicarlo separatamente. Il fallimento è di solito l'opzione di salvataggio.

Ho lavorato con sviluppatori che gestiscono sempre e solo il caso del successo e in molti scenari è sufficiente implementare un callback di successo in questo caso. Un callback multi-stato sarebbe un'opzione catastrofica per quello stile di programmazione dato che avrebbero assunto il successo.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.