javascript - practices - typescript typeerror is not a function




Node.js Konvention für die Rückgabe mehrerer Fehler über Rückruf? (2)

Diese Frage wurde über eine Suche nach demselben Problem gefunden. Obwohl ich mich umsah und zu der Schlussfolgerung kam, dass ich nicht glaube, dass Irrtum nichts als ein Fehler oder null .

Die beste "autoritative" Quelle, die ich gefunden habe, ist Nodejitsus Hilfethema:

http://docs.nodejitsu.com/articles/errors/what-are-the-error-conventions

In node.js wird standardmäßig angenommen, dass Fehler in asynchronen Funktionen behandelt werden, indem sie als erstes Argument an den Callback der aktuellen Funktion zurückgegeben werden. Wenn ein Fehler auftritt, wird dem ersten Parameter ein Error-Objekt mit allen Details übergeben. Andernfalls ist der erste Parameter null.

Aber ich denke, dass man aus der Intuition heraus argumentieren kann, warum es so sein sollte. Obwohl es im Code viele if (err) -Tests gibt, um zu entscheiden, ob etwas ein Fehler war oder nicht, sollten Sie nicht 0 oder false oder undefined oder NaN oder eine leere Zeichenfolge übergeben. Sie sollten in der Lage sein, mit if (err == null) zu testen, wenn Sie es wünschen.

Zurückgeben von etwas in dem Feld err, das nicht null ist, aber nicht mit if (err instanceof Error) übereinstimmt if (err instanceof Error) scheint zweifelhaft zu sein. Daher würde ich vorschlagen, keine Arrays oder Objekte zu verwenden. Wenn Sie dies getan haben, beachten Sie auch, dass keiner der Fehler in Ihrem Array den Ort identifiziert, an dem der Aggregatfehler erstellt wurde. Das ist der Punkt, an dem der "wirkliche Fehler" aufgetreten ist, denn es war der Moment der Entscheidung, dass die Fehler, die es gab, nicht etwas waren, mit dem es umgehen konnte.

Dies bedeutet jedoch, dass Sie etwas mehr Arbeit benötigen, um das zu erreichen:

function MultipleError (errs) {
    // http://stackoverflow.com/a/13294728/211160

    if (!(this instanceof MultipleError)) {
        return new MultipleError(errs);
    }

    Error.call(this);
    this.errs = errs;

    // captureStackTrace is V8-only (so Node, Chrome)
    // https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi

    Error.captureStackTrace(this, MultipleError);
};

MultipleError.prototype.__proto__ = Error.prototype;
MultipleError.prototype.name = 'MultipleError';
MultipleError.prototype.toString = function () {
   return 'MultipleError: [\n\t' + this.errs.join(',\n\t') + '\n]';
}

Ein bisschen Overkill, vielleicht. Aber wenn Sie wirklich keinen Fehler auswählen können, um die Aggregation darzustellen, und denken, dass jemand an der Fehlermenge interessiert sein könnte, anstatt nur einer, würde es (?) So aussehen, wie Sie es tun möchten ... Aufrufer, um das errs zu untersuchen, wenn sie möchten.

Die allgemeine Konvention für Callback-Funktionen in Node.js besteht darin, den ersten Parameter für einen Fehler (falls vorhanden) zu "reservieren". Beispielsweise:

callSomeBlockingFcn( function callbackWhenDone(err, result) {
  if( err ) ...
});

Wenn Sie mehr als einen Fehler zurückgeben müssen - sagen wir zum Beispiel mehrere Datenvalidierungsfehler - ist es eine schlechte Form, ein Array von Fehlerobjekten zu übergeben? Beispiel:

var callSomeBlockingFcn = function(callback) {
  // multiple errors to report back...
  callback( [ err1, err2, ...] );
}

Oder ist es vorzuziehen, Arrays zu vermeiden und ein einzelnes Objekt mit einer Eigenschaft zurückzugeben, die auf ein Array verweist (falls erforderlich)? Beispiel:

var callSomeBlockingFcn = function(callback) {
  // multiple errors to report back...
  callback( { errors: [ err1, err2, ...] } );
}

3 Jahre später :

Jeder, der ein Array in einen Rückruf versetzt, wird mich verrückt machen.

Die richtige Lösung besteht darin, einen error als erstes Argument zurückzugeben. Wenn Sie mehrere Fehler zurückgeben möchten, verwenden Sie wahrscheinlich Fehler in Ausnahmefällen.

In diesem Fall sollte es in den "Wert" -Slot des Rückrufs gehen, dh das zweite Argument. Das erste Argument bezieht sich auf einen einzelnen, unerwarteten Betriebsfehler.

Wenn Sie mehrere unerwartete Betriebsfehler (unwahrscheinlich) haben, können Sie etwas wie diesen MultiError

Original :

Ich denke, es ist nichts falsch daran, eine Reihe von Fehlern zurückzugeben.

Sie könnten zwar einen neuen benutzerdefinierten ValidationError mit einer Eigenschaft "messages" dem es sich um ein Array handelt.

ein)

function validateX(x, cb) {
  ...
  if (errorMessages) {
    return cb(errorMessages);
  }
}

b)

function ValidationError(msgs) {
  this.messages = msgs;
}

function validateX(x, cb) {
  ...
  if (errorMessages) {
    return cb(new ValidationError(errorMessages));
  }
}






error-handling