Fehler

Anwendungen, die in Node.js ausgeführt werden, erleben im Allgemeinen vier Kategorien von Fehlern:

Standardmäßige JavaScript-Fehler wie <EvalError>, <SyntaxError>, <RangeError>, <ReferenceError>, <TypeError> und <URIError>.
Systemfehler, die durch zugrunde liegende Betriebssystembeschränkungen ausgelöst werden, z. B. der Versuch, eine nicht vorhandene Datei zu öffnen oder Daten über einen geschlossenen Socket zu senden.
Benutzerdefinierte Fehler, die durch Anwendungscode ausgelöst werden.
AssertionErrors sind eine spezielle Fehlerklasse, die ausgelöst werden kann, wenn Node.js eine außergewöhnliche Logikverletzung erkennt, die niemals auftreten sollte. Diese werden typischerweise durch das node:assert-Modul ausgelöst.

Alle JavaScript- und Systemfehler, die von Node.js ausgelöst werden, erben von der Standard-JavaScript-Klasse <Error> oder sind Instanzen davon und garantieren, mindestens die Eigenschaften bereitzustellen, die für diese Klasse verfügbar sind.

Fehlerweiterleitung und -abfang

Node.js unterstützt verschiedene Mechanismen zum Weiterleiten und Behandeln von Fehlern, die während der Ausführung einer Anwendung auftreten. Wie diese Fehler gemeldet und behandelt werden, hängt vollständig von der Art des Error und dem Stil der aufgerufenen API ab.

Alle JavaScript-Fehler werden als Ausnahmen behandelt, die sofort einen Fehler generieren und mit dem Standard-JavaScript-Mechanismus throw auslösen. Diese werden mit dem von der JavaScript-Sprache bereitgestellten try…catch-Konstrukt behandelt.

// Wirft einen ReferenceError, weil z nicht definiert ist.
try {
  const m = 1;
  const n = m + z;
} catch (err) {
  // Behandle den Fehler hier.
}

Jede Verwendung des JavaScript-Mechanismus throw löst eine Ausnahme aus, die behandelt werden muss, oder der Node.js-Prozess wird sofort beendet.

Mit wenigen Ausnahmen verwenden synchrone APIs (jede blockierende Methode, die kein <Promise> zurückgibt und keine callback-Funktion akzeptiert, wie z. B. fs.readFileSync) throw, um Fehler zu melden.

Fehler, die innerhalb von asynchronen APIs auftreten, können auf verschiedene Arten gemeldet werden:

Einige asynchrone Methoden geben ein <Promise> zurück. Sie sollten immer berücksichtigen, dass es abgelehnt werden kann. Siehe Flag --unhandled-rejections, um zu erfahren, wie der Prozess auf eine unbehandelte Promise-Ablehnung reagiert.
Die meisten asynchronen Methoden, die eine callback-Funktion akzeptieren, akzeptieren ein Error-Objekt, das als erstes Argument an diese Funktion übergeben wird. Wenn dieses erste Argument nicht null ist und eine Instanz von Error ist, ist ein Fehler aufgetreten, der behandelt werden sollte.
Wenn eine asynchrone Methode für ein Objekt aufgerufen wird, das ein EventEmitter ist, können Fehler an das 'error'-Ereignis dieses Objekts weitergeleitet werden.
Eine Handvoll typischerweise asynchroner Methoden in der Node.js-API können immer noch den throw-Mechanismus verwenden, um Ausnahmen auszulösen, die mit try…catch behandelt werden müssen. Es gibt keine umfassende Liste solcher Methoden. Bitte konsultieren Sie die Dokumentation jeder Methode, um den erforderlichen Fehlerbehandlungsmechanismus zu bestimmen.

Die Verwendung des 'error'-Ereignismechanismus ist am gebräuchlichsten für stream-basierte und event emitter-basierte APIs, die selbst eine Reihe von asynchronen Operationen im Laufe der Zeit darstellen (im Gegensatz zu einer einzelnen Operation, die erfolgreich sein oder fehlschlagen kann).

Für alle EventEmitter-Objekte gilt: Wenn kein 'error'-Ereignishandler bereitgestellt wird, wird der Fehler ausgelöst, wodurch der Node.js-Prozess eine nicht abgefangene Ausnahme meldet und abstürzt, es sei denn: Es wurde ein Handler für das ['uncaughtException']-Ereignis](/de/api/process#event-uncaughtexception) registriert oder das veraltete node:domain-Modul wird verwendet.

const EventEmitter = require('node:events');
const ee = new EventEmitter();

setImmediate(() => {
  // Dies wird den Prozess zum Absturz bringen, da kein 'error'-Ereignis
  // Handler wurde hinzugefügt.
  ee.emit('error', new Error('This will crash'));
});

Auf diese Weise generierte Fehler können nicht mit try…catch abgefangen werden, da sie nachdem der aufrufende Code bereits beendet wurde, ausgelöst werden.

Entwickler müssen sich auf die Dokumentation für jede Methode beziehen, um genau zu bestimmen, wie Fehler, die von diesen Methoden ausgelöst werden, weitergeleitet werden.

Klasse: `Error`

Ein generisches JavaScript-<Error>-Objekt, das keine spezifischen Umstände angibt, warum der Fehler aufgetreten ist. Error-Objekte erfassen einen "Stack-Trace", der den Punkt im Code detailliert beschreibt, an dem das Error-Objekt instanziiert wurde, und können eine Textbeschreibung des Fehlers liefern.

Alle von Node.js generierten Fehler, einschließlich aller System- und JavaScript-Fehler, sind entweder Instanzen der Klasse Error oder erben von ihr.

`new Error(message[, options])`

message <string>
options <Object>
- cause <any> Der Fehler, der den neu erstellten Fehler verursacht hat.

Erstellt ein neues Error-Objekt und setzt die Eigenschaft error.message auf die bereitgestellte Textnachricht. Wenn ein Objekt als message übergeben wird, wird die Textnachricht durch Aufrufen von String(message) generiert. Wenn die Option cause angegeben wird, wird sie der Eigenschaft error.cause zugewiesen. Die Eigenschaft error.stack repräsentiert den Punkt im Code, an dem new Error() aufgerufen wurde. Stack-Traces sind von der Stack-Trace-API von V8 abhängig. Stack-Traces erstrecken sich nur bis entweder (a) zum Beginn der synchronen Codeausführung oder (b) bis zur Anzahl der Frames, die durch die Eigenschaft Error.stackTraceLimit vorgegeben ist, je nachdem, welcher Wert kleiner ist.

`Error.captureStackTrace(targetObject[, constructorOpt])`

targetObject <Object>
constructorOpt <Function>

Erstellt eine .stack-Eigenschaft für targetObject, die bei Zugriff eine Zeichenfolge zurückgibt, die die Position im Code darstellt, an der Error.captureStackTrace() aufgerufen wurde.

const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Ähnlich wie `new Error().stack`

Die erste Zeile des Trace wird mit ${myObject.name}: ${myObject.message} versehen.

Das optionale Argument constructorOpt akzeptiert eine Funktion. Wenn es angegeben wird, werden alle Frames oberhalb von constructorOpt, einschließlich constructorOpt, aus dem generierten Stack-Trace entfernt.

Das Argument constructorOpt ist nützlich, um Implementierungsdetails der Fehlererzeugung vor dem Benutzer zu verbergen. Zum Beispiel:

function a() {
  b();
}

function b() {
  c();
}

function c() {
  // Erstellen Sie einen Fehler ohne Stack-Trace, um die Berechnung des Stack-Traces nicht zweimal durchführen zu müssen.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;

  // Erfassen Sie den Stack-Trace oberhalb der Funktion b
  Error.captureStackTrace(error, b); // Weder Funktion c noch b sind im Stack-Trace enthalten
  throw error;
}

a();

`Error.stackTraceLimit`

<number>

Die Eigenschaft Error.stackTraceLimit gibt die Anzahl der Stackframes an, die von einem Stacktrace erfasst werden (unabhängig davon, ob er von new Error().stack oder Error.captureStackTrace(obj) generiert wurde).

Der Standardwert ist 10, kann aber auf eine beliebige gültige JavaScript-Zahl gesetzt werden. Änderungen wirken sich auf alle Stacktraces aus, die nachdem der Wert geändert wurde, erfasst werden.

Wenn sie auf einen Wert gesetzt wird, der keine Zahl ist, oder auf eine negative Zahl gesetzt wird, erfassen Stacktraces keine Frames.

`error.cause`

Hinzugefügt in: v16.9.0

<any>

Wenn vorhanden, ist die Eigenschaft error.cause die zugrunde liegende Ursache des Error. Sie wird verwendet, wenn ein Fehler abgefangen und ein neuer mit einer anderen Nachricht oder einem anderen Code ausgelöst wird, um weiterhin Zugriff auf den ursprünglichen Fehler zu haben.

Die Eigenschaft error.cause wird typischerweise durch Aufruf von new Error(message, { cause }) gesetzt. Sie wird vom Konstruktor nicht gesetzt, wenn die Option cause nicht angegeben wird.

Diese Eigenschaft ermöglicht es, Fehler zu verketten. Beim Serialisieren von Error-Objekten serialisiert util.inspect() rekursiv error.cause, falls es gesetzt ist.

const cause = new Error('Der Remote-HTTP-Server antwortete mit dem Status 500');
const symptom = new Error('Die Nachricht konnte nicht gesendet werden', { cause });

console.log(symptom);
// Prints:
//   Error: Die Nachricht konnte nicht gesendet werden
//       at REPL2:1:17
//       at Script.runInThisContext (node:vm:130:12)
//       ... 7 lines matching cause stack trace ...
//       at [_line] [as _line] (node:internal/readline/interface:886:18) {
//     [cause]: Error: Der Remote-HTTP-Server antwortete mit dem Status 500
//         at REPL1:1:15
//         at Script.runInThisContext (node:vm:130:12)
//         at REPLServer.defaultEval (node:repl:574:29)
//         at bound (node:domain:426:15)
//         at REPLServer.runBound [as eval] (node:domain:437:12)
//         at REPLServer.onLine (node:repl:902:10)
//         at REPLServer.emit (node:events:549:35)
//         at REPLServer.emit (node:domain:482:12)
//         at [_onLine] [as _onLine] (node:internal/readline/interface:425:12)
//         at [_line] [as _line] (node:internal/readline/interface:886:18)

`error.code`

<string>

Die Eigenschaft error.code ist eine String-Kennzeichnung, die die Art des Fehlers identifiziert. error.code ist die stabilste Möglichkeit, einen Fehler zu identifizieren. Sie ändert sich nur zwischen Hauptversionen von Node.js. Im Gegensatz dazu können sich error.message-Strings zwischen beliebigen Versionen von Node.js ändern. Siehe Node.js-Fehlercodes für Details zu bestimmten Codes.

`error.message`

<string>

Die Eigenschaft error.message ist die String-Beschreibung des Fehlers, wie sie durch Aufrufen von new Error(message) festgelegt wurde. Die an den Konstruktor übergebene message erscheint auch in der ersten Zeile des Stack-Traces des Error. Das Ändern dieser Eigenschaft nach der Erstellung des Error-Objekts ändert möglicherweise nicht die erste Zeile des Stack-Traces (z. B. wenn error.stack gelesen wird, bevor diese Eigenschaft geändert wird).

const err = new Error('Die Nachricht');
console.error(err.message);
// Gibt aus: Die Nachricht

`error.stack`

<string>

Die Eigenschaft error.stack ist ein String, der den Punkt im Code beschreibt, an dem der Error instanziiert wurde.

bash

Error: Dinge passieren immer wieder!
   at /home/gbusey/file.js:525:2
   at Frobnicator.refrobulate (/home/gbusey/business-logic.js:424:21)
   at Actor.<anonymous> (/home/gbusey/actors.js:400:8)
   at increaseSynergy (/home/gbusey/actors.js:701:6)

Die erste Zeile ist als \<Fehlerklassenname\>: \<Fehlermeldung\> formatiert und wird von einer Reihe von Stack-Frames gefolgt (jede Zeile beginnt mit "at "). Jeder Frame beschreibt eine Aufrufstelle innerhalb des Codes, die zur Erzeugung des Fehlers geführt hat. V8 versucht, einen Namen für jede Funktion anzuzeigen (nach Variablenname, Funktionsname oder Objektmethodenname), aber gelegentlich kann es keinen geeigneten Namen finden. Wenn V8 keinen Namen für die Funktion bestimmen kann, werden für diesen Frame nur Standortinformationen angezeigt. Andernfalls wird der ermittelte Funktionsname mit Standortinformationen in Klammern angehängt angezeigt.

Frames werden nur für JavaScript-Funktionen generiert. Wenn beispielsweise die Ausführung synchron durch eine C++-Addon-Funktion namens cheetahify läuft, die selbst eine JavaScript-Funktion aufruft, ist der Frame, der den cheetahify-Aufruf darstellt, nicht in den Stack-Traces vorhanden:

const cheetahify = require('./native-binding.node');

function makeFaster() {
  // `cheetahify()` ruft *synchron* speedy auf.
  cheetahify(function speedy() {
    throw new Error('Oh nein!');
  });
}

makeFaster();
// wird auslösen:
//   /home/gbusey/file.js:6
//       throw new Error('Oh nein!');
//           ^
//   Error: Oh nein!
//       at speedy (/home/gbusey/file.js:6:11)
//       at makeFaster (/home/gbusey/file.js:5:3)
//       at Object.<anonymous> (/home/gbusey/file.js:10:1)
//       at Module._compile (module.js:456:26)
//       at Object.Module._extensions..js (module.js:474:10)
//       at Module.load (module.js:356:32)
//       at Function.Module._load (module.js:312:12)
//       at Function.Module.runMain (module.js:497:10)
//       at startup (node.js:119:16)
//       at node.js:906:3

Die Standortinformationen sind eine der folgenden:

native, wenn der Frame einen Aufruf innerhalb von V8 darstellt (wie in [].forEach).
plain-filename.js:line:column, wenn der Frame einen Aufruf innerhalb von Node.js darstellt.
/absolute/path/to/file.js:line:column, wenn der Frame einen Aufruf in einem Benutzerprogramm (mit CommonJS-Modulsystem) oder dessen Abhängigkeiten darstellt.
\<transport-protocol\>:///url/to/module/file.mjs:line:column, wenn der Frame einen Aufruf in einem Benutzerprogramm (mit ES-Modulsystem) oder dessen Abhängigkeiten darstellt.

Der String, der den Stack-Trace darstellt, wird verzögert generiert, wenn auf die Eigenschaft error.stack zugegriffen wird.

Die Anzahl der von der Stack-Trace erfassten Frames wird durch den kleineren Wert von Error.stackTraceLimit oder der Anzahl der verfügbaren Frames im aktuellen Event-Loop-Tick begrenzt.

Klasse: `AssertionError`

Erweitert: <errors.Error>

Zeigt das Fehlschlagen einer Assertion an. Für Details siehe Klasse: assert.AssertionError.

Klasse: `RangeError`

Erweitert: <errors.Error>

Zeigt an, dass ein bereitgestelltes Argument nicht innerhalb der Menge oder des Bereichs akzeptabler Werte für eine Funktion lag; sei es ein numerischer Bereich oder außerhalb der Menge der Optionen für einen bestimmten Funktionsparameter.

require('node:net').connect(-1);
// Wirft "RangeError: "port" option should be >= 0 and < 65536: -1"

Node.js generiert und wirft RangeError-Instanzen sofort als eine Form der Argumentvalidierung.

Klasse: `ReferenceError`

Erweitert: <errors.Error>

Zeigt an, dass versucht wird, auf eine Variable zuzugreifen, die nicht definiert ist. Solche Fehler deuten häufig auf Tippfehler im Code oder ein anderweitig fehlerhaftes Programm hin.

Während Client-Code diese Fehler generieren und weiterleiten kann, tut dies in der Praxis nur V8.

doesNotExist;
// Wirft ReferenceError, doesNotExist ist keine Variable in diesem Programm.

Sofern eine Anwendung nicht dynamisch Code generiert und ausführt, weisen ReferenceError-Instanzen auf einen Fehler im Code oder seinen Abhängigkeiten hin.

Klasse: `SyntaxError`

Erweitert: <errors.Error>

Zeigt an, dass ein Programm kein gültiges JavaScript ist. Diese Fehler können nur als Ergebnis der Codeauswertung generiert und weitergeleitet werden. Die Codeauswertung kann als Ergebnis von eval, Function, require oder vm erfolgen. Diese Fehler sind fast immer ein Zeichen für ein fehlerhaftes Programm.

try {
  require('node:vm').runInThisContext('binary ! isNotOk');
} catch (err) {
  // 'err' wird ein SyntaxError sein.
}

SyntaxError-Instanzen sind in dem Kontext, der sie erzeugt hat, nicht wiederherstellbar – sie können nur von anderen Kontexten abgefangen werden.

Klasse: `SystemError`

Erweitert: <errors.Error>

Node.js generiert Systemfehler, wenn Ausnahmen innerhalb seiner Laufzeitumgebung auftreten. Diese treten normalerweise auf, wenn eine Anwendung eine Einschränkung des Betriebssystems verletzt. Beispielsweise tritt ein Systemfehler auf, wenn eine Anwendung versucht, eine Datei zu lesen, die nicht existiert.

address <string> Falls vorhanden, die Adresse, zu der eine Netzwerkverbindung fehlgeschlagen ist
code <string> Der Zeichenfolgen-Fehlercode
dest <string> Falls vorhanden, der Dateipfad des Ziels bei der Meldung eines Dateisystemfehlers
errno <number> Die vom System bereitgestellte Fehlernummer
info <Object> Falls vorhanden, zusätzliche Details zur Fehlerbedingung
message <string> Eine vom System bereitgestellte, für Menschen lesbare Beschreibung des Fehlers
path <string> Falls vorhanden, der Dateipfad bei der Meldung eines Dateisystemfehlers
port <number> Falls vorhanden, der Netzwerkverbindungsport, der nicht verfügbar ist
syscall <string> Der Name des Systemaufrufs, der den Fehler ausgelöst hat

`error.address`

<string>

Falls vorhanden, ist error.address eine Zeichenkette, die die Adresse beschreibt, zu der eine Netzwerkverbindung fehlgeschlagen ist.

`error.code`

<string>

Die Eigenschaft error.code ist eine Zeichenkette, die den Fehlercode darstellt.

`error.dest`

<string>

Falls vorhanden, ist error.dest der Dateipfad des Ziels, wenn ein Dateisystemfehler gemeldet wird.

`error.errno`

<number>

Die Eigenschaft error.errno ist eine negative Zahl, die dem in libuv Error handling definierten Fehlercode entspricht.

Unter Windows wird die vom System bereitgestellte Fehlernummer von libuv normalisiert.

Um die String-Repräsentation des Fehlercodes zu erhalten, verwende util.getSystemErrorName(error.errno).

`error.info`

<Object>

Falls vorhanden, ist error.info ein Objekt mit Details zum Fehlerzustand.

`error.message`

<string>

error.message ist eine vom System bereitgestellte, für Menschen lesbare Beschreibung des Fehlers.

`error.path`

<string>

Falls vorhanden, ist error.path eine Zeichenkette, die einen relevanten, ungültigen Pfadnamen enthält.

`error.port`

<number>

Falls vorhanden, ist error.port der Netzwerkverbindungsport, der nicht verfügbar ist.

`error.syscall`

<string>

Die Eigenschaft error.syscall ist eine Zeichenkette, die den fehlgeschlagenen Syscall beschreibt.

Häufige Systemfehler

Dies ist eine Liste von Systemfehlern, die häufig beim Schreiben eines Node.js-Programms auftreten. Eine umfassende Liste finden Sie in der errno(3) Manpage.

EACCES (Zugriff verweigert): Es wurde versucht, auf eine Datei in einer Weise zuzugreifen, die durch ihre Dateizugriffsberechtigungen verboten ist.
EADDRINUSE (Adresse wird bereits verwendet): Der Versuch, einen Server (net, http oder https) an eine lokale Adresse zu binden, ist fehlgeschlagen, da bereits ein anderer Server auf dem lokalen System diese Adresse belegt.
ECONNREFUSED (Verbindung verweigert): Es konnte keine Verbindung hergestellt werden, weil der Zielrechner sie aktiv verweigert hat. Dies ist normalerweise die Folge des Versuchs, eine Verbindung zu einem Dienst herzustellen, der auf dem fremden Host inaktiv ist.
ECONNRESET (Verbindung vom Peer zurückgesetzt): Eine Verbindung wurde von einem Peer zwangsweise geschlossen. Dies ist normalerweise die Folge eines Verbindungsverlusts auf dem Remote-Socket aufgrund eines Timeouts oder eines Neustarts. Tritt häufig über die Module http und net auf.
EEXIST (Datei existiert): Eine vorhandene Datei war das Ziel einer Operation, die erforderte, dass das Ziel nicht existiert.
EISDIR (Ist ein Verzeichnis): Eine Operation erwartete eine Datei, aber der angegebene Pfadname war ein Verzeichnis.
EMFILE (Zu viele offene Dateien im System): Die maximal zulässige Anzahl von Dateideskriptoren auf dem System ist erreicht, und Anfragen nach einem weiteren Deskriptor können erst erfüllt werden, wenn mindestens einer geschlossen wurde. Dies tritt auf, wenn viele Dateien gleichzeitig parallel geöffnet werden, insbesondere auf Systemen (insbesondere macOS), auf denen es eine niedrige Dateideskriptorbegrenzung für Prozesse gibt. Um eine niedrige Begrenzung zu beheben, führen Sie ulimit -n 2048 in derselben Shell aus, in der der Node.js-Prozess ausgeführt wird.
ENOENT (Datei oder Verzeichnis nicht gefunden): Wird häufig von fs-Operationen ausgelöst, um anzuzeigen, dass eine Komponente des angegebenen Pfadnamens nicht vorhanden ist. Es konnte keine Entität (Datei oder Verzeichnis) unter dem angegebenen Pfad gefunden werden.
ENOTDIR (Kein Verzeichnis): Eine Komponente des angegebenen Pfadnamens existierte, war aber kein Verzeichnis wie erwartet. Wird häufig von fs.readdir ausgelöst.
ENOTEMPTY (Verzeichnis ist nicht leer): Ein Verzeichnis mit Einträgen war das Ziel einer Operation, die ein leeres Verzeichnis erfordert, normalerweise fs.unlink.
ENOTFOUND (DNS-Lookup fehlgeschlagen): Zeigt einen DNS-Fehler von entweder EAI_NODATA oder EAI_NONAME an. Dies ist kein Standard-POSIX-Fehler.
EPERM (Operation nicht erlaubt): Es wurde versucht, eine Operation durchzuführen, die erhöhte Privilegien erfordert.
EPIPE (Broken Pipe): Ein Schreibvorgang auf eine Pipe, einen Socket oder eine FIFO, für die kein Prozess zum Lesen der Daten vorhanden ist. Tritt häufig in den Schichten net und http auf und zeigt an, dass die Remote-Seite des Streams, in den geschrieben wird, geschlossen wurde.
ETIMEDOUT (Zeitüberschreitung bei der Operation): Eine Verbindungs- oder Sendeanforderung ist fehlgeschlagen, weil die verbundene Partei nach einer bestimmten Zeit nicht ordnungsgemäß geantwortet hat. Tritt normalerweise bei http oder net auf. Oft ein Zeichen dafür, dass socket.end() nicht ordnungsgemäß aufgerufen wurde.

Klasse: `TypeError`

Erweitert <errors.Error>

Zeigt an, dass ein bereitgestelltes Argument kein zulässiger Typ ist. Beispielsweise würde das Übergeben einer Funktion an einen Parameter, der eine Zeichenkette erwartet, ein TypeError sein.

require('node:url').parse(() => { });
// Wirft TypeError, da eine Zeichenkette erwartet wurde.

Node.js generiert und wirft TypeError-Instanzen sofort als eine Form der Argumentvalidierung.

Ausnahmen vs. Fehler

Eine JavaScript-Ausnahme ist ein Wert, der als Ergebnis einer ungültigen Operation oder als Ziel einer throw-Anweisung geworfen wird. Obwohl es nicht erforderlich ist, dass diese Werte Instanzen von Error oder von Klassen sind, die von Error erben, sind alle Ausnahmen, die von Node.js oder der JavaScript-Runtime geworfen werden, Instanzen von Error.

Einige Ausnahmen sind auf der JavaScript-Ebene nicht wiederherstellbar. Solche Ausnahmen führen immer zum Absturz des Node.js-Prozesses. Beispiele hierfür sind assert()-Prüfungen oder abort()-Aufrufe in der C++-Ebene.

OpenSSL-Fehler

Fehler, die in crypto oder tls ihren Ursprung haben, sind von der Klasse Error und können zusätzlich zu den Standardeigenschaften .code und .message einige zusätzliche OpenSSL-spezifische Eigenschaften aufweisen.

`error.opensslErrorStack`

Ein Array von Fehlern, das Kontext dazu geben kann, wo in der OpenSSL-Bibliothek ein Fehler seinen Ursprung hat.

`error.function`

Die OpenSSL-Funktion, in der der Fehler seinen Ursprung hat.

`error.library`

Die OpenSSL-Bibliothek, in der der Fehler seinen Ursprung hat.

`error.reason`

Eine für Menschen lesbare Zeichenkette, die den Grund für den Fehler beschreibt.

Node.js Fehlercodes

`ABORT_ERR`

Hinzugefügt in: v15.0.0

Wird verwendet, wenn ein Vorgang abgebrochen wurde (typischerweise mit einem AbortController).

APIs, die keine AbortSignal verwenden, werfen typischerweise keinen Fehler mit diesem Code.

Dieser Code verwendet nicht die reguläre ERR_*-Konvention, die Node.js-Fehler verwenden, um mit dem AbortError der Webplattform kompatibel zu sein.

`ERR_ACCESS_DENIED`

Eine spezielle Art von Fehler, der ausgelöst wird, wenn Node.js versucht, auf eine Ressource zuzugreifen, die durch das Berechtigungsmodell eingeschränkt ist.

`ERR_AMBIGUOUS_ARGUMENT`

Ein Funktionsargument wird so verwendet, dass die Funktionssignatur möglicherweise missverstanden wird. Dies wird vom node:assert-Modul ausgelöst, wenn der Parameter message in assert.throws(block, message) mit der von block ausgelösten Fehlermeldung übereinstimmt, da diese Verwendung darauf hindeutet, dass der Benutzer glaubt, message sei die erwartete Meldung und nicht die Meldung, die AssertionError anzeigt, wenn block keine Ausnahme auslöst.

`ERR_ARG_NOT_ITERABLE`

Ein iterierbares Argument (d. h. ein Wert, der mit for...of-Schleifen funktioniert) wurde benötigt, aber nicht an eine Node.js-API übergeben.

`ERR_ASSERTION`

Ein spezieller Fehlertyp, der ausgelöst werden kann, wenn Node.js eine außergewöhnliche Logikverletzung feststellt, die niemals auftreten sollte. Diese werden typischerweise vom node:assert-Modul ausgelöst.

`ERR_ASYNC_CALLBACK`

Es wurde versucht, etwas, das keine Funktion ist, als AsyncHooks-Callback zu registrieren.

`ERR_ASYNC_TYPE`

Der Typ einer asynchronen Ressource war ungültig. Benutzer können auch ihre eigenen Typen definieren, wenn sie die öffentliche Embedder-API verwenden.

`ERR_BROTLI_COMPRESSION_FAILED`

Daten, die an einen Brotli-Stream übergeben wurden, wurden nicht erfolgreich komprimiert.

`ERR_BROTLI_INVALID_PARAM`

Während der Konstruktion eines Brotli-Streams wurde ein ungültiger Parameterschlüssel übergeben.

`ERR_BUFFER_CONTEXT_NOT_AVAILABLE`

Es wurde versucht, eine Node.js Buffer-Instanz aus Addon- oder Embedder-Code zu erstellen, während sich die JS-Engine in einem Kontext befindet, der nicht mit einer Node.js-Instanz verbunden ist. Die an die Buffer-Methode übergebenen Daten sind zum Zeitpunkt der Rückgabe der Methode freigegeben worden.

Wenn dieser Fehler auftritt, ist eine mögliche Alternative zur Erstellung einer Buffer-Instanz die Erstellung eines normalen Uint8Array, der sich nur im Prototyp des resultierenden Objekts unterscheidet. Uint8Arrays werden im Allgemeinen in allen Node.js-Kern-APIs akzeptiert, in denen Buffers verwendet werden; sie sind in allen Kontexten verfügbar.

`ERR_BUFFER_OUT_OF_BOUNDS`

Es wurde ein Vorgang außerhalb der Grenzen eines Buffer versucht.

`ERR_BUFFER_TOO_LARGE`

Es wurde versucht, einen Buffer zu erstellen, der größer als die maximal zulässige Größe ist.

`ERR_CANNOT_WATCH_SIGINT`

Node.js konnte das SIGINT-Signal nicht überwachen.

`ERR_CHILD_CLOSED_BEFORE_REPLY`

Ein Kindprozess wurde geschlossen, bevor das Elternteil eine Antwort erhalten hat.

`ERR_CHILD_PROCESS_IPC_REQUIRED`

Wird verwendet, wenn ein Kindprozess ohne Angabe eines IPC-Kanals geforkt wird.

`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`

Wird verwendet, wenn der Hauptprozess versucht, Daten von der STDERR/STDOUT des Kindprozesses zu lesen, und die Länge der Daten größer ist als die Option maxBuffer.

`ERR_CLOSED_MESSAGE_PORT`

[Verlauf]

Version	Änderungen
v16.2.0, v14.17.1	Die Fehlermeldung wurde wieder eingeführt.
v11.12.0	Die Fehlermeldung wurde entfernt.
v10.5.0	Hinzugefügt in: v10.5.0

Es wurde versucht, eine MessagePort-Instanz in einem geschlossenen Zustand zu verwenden, normalerweise nachdem .close() aufgerufen wurde.

`ERR_CONSOLE_WRITABLE_STREAM`

Console wurde ohne stdout-Stream instanziiert, oder Console hat einen nicht-beschreibbaren stdout- oder stderr-Stream.

`ERR_CONSTRUCT_CALL_INVALID`

Hinzugefügt in: v12.5.0

Ein Klassenkonstruktor wurde aufgerufen, der nicht aufrufbar ist.

`ERR_CONSTRUCT_CALL_REQUIRED`

Ein Konstruktor für eine Klasse wurde ohne new aufgerufen.

`ERR_CONTEXT_NOT_INITIALIZED`

Der in die API übergebene vm-Kontext ist noch nicht initialisiert. Dies kann passieren, wenn während der Erstellung des Kontexts ein Fehler auftritt (und abgefangen wird), z. B. wenn die Zuweisung fehlschlägt oder die maximale Aufrufstapelgröße erreicht wird, wenn der Kontext erstellt wird.

`ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED`

Eine OpenSSL-Engine wurde angefordert (z. B. über die TLS-Optionen clientCertEngine oder privateKeyEngine), die von der verwendeten OpenSSL-Version nicht unterstützt wird, wahrscheinlich aufgrund des Kompilierzeit-Flags OPENSSL_NO_ENGINE.

`ERR_CRYPTO_ECDH_INVALID_FORMAT`

Ein ungültiger Wert für das Argument format wurde an die Methode getPublicKey() der Klasse crypto.ECDH() übergeben.

`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY`

Ein ungültiger Wert für das Argument key wurde an die Methode computeSecret() der Klasse crypto.ECDH() übergeben. Dies bedeutet, dass der öffentliche Schlüssel außerhalb der elliptischen Kurve liegt.

`ERR_CRYPTO_ENGINE_UNKNOWN`

Eine ungültige Krypto-Engine-Kennung wurde an require('node:crypto').setEngine() übergeben.

`ERR_CRYPTO_FIPS_FORCED`

Das Befehlszeilenargument --force-fips wurde verwendet, aber es gab einen Versuch, den FIPS-Modus im node:crypto-Modul zu aktivieren oder zu deaktivieren.

`ERR_CRYPTO_FIPS_UNAVAILABLE`

Es wurde versucht, den FIPS-Modus zu aktivieren oder zu deaktivieren, aber der FIPS-Modus war nicht verfügbar.

`ERR_CRYPTO_HASH_FINALIZED`

hash.digest() wurde mehrfach aufgerufen. Die Methode hash.digest() darf pro Instanz eines Hash-Objekts höchstens einmal aufgerufen werden.

`ERR_CRYPTO_HASH_UPDATE_FAILED`

hash.update() ist aus irgendeinem Grund fehlgeschlagen. Dies sollte selten bis gar nicht vorkommen.

`ERR_CRYPTO_INCOMPATIBLE_KEY`

Die angegebenen Krypto-Schlüssel sind mit der versuchten Operation inkompatibel.

`ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS`

Die ausgewählte öffentliche oder private Schlüsselcodierung ist mit anderen Optionen inkompatibel.

`ERR_CRYPTO_INITIALIZATION_FAILED`

Hinzugefügt in: v15.0.0

Die Initialisierung des Krypto-Subsystems ist fehlgeschlagen.

`ERR_CRYPTO_INVALID_AUTH_TAG`

Hinzugefügt in: v15.0.0

Ein ungültiges Authentifizierungs-Tag wurde bereitgestellt.

`ERR_CRYPTO_INVALID_COUNTER`

Hinzugefügt in: v15.0.0

Ein ungültiger Zähler wurde für einen Zählermodus-Cipher bereitgestellt.

`ERR_CRYPTO_INVALID_CURVE`

Hinzugefügt in: v15.0.0

Eine ungültige elliptische Kurve wurde bereitgestellt.

Der Typ des angegebenen Krypto-Schlüsselobjekts ist für die versuchte Operation ungültig.

`ERR_CRYPTO_INVALID_MESSAGELEN`

Hinzugefügt in: v15.0.0

Es wurde eine ungültige Nachrichtenlänge angegeben.

`ERR_CRYPTO_INVALID_SCRYPT_PARAMS`

Node.js wurde ohne scrypt-Unterstützung kompiliert. Mit den offiziellen Release-Binaries nicht möglich, kann aber bei benutzerdefinierten Builds, einschließlich Distro-Builds, vorkommen.

`ERR_CRYPTO_SIGN_KEY_REQUIRED`

Es wurde kein Signier-key an die Methode sign.sign() übergeben.

`ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH`

crypto.timingSafeEqual() wurde mit Buffer-, TypedArray- oder DataView-Argumenten unterschiedlicher Länge aufgerufen.

`ERR_CRYPTO_UNKNOWN_CIPHER`

Es wurde eine unbekannte Chiffre angegeben.

`ERR_CRYPTO_UNKNOWN_DH_GROUP`

Es wurde ein unbekannter Diffie-Hellman-Gruppenname angegeben. Siehe crypto.getDiffieHellman() für eine Liste gültiger Gruppennamen.

`ERR_CRYPTO_UNSUPPORTED_OPERATION`

Hinzugefügt in: v15.0.0, v14.18.0

Es wurde versucht, eine nicht unterstützte Krypto-Operation aufzurufen.

`ERR_DEBUGGER_ERROR`

Hinzugefügt in: v16.4.0, v14.17.4

Es ist ein Fehler mit dem Debugger aufgetreten.

`ERR_DEBUGGER_STARTUP_ERROR`

Hinzugefügt in: v16.4.0, v14.17.4

Beim Debugger ist eine Zeitüberschreitung aufgetreten, während darauf gewartet wurde, dass der erforderliche Host/Port frei wird.

`ERR_DIR_CLOSED`

Das fs.Dir wurde zuvor geschlossen.

`ERR_DIR_CONCURRENT_OPERATION`

Hinzugefügt in: v14.3.0

Es wurde versucht, einen synchronen Lese- oder Schließaufruf auf einem fs.Dir durchzuführen, der laufende asynchrone Operationen hat.

`ERR_DLOPEN_DISABLED`

Hinzugefügt in: v16.10.0, v14.19.0

Das Laden nativer Addons wurde mit --no-addons deaktiviert.

`ERR_DLOPEN_FAILED`

Hinzugefügt in: v15.0.0

Ein Aufruf von process.dlopen() ist fehlgeschlagen.

`ERR_DNS_SET_SERVERS_FAILED`

c-ares konnte den DNS-Server nicht festlegen.

`ERR_DOMAIN_CALLBACK_NOT_AVAILABLE`

Das Modul node:domain war nicht verwendbar, da es die erforderlichen Fehlerbehandlungshooks nicht einrichten konnte, da process.setUncaughtExceptionCaptureCallback() zu einem früheren Zeitpunkt aufgerufen worden war.

`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`

process.setUncaughtExceptionCaptureCallback() konnte nicht aufgerufen werden, da das Modul node:domain zu einem früheren Zeitpunkt geladen wurde.

Die Stack-Trace wird erweitert, um den Zeitpunkt einzubeziehen, zu dem das Modul node:domain geladen wurde.

`ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION`

v8.startupSnapshot.setDeserializeMainFunction() konnte nicht aufgerufen werden, da es bereits zuvor aufgerufen wurde.

`ERR_ENCODING_INVALID_ENCODED_DATA`

Die an die TextDecoder() API übergebenen Daten waren gemäß der bereitgestellten Kodierung ungültig.

`ERR_ENCODING_NOT_SUPPORTED`

Die an die TextDecoder() API übergebene Kodierung war keine der WHATWG Supported Encodings.

`ERR_EVAL_ESM_CANNOT_PRINT`

--print kann nicht mit ESM-Eingaben verwendet werden.

`ERR_EVENT_RECURSION`

Wird ausgelöst, wenn versucht wird, ein Ereignis rekursiv auf EventTarget zu verteilen.

`ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE`

Der JS-Ausführungskontext ist nicht mit einer Node.js-Umgebung verknüpft. Dies kann vorkommen, wenn Node.js als eingebettete Bibliothek verwendet wird und einige Hooks für die JS-Engine nicht korrekt eingerichtet sind.

`ERR_FALSY_VALUE_REJECTION`

Ein Promise, das über util.callbackify() callbackifiziert wurde, wurde mit einem Falsy-Wert verworfen.

`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`

Hinzugefügt in: v14.0.0

Es wurde versucht, mit fs.cp() in einen unbekannten Dateityp zu kopieren.

`ERR_FS_EISDIR`

Pfad ist ein Verzeichnis.

`ERR_FS_FILE_TOO_LARGE`

Es wurde versucht, eine Datei zu lesen, deren Größe die maximal zulässige Größe für einen Buffer überschreitet.

`ERR_HTTP2_ALTSVC_INVALID_ORIGIN`

HTTP/2 ALTSVC Frames erfordern einen gültigen Ursprung.

`ERR_HTTP2_ALTSVC_LENGTH`

HTTP/2 ALTSVC Frames sind auf maximal 16.382 Payload-Bytes begrenzt.

`ERR_HTTP2_CONNECT_AUTHORITY`

Für HTTP/2-Anfragen, die die CONNECT-Methode verwenden, ist der Pseudo-Header :authority erforderlich.

`ERR_HTTP2_CONNECT_PATH`

Für HTTP/2-Anfragen, die die CONNECT-Methode verwenden, ist der Pseudo-Header :path verboten.

`ERR_HTTP2_CONNECT_SCHEME`

Für HTTP/2-Anfragen, die die CONNECT-Methode verwenden, ist der Pseudo-Header :scheme verboten.

`ERR_HTTP2_ERROR`

Es ist ein nicht spezifischer HTTP/2-Fehler aufgetreten.

`ERR_HTTP2_GOAWAY_SESSION`

Nachdem die Http2Session einen GOAWAY-Frame vom verbundenen Peer empfangen hat, dürfen keine neuen HTTP/2-Streams mehr geöffnet werden.

`ERR_HTTP2_HEADERS_AFTER_RESPOND`

Nachdem eine HTTP/2-Antwort initiiert wurde, wurden zusätzliche Header angegeben.

`ERR_HTTP2_HEADERS_SENT`

Es wurde versucht, mehrere Antwort-Header zu senden.

`ERR_HTTP2_HEADER_SINGLE_VALUE`

Für ein HTTP/2-Header-Feld, das nur einen einzigen Wert haben sollte, wurden mehrere Werte angegeben.

`ERR_HTTP2_INFO_STATUS_NOT_ALLOWED`

Informationelle HTTP-Statuscodes (1xx) dürfen nicht als Antwortstatuscode für HTTP/2-Antworten festgelegt werden.

`ERR_HTTP2_INVALID_CONNECTION_HEADERS`

HTTP/1-Verbindungsspezifische Header dürfen nicht in HTTP/2-Anfragen und -Antworten verwendet werden.

`ERR_HTTP2_INVALID_HEADER_VALUE`

Es wurde ein ungültiger HTTP/2-Header-Wert angegeben.

`ERR_HTTP2_INVALID_INFO_STATUS`

Es wurde ein ungültiger HTTP-Informationsstatuscode angegeben. Informationsstatuscodes müssen eine Ganzzahl zwischen 100 und 199 (einschließlich) sein.

`ERR_HTTP2_INVALID_ORIGIN`

HTTP/2 ORIGIN-Frames erfordern einen gültigen Ursprung.

`ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH`

Eingabe Buffer- und Uint8Array-Instanzen, die an die http2.getUnpackedSettings()-API übergeben werden, müssen eine Länge haben, die ein Vielfaches von sechs ist.

`ERR_HTTP2_INVALID_PSEUDOHEADER`

Es dürfen nur gültige HTTP/2-Pseudo-Header (:status, :path, :authority, :scheme und :method) verwendet werden.

`ERR_HTTP2_INVALID_SESSION`

Es wurde eine Aktion auf einem Http2Session-Objekt durchgeführt, das bereits zerstört wurde.

`ERR_HTTP2_INVALID_SETTING_VALUE`

Es wurde ein ungültiger Wert für eine HTTP/2-Einstellung angegeben.

`ERR_HTTP2_INVALID_STREAM`

Es wurde eine Operation auf einem Stream ausgeführt, der bereits zerstört wurde.

`ERR_HTTP2_MAX_PENDING_SETTINGS_ACK`

Wann immer ein HTTP/2 SETTINGS-Frame an einen verbundenen Peer gesendet wird, ist der Peer verpflichtet, eine Bestätigung zu senden, dass er die neuen SETTINGS empfangen und angewendet hat. Standardmäßig kann eine maximale Anzahl von unbestätigten SETTINGS-Frames zu einem bestimmten Zeitpunkt gesendet werden. Dieser Fehlercode wird verwendet, wenn dieses Limit erreicht wurde.

`ERR_HTTP2_NESTED_PUSH`

Es wurde versucht, einen neuen Push-Stream innerhalb eines Push-Streams zu initiieren. Verschachtelte Push-Streams sind nicht zulässig.

`ERR_HTTP2_NO_MEM`

Nicht genügend Speicher bei Verwendung der http2session.setLocalWindowSize(windowSize) API.

`ERR_HTTP2_NO_SOCKET_MANIPULATION`

Es wurde versucht, einen Socket, der an eine Http2Session angehängt ist, direkt zu manipulieren (lesen, schreiben, pausieren, fortsetzen usw.).

`ERR_HTTP2_ORIGIN_LENGTH`

HTTP/2 ORIGIN-Frames sind auf eine Länge von 16382 Byte begrenzt.

`ERR_HTTP2_OUT_OF_STREAMS`

Die Anzahl der Streams, die in einer einzelnen HTTP/2-Sitzung erstellt wurden, hat das maximale Limit erreicht.

`ERR_HTTP2_PAYLOAD_FORBIDDEN`

Es wurde eine Nachrichten-Payload für einen HTTP-Antwortcode angegeben, für den eine Payload verboten ist.

`ERR_HTTP2_PING_CANCEL`

Ein HTTP/2-Ping wurde abgebrochen.

`ERR_HTTP2_PING_LENGTH`

HTTP/2-Ping-Nutzlasten müssen genau 8 Byte lang sein.

`ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED`

Ein HTTP/2-Pseudo-Header wurde unangemessen verwendet. Pseudo-Header sind Header-Schlüsselnamen, die mit dem Präfix : beginnen.

`ERR_HTTP2_PUSH_DISABLED`

Es wurde versucht, einen Push-Stream zu erstellen, der vom Client deaktiviert wurde.

`ERR_HTTP2_SEND_FILE`

Es wurde versucht, die Http2Stream.prototype.responseWithFile()-API zu verwenden, um ein Verzeichnis zu senden.

`ERR_HTTP2_SEND_FILE_NOSEEK`

Es wurde versucht, die Http2Stream.prototype.responseWithFile()-API zu verwenden, um etwas anderes als eine reguläre Datei zu senden, aber die Optionen offset oder length wurden angegeben.

`ERR_HTTP2_SESSION_ERROR`

Die Http2Session wurde mit einem Fehlercode ungleich Null geschlossen.

`ERR_HTTP2_SETTINGS_CANCEL`

Die Http2Session-Einstellungen wurden abgebrochen.

`ERR_HTTP2_SOCKET_BOUND`

Es wurde versucht, ein Http2Session-Objekt mit einem net.Socket oder tls.TLSSocket zu verbinden, der/das bereits an ein anderes Http2Session-Objekt gebunden war.

`ERR_HTTP2_SOCKET_UNBOUND`

Es wurde versucht, die socket-Eigenschaft einer Http2Session zu verwenden, die bereits geschlossen wurde.

`ERR_HTTP2_STATUS_101`

Die Verwendung des Informations-Statuscodes 101 ist in HTTP/2 verboten.

`ERR_HTTP2_STATUS_INVALID`

Ein ungültiger HTTP-Statuscode wurde angegeben. Statuscodes müssen eine ganze Zahl zwischen 100 und 599 (einschließlich) sein.

`ERR_HTTP2_STREAM_CANCEL`

Ein Http2Stream wurde zerstört, bevor Daten an den verbundenen Peer übertragen wurden.

`ERR_HTTP2_STREAM_ERROR`

Ein Fehlercode ungleich Null wurde in einem RST_STREAM-Frame angegeben.

`ERR_HTTP2_STREAM_SELF_DEPENDENCY`

Beim Festlegen der Priorität für einen HTTP/2-Stream kann der Stream als Abhängigkeit für einen übergeordneten Stream markiert werden. Dieser Fehlercode wird verwendet, wenn versucht wird, einen Stream als abhängig von sich selbst zu markieren.

`ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS`

Die Anzahl der unterstützten benutzerdefinierten Einstellungen (10) wurde überschritten.

`ERR_HTTP2_TOO_MANY_INVALID_FRAMES`

Hinzugefügt in: v15.14.0

Das Limit für akzeptable ungültige HTTP/2-Protokoll-Frames, die vom Peer gesendet wurden, wie durch die Option maxSessionInvalidFrames festgelegt, wurde überschritten.

`ERR_HTTP2_TRAILERS_ALREADY_SENT`

Trailing Headers wurden bereits im Http2Stream gesendet.

`ERR_HTTP2_TRAILERS_NOT_READY`

Die Methode http2stream.sendTrailers() kann erst aufgerufen werden, nachdem das 'wantTrailers'-Ereignis für ein Http2Stream-Objekt ausgegeben wurde. Das 'wantTrailers'-Ereignis wird nur ausgegeben, wenn die Option waitForTrailers für den Http2Stream festgelegt ist.

`ERR_HTTP2_UNSUPPORTED_PROTOCOL`

An http2.connect() wurde eine URL übergeben, die ein anderes Protokoll als http: oder https: verwendet.

`ERR_HTTP_BODY_NOT_ALLOWED`

Ein Fehler wird ausgelöst, wenn in eine HTTP-Antwort geschrieben wird, die keine Inhalte zulässt.

`ERR_HTTP_CONTENT_LENGTH_MISMATCH`

Die Größe des Antworttextes stimmt nicht mit dem angegebenen Content-Length-Header-Wert überein.

`ERR_HTTP_HEADERS_SENT`

Es wurde versucht, weitere Header hinzuzufügen, nachdem die Header bereits gesendet wurden.

`ERR_HTTP_INVALID_HEADER_VALUE`

Es wurde ein ungültiger HTTP-Header-Wert angegeben.

`ERR_HTTP_INVALID_STATUS_CODE`

Der Statuscode lag außerhalb des regulären Statuscode-Bereichs (100-999).

`ERR_HTTP_REQUEST_TIMEOUT`

Der Client hat die vollständige Anfrage nicht innerhalb der zulässigen Zeit gesendet.

`ERR_HTTP_SOCKET_ASSIGNED`

Dem angegebenen ServerResponse wurde bereits ein Socket zugewiesen.

`ERR_HTTP_SOCKET_ENCODING`

Das Ändern der Socket-Kodierung ist gemäß RFC 7230 Abschnitt 3 nicht zulässig.

`ERR_HTTP_TRAILER_INVALID`

Der Trailer-Header wurde gesetzt, obwohl die Transferkodierung dies nicht unterstützt.

`ERR_ILLEGAL_CONSTRUCTOR`

Es wurde versucht, ein Objekt mit einem nicht-öffentlichen Konstruktor zu erstellen.

`ERR_IMPORT_ATTRIBUTE_MISSING`

Hinzugefügt in: v21.1.0

Ein Import-Attribut fehlt, wodurch der Import des angegebenen Moduls verhindert wird.

`ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE`

Hinzugefügt in: v21.1.0

Ein Import-type-Attribut wurde angegeben, aber das angegebene Modul ist von einem anderen Typ.

`ERR_IMPORT_ATTRIBUTE_UNSUPPORTED`

Hinzugefügt in: v21.0.0, v20.10.0, v18.19.0

Ein Import-Attribut wird von dieser Version von Node.js nicht unterstützt.

`ERR_INCOMPATIBLE_OPTION_PAIR`

Ein Optionspaar ist miteinander inkompatibel und kann nicht gleichzeitig verwendet werden.

`ERR_INPUT_TYPE_NOT_ALLOWED`

[Stable: 1 - Experimental]

Stable: 1 Stabilität: 1 - Experimentell

Das Flag --input-type wurde verwendet, um zu versuchen, eine Datei auszuführen. Dieses Flag kann nur mit Eingaben über --eval, --print oder STDIN verwendet werden.

`ERR_INSPECTOR_ALREADY_ACTIVATED`

Bei der Verwendung des node:inspector-Moduls wurde versucht, den Inspector zu aktivieren, obwohl er bereits begonnen hatte, an einem Port zu lauschen. Verwenden Sie inspector.close(), bevor Sie ihn an einer anderen Adresse aktivieren.

`ERR_INSPECTOR_ALREADY_CONNECTED`

Bei der Verwendung des node:inspector-Moduls wurde versucht, eine Verbindung herzustellen, obwohl der Inspector bereits verbunden war.

`ERR_INSPECTOR_CLOSED`

Bei der Verwendung des node:inspector-Moduls wurde versucht, den Inspector zu verwenden, nachdem die Sitzung bereits geschlossen war.

`ERR_INSPECTOR_COMMAND`

Beim Ausführen eines Befehls über das node:inspector-Modul ist ein Fehler aufgetreten.

`ERR_INSPECTOR_NOT_ACTIVE`

Der inspector ist nicht aktiv, wenn inspector.waitForDebugger() aufgerufen wird.

`ERR_INSPECTOR_NOT_AVAILABLE`

Das node:inspector-Modul steht nicht zur Verfügung.

`ERR_INSPECTOR_NOT_CONNECTED`

Bei der Verwendung des node:inspector-Moduls wurde versucht, den Inspector zu verwenden, bevor er verbunden war.

`ERR_INSPECTOR_NOT_WORKER`

Eine API wurde im Hauptthread aufgerufen, die nur vom Worker-Thread aus verwendet werden kann.

`ERR_INTERNAL_ASSERTION`

Es gab einen Fehler in Node.js oder eine falsche Verwendung von Node.js-Interna. Um den Fehler zu beheben, öffnen Sie ein Issue unter https://github.com/nodejs/node/issues.

`ERR_INVALID_ADDRESS`

Die bereitgestellte Adresse wird von der Node.js-API nicht verstanden.

`ERR_INVALID_ADDRESS_FAMILY`

Die bereitgestellte Adressfamilie wird von der Node.js-API nicht verstanden.

`ERR_INVALID_ARG_TYPE`

Ein Argument des falschen Typs wurde an eine Node.js-API übergeben.

`ERR_INVALID_ARG_VALUE`

Ein ungültiger oder nicht unterstützter Wert wurde für ein bestimmtes Argument übergeben.

`ERR_INVALID_ASYNC_ID`

Eine ungültige asyncId oder triggerAsyncId wurde mit AsyncHooks übergeben. Eine ID kleiner als -1 sollte niemals vorkommen.

`ERR_INVALID_BUFFER_SIZE`

Ein Swap wurde auf einem Buffer durchgeführt, aber seine Größe war nicht mit der Operation kompatibel.

`ERR_INVALID_CHAR`

Ungültige Zeichen wurden in Headern erkannt.

`ERR_INVALID_CURSOR_POS`

Ein Cursor in einem gegebenen Stream kann nicht ohne eine bestimmte Spalte in eine bestimmte Zeile verschoben werden.

`ERR_INVALID_FD`

Ein Dateideskriptor ('fd') war ungültig (z. B. hatte er einen negativen Wert).

`ERR_INVALID_FD_TYPE`

Ein Dateideskriptor-Typ ('fd') war ungültig.

`ERR_INVALID_FILE_URL_HOST`

Eine Node.js-API, die file:-URLs verarbeitet (wie z. B. bestimmte Funktionen im fs-Modul), hat eine Datei-URL mit einem inkompatiblen Host gefunden. Diese Situation kann nur auf Unix-ähnlichen Systemen auftreten, wo nur localhost oder ein leerer Host unterstützt werden.

`ERR_INVALID_FILE_URL_PATH`

Eine Node.js-API, die file:-URLs verarbeitet (wie z. B. bestimmte Funktionen im fs-Modul), hat eine Datei-URL mit einem inkompatiblen Pfad gefunden. Die genaue Semantik zur Bestimmung, ob ein Pfad verwendet werden kann, ist plattformabhängig.

`ERR_INVALID_HANDLE_TYPE`

Es wurde versucht, ein nicht unterstütztes "Handle" über einen IPC-Kommunikationskanal an einen Child-Prozess zu senden. Weitere Informationen finden Sie unter subprocess.send() und process.send().

`ERR_INVALID_HTTP_TOKEN`

Ein ungültiges HTTP-Token wurde angegeben.

`ERR_INVALID_IP_ADDRESS`

Eine IP-Adresse ist ungültig.

`ERR_INVALID_MIME_SYNTAX`

Die Syntax eines MIME ist ungültig.

`ERR_INVALID_MODULE`

Hinzugefügt in: v15.0.0, v14.18.0

Es wurde versucht, ein Modul zu laden, das nicht existiert oder auf andere Weise ungültig war.

`ERR_INVALID_MODULE_SPECIFIER`

Die importierte Modulzeichenkette ist eine ungültige URL, ein Paketname oder eine Paket-Subpfad-Spezifikation.

`ERR_INVALID_OBJECT_DEFINE_PROPERTY`

Beim Festlegen eines ungültigen Attributs für die Eigenschaft eines Objekts ist ein Fehler aufgetreten.

`ERR_INVALID_PACKAGE_CONFIG`

Eine ungültige package.json-Datei konnte nicht geparst werden.

`ERR_INVALID_PACKAGE_TARGET`

Das Feld "exports" von package.json enthält einen ungültigen Zielzuordnungswert für die versuchte Modulauflösung.

`ERR_INVALID_PROTOCOL`

Ein ungültiges options.protocol wurde an http.request() übergeben.

`ERR_INVALID_REPL_EVAL_CONFIG`

Sowohl die Option breakEvalOnSigint als auch die Option eval wurden in der REPL-Konfiguration gesetzt, was nicht unterstützt wird.

`ERR_INVALID_REPL_INPUT`

Die Eingabe darf in der REPL nicht verwendet werden. Die Bedingungen, unter denen dieser Fehler verwendet wird, sind in der REPL-Dokumentation beschrieben.

`ERR_INVALID_RETURN_PROPERTY`

Wird ausgelöst, wenn eine Funktionsoption keinen gültigen Wert für eine ihrer zurückgegebenen Objekteigenschaften bei der Ausführung liefert.

`ERR_INVALID_RETURN_PROPERTY_VALUE`

Wird ausgelöst, wenn eine Funktionsoption keinen erwarteten Werttyp für eine ihrer zurückgegebenen Objekteigenschaften bei der Ausführung liefert.

`ERR_INVALID_RETURN_VALUE`

Wird ausgelöst, wenn eine Funktionsoption bei der Ausführung keinen erwarteten Werttyp zurückgibt, z. B. wenn von einer Funktion erwartet wird, dass sie eine Promise zurückgibt.

`ERR_INVALID_STATE`

Hinzugefügt in: v15.0.0

Gibt an, dass ein Vorgang aufgrund eines ungültigen Zustands nicht abgeschlossen werden kann. Beispielsweise wurde ein Objekt möglicherweise bereits zerstört oder führt einen anderen Vorgang aus.

`ERR_INVALID_SYNC_FORK_INPUT`

Ein Buffer, TypedArray, DataView oder string wurde als stdio-Eingabe an einen asynchronen Fork übergeben. Weitere Informationen finden Sie in der Dokumentation des Moduls child_process.

`ERR_INVALID_THIS`

Eine Node.js-API-Funktion wurde mit einem inkompatiblen this-Wert aufgerufen.

const urlSearchParams = new URLSearchParams('foo=bar&baz=new');

const buf = Buffer.alloc(1);
urlSearchParams.has.call(buf, 'foo');
// Wirft einen TypeError mit dem Code 'ERR_INVALID_THIS'

`ERR_INVALID_TUPLE`

Ein Element in dem iterable, das dem WHATWG URLSearchParams-Konstruktor bereitgestellt wurde, stellte kein [name, value]-Tupel dar – das heißt, wenn ein Element nicht iterierbar ist oder nicht aus genau zwei Elementen besteht.

`ERR_INVALID_TYPESCRIPT_SYNTAX`

Hinzugefügt in: v23.0.0

Die bereitgestellte TypeScript-Syntax ist ungültig oder wird nicht unterstützt. Dies kann vorkommen, wenn TypeScript-Syntax verwendet wird, die eine Transformation mit Type-Stripping erfordert.

`ERR_INVALID_URI`

Eine ungültige URI wurde übergeben.

`ERR_INVALID_URL`

Eine ungültige URL wurde an den WHATWG URL-Konstruktor oder das Legacy url.parse() zur Analyse übergeben. Das ausgelöste Fehlerobjekt hat typischerweise eine zusätzliche Eigenschaft 'input', die die URL enthält, deren Analyse fehlgeschlagen ist.

`ERR_INVALID_URL_SCHEME`

Es wurde versucht, eine URL mit einem inkompatiblen Schema (Protokoll) für einen bestimmten Zweck zu verwenden. Sie wird nur in der WHATWG URL API-Unterstützung im fs-Modul verwendet (das nur URLs mit dem Schema 'file' akzeptiert), kann aber in Zukunft auch in anderen Node.js-APIs verwendet werden.

`ERR_IPC_CHANNEL_CLOSED`

Es wurde versucht, einen IPC-Kommunikationskanal zu verwenden, der bereits geschlossen war.

`ERR_IPC_DISCONNECTED`

Es wurde versucht, einen IPC-Kommunikationskanal zu trennen, der bereits getrennt war. Weitere Informationen finden Sie in der Dokumentation des child_process-Moduls.

`ERR_IPC_ONE_PIPE`

Es wurde versucht, einen untergeordneten Node.js-Prozess mit mehr als einem IPC-Kommunikationskanal zu erstellen. Weitere Informationen finden Sie in der Dokumentation des child_process-Moduls.

`ERR_IPC_SYNC_FORK`

Es wurde versucht, einen IPC-Kommunikationskanal mit einem synchron geforkten Node.js-Prozess zu öffnen. Weitere Informationen finden Sie in der Dokumentation des Moduls child_process.

`ERR_IP_BLOCKED`

IP wird von net.BlockList blockiert.

`ERR_LOADER_CHAIN_INCOMPLETE`

Hinzugefügt in: v18.6.0, v16.17.0

Ein ESM-Loader-Hook gab zurück, ohne next() aufzurufen und ohne explizit einen Kurzschluss zu signalisieren.

`ERR_LOAD_SQLITE_EXTENSION`

Hinzugefügt in: v23.5.0

Beim Laden einer SQLite-Erweiterung ist ein Fehler aufgetreten.

`ERR_MEMORY_ALLOCATION_FAILED`

Es wurde versucht, Speicher zu allozieren (normalerweise in der C++-Schicht), aber dies schlug fehl.

`ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE`

Hinzugefügt in: v14.5.0, v12.19.0

Eine an einen MessagePort gesendete Nachricht konnte im Ziel-vm-Context nicht deserialisiert werden. Nicht alle Node.js-Objekte können derzeit in jedem Kontext erfolgreich instanziiert werden, und der Versuch, sie mit postMessage() zu übertragen, kann in diesem Fall auf der Empfängerseite fehlschlagen.

`ERR_METHOD_NOT_IMPLEMENTED`

Eine Methode ist erforderlich, aber nicht implementiert.

`ERR_MISSING_ARGS`

Ein erforderliches Argument einer Node.js-API wurde nicht übergeben. Dies wird nur zur strikten Einhaltung der API-Spezifikation verwendet (die in einigen Fällen func(undefined) akzeptieren kann, aber nicht func()). In den meisten nativen Node.js-APIs werden func(undefined) und func() identisch behandelt, und stattdessen kann der Fehlercode ERR_INVALID_ARG_TYPE verwendet werden.

`ERR_MISSING_OPTION`

Für APIs, die Options-Objekte akzeptieren, können einige Optionen obligatorisch sein. Dieser Code wird ausgelöst, wenn eine erforderliche Option fehlt.

`ERR_MISSING_PASSPHRASE`

Es wurde versucht, einen verschlüsselten Schlüssel zu lesen, ohne eine Passphrase anzugeben.

`ERR_MISSING_PLATFORM_FOR_WORKER`

Die von dieser Node.js-Instanz verwendete V8-Plattform unterstützt das Erstellen von Workern nicht. Dies wird durch fehlende Embedder-Unterstützung für Worker verursacht. Insbesondere tritt dieser Fehler nicht bei Standard-Builds von Node.js auf.

`ERR_MODULE_NOT_FOUND`

Eine Moduldatei konnte vom ECMAScript-Modul-Loader nicht aufgelöst werden, während ein import-Vorgang versucht wurde oder beim Laden des Programmeinstiegspunkts.

`ERR_MULTIPLE_CALLBACK`

Ein Callback wurde mehr als einmal aufgerufen.

Ein Callback ist fast immer dazu gedacht, nur einmal aufgerufen zu werden, da die Abfrage entweder erfüllt oder abgelehnt werden kann, aber nicht beides gleichzeitig. Letzteres wäre möglich, indem ein Callback mehr als einmal aufgerufen wird.

`ERR_NAPI_CONS_FUNCTION`

Bei der Verwendung von Node-API war ein übergebener Konstruktor keine Funktion.

`ERR_NAPI_INVALID_DATAVIEW_ARGS`

Beim Aufruf von napi_create_dataview() lag ein gegebener offset außerhalb der Grenzen der Datenansicht oder offset + length war größer als die Länge des gegebenen buffer.

`ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT`

Beim Aufruf von napi_create_typedarray() war der bereitgestellte offset kein Vielfaches der Elementgröße.

`ERR_NAPI_INVALID_TYPEDARRAY_LENGTH`

Beim Aufruf von napi_create_typedarray() war (length * size_of_element) + byte_offset größer als die Länge des gegebenen buffer.

`ERR_NAPI_TSFN_CALL_JS`

Beim Aufrufen des JavaScript-Teils der Thread-sicheren Funktion ist ein Fehler aufgetreten.

`ERR_NAPI_TSFN_GET_UNDEFINED`

Beim Versuch, den JavaScript-Wert undefined abzurufen, ist ein Fehler aufgetreten.

`ERR_NON_CONTEXT_AWARE_DISABLED`

Ein Non-Context-Aware natives Addon wurde in einem Prozess geladen, der diese nicht zulässt.

`ERR_NOT_BUILDING_SNAPSHOT`

Es wurde versucht, Operationen zu verwenden, die nur beim Erstellen eines V8-Startup-Snapshots verwendet werden können, obwohl Node.js keinen erstellt.

`ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION`

Hinzugefügt in: v21.7.0, v20.12.0

Die Operation kann nicht ausgeführt werden, wenn sie sich nicht in einer Single-Executable-Anwendung befindet.

`ERR_NOT_SUPPORTED_IN_SNAPSHOT`

Es wurde versucht, Operationen auszuführen, die beim Erstellen eines Startup-Snapshots nicht unterstützt werden.

`ERR_NO_CRYPTO`

Es wurde versucht, Crypto-Funktionen zu verwenden, während Node.js nicht mit OpenSSL-Crypto-Unterstützung kompiliert wurde.

`ERR_NO_ICU`

Es wurde versucht, Funktionen zu nutzen, die ICU erfordern, aber Node.js wurde nicht mit ICU-Unterstützung kompiliert.

`ERR_NO_TYPESCRIPT`

Hinzugefügt in: v23.0.0

Es wurde versucht, Funktionen zu nutzen, die Native TypeScript Unterstützung erfordern, aber Node.js wurde nicht mit TypeScript-Unterstützung kompiliert.

`ERR_OPERATION_FAILED`

Hinzugefügt in: v15.0.0

Eine Operation ist fehlgeschlagen. Dies wird typischerweise verwendet, um das allgemeine Scheitern einer asynchronen Operation zu signalisieren.

`ERR_OUT_OF_RANGE`

Ein gegebener Wert liegt außerhalb des zulässigen Bereichs.

`ERR_PACKAGE_IMPORT_NOT_DEFINED`

Das Feld package.json "imports" definiert keine Zuordnung für den gegebenen internen Paket-Spezifizierer.

`ERR_PACKAGE_PATH_NOT_EXPORTED`

Das Feld package.json "exports" exportiert nicht den angeforderten Unterpfad. Da Exporte gekapselt sind, können private interne Module, die nicht exportiert werden, nicht über die Paketauflösung importiert werden, es sei denn, es wird eine absolute URL verwendet.

`ERR_PARSE_ARGS_INVALID_OPTION_VALUE`

Hinzugefügt in: v18.3.0, v16.17.0

Wenn strict auf true gesetzt ist, wird dies von util.parseArgs() ausgelöst, wenn ein <boolean>-Wert für eine Option vom Typ <string> angegeben wird, oder wenn ein <string>-Wert für eine Option vom Typ <boolean> angegeben wird.

`ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL`

Hinzugefügt in: v18.3.0, v16.17.0

Wird von util.parseArgs() ausgelöst, wenn ein Positionsargument angegeben wird und allowPositionals auf false gesetzt ist.

`ERR_PARSE_ARGS_UNKNOWN_OPTION`

Hinzugefügt in: v18.3.0, v16.17.0

Wenn strict auf true gesetzt ist, wird dies von util.parseArgs() ausgelöst, wenn ein Argument nicht in options konfiguriert ist.

`ERR_PERFORMANCE_INVALID_TIMESTAMP`

Ein ungültiger Zeitstempelwert wurde für eine Performance-Markierung oder -Messung angegeben.

`ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS`

Stable: 1 Stabilität: 1 - Experimentell

Beim Versuch, ein ES-Modul mit require() zu laden, beteiligt sich eine CommonJS-zu-ESM- oder ESM-zu-CommonJS-Kante an einem unmittelbaren Zyklus. Dies ist nicht zulässig, da ES-Module nicht ausgewertet werden können, während sie bereits ausgewertet werden.

Um den Zyklus zu vermeiden, sollte der am Zyklus beteiligte require()-Aufruf nicht auf oberster Ebene eines ES-Moduls (über createRequire()) oder eines CommonJS-Moduls erfolgen, sondern lazy in einer inneren Funktion erfolgen.

`ERR_REQUIRE_ESM`

[Verlauf]

Version	Änderungen
v23.0.0	require() unterstützt jetzt standardmäßig das Laden synchroner ES-Module.

[Stable: 0 - Deprecated]

Stable: 0 Stabilität: 0 - Veraltet

Es wurde versucht, ein ES-Modul mit require() zu laden.

Dieser Fehler ist veraltet, da require() jetzt das Laden synchroner ES-Module unterstützt. Wenn require() auf ein ES-Modul stößt, das Top-Level await enthält, wird stattdessen ERR_REQUIRE_ASYNC_MODULE ausgelöst.

`ERR_SCRIPT_EXECUTION_INTERRUPTED`

Die Skriptausführung wurde durch SIGINT unterbrochen (zum Beispiel wurde + gedrückt).

`ERR_SCRIPT_EXECUTION_TIMEOUT`

Die Skriptausführung hat das Zeitlimit überschritten, möglicherweise aufgrund von Fehlern im ausgeführten Skript.

`ERR_SERVER_ALREADY_LISTEN`

Die Methode server.listen() wurde aufgerufen, während ein net.Server bereits auf eingehende Verbindungen wartete. Dies gilt für alle Instanzen von net.Server, einschließlich HTTP-, HTTPS- und HTTP/2-Server-Instanzen.

`ERR_SERVER_NOT_RUNNING`

Die Methode server.close() wurde aufgerufen, als ein net.Server nicht lief. Dies gilt für alle Instanzen von net.Server, einschließlich HTTP-, HTTPS- und HTTP/2-Server-Instanzen.

`ERR_SINGLE_EXECUTABLE_APPLICATION_ASSET_NOT_FOUND`

Hinzugefügt in: v21.7.0, v20.12.0

Ein Schlüssel wurde an Single Executable Application APIs übergeben, um ein Asset zu identifizieren, aber es konnte keine Übereinstimmung gefunden werden.

`ERR_SOCKET_ALREADY_BOUND`

Es wurde versucht, einen Socket zu binden, der bereits gebunden ist.

`ERR_SOCKET_BAD_BUFFER_SIZE`

Für die Optionen recvBufferSize oder sendBufferSize in dgram.createSocket() wurde eine ungültige (negative) Größe übergeben.

`ERR_SOCKET_BAD_PORT`

Eine API-Funktion, die einen Port >= 0 und < 65536 erwartet, hat einen ungültigen Wert erhalten.

`ERR_SOCKET_BAD_TYPE`

Eine API-Funktion, die einen Socket-Typ (udp4 oder udp6) erwartet, hat einen ungültigen Wert erhalten.

`ERR_SOCKET_BUFFER_SIZE`

Bei der Verwendung von dgram.createSocket() konnte die Größe des Empfangs- oder Sende-Buffer nicht bestimmt werden.

`ERR_SOCKET_CLOSED`

Es wurde versucht, eine Operation auf einem bereits geschlossenen Socket durchzuführen.

`ERR_SOCKET_CLOSED_BEFORE_CONNECTION`

Beim Aufruf von net.Socket.write() auf einem verbindenden Socket wurde der Socket geschlossen, bevor die Verbindung hergestellt wurde.

`ERR_SOCKET_CONNECTION_TIMEOUT`

Der Socket konnte sich nicht mit einer der Adressen verbinden, die vom DNS innerhalb des zulässigen Timeouts zurückgegeben wurden, als der Familienauswahlalgorithmus verwendet wurde.

`ERR_SOCKET_DGRAM_IS_CONNECTED`

Ein dgram.connect()-Aufruf wurde auf einem bereits verbundenen Socket durchgeführt.

`ERR_SOCKET_DGRAM_NOT_CONNECTED`

Ein dgram.disconnect()- oder dgram.remoteAddress()-Aufruf wurde auf einem nicht verbundenen Socket durchgeführt.

`ERR_SOCKET_DGRAM_NOT_RUNNING`

Es wurde ein Aufruf getätigt und das UDP-Subsystem lief nicht.

`ERR_SOURCE_MAP_CORRUPT`

Die Source Map konnte nicht geparst werden, da sie nicht existiert oder beschädigt ist.

`ERR_SOURCE_MAP_MISSING_SOURCE`

Eine aus einer Source Map importierte Datei wurde nicht gefunden.

`ERR_SQLITE_ERROR`

Hinzugefügt in: v22.5.0

Ein Fehler wurde von SQLite zurückgegeben.

`ERR_SRI_PARSE`

Eine Zeichenkette wurde für eine Subresource Integrity-Prüfung bereitgestellt, konnte aber nicht geparst werden. Überprüfen Sie das Format der Integritätsattribute, indem Sie sich die Subresource Integrity-Spezifikation ansehen.

`ERR_STREAM_ALREADY_FINISHED`

Eine Stream-Methode wurde aufgerufen, die nicht abgeschlossen werden kann, da der Stream beendet wurde.

`ERR_STREAM_CANNOT_PIPE`

Es wurde versucht, stream.pipe() auf einem Writable Stream aufzurufen.

`ERR_STREAM_DESTROYED`

Eine Stream-Methode wurde aufgerufen, die nicht abgeschlossen werden kann, da der Stream mit stream.destroy() zerstört wurde.

`ERR_STREAM_NULL_VALUES`

Es wurde versucht, stream.write() mit einem null-Chunk aufzurufen.

`ERR_STREAM_PREMATURE_CLOSE`

Ein Fehler, der von stream.finished() und stream.pipeline() zurückgegeben wird, wenn ein Stream oder eine Pipeline nicht ordnungsgemäß ohne expliziten Fehler endet.

`ERR_STREAM_PUSH_AFTER_EOF`

Es wurde versucht, stream.push() aufzurufen, nachdem ein null (EOF) in den Stream gepusht wurde.

`ERR_STREAM_UNABLE_TO_PIPE`

Es wurde versucht, an einen geschlossenen oder zerstörten Stream in einer Pipeline zu pipen.

`ERR_STREAM_UNSHIFT_AFTER_END_EVENT`

Es wurde versucht, stream.unshift() aufzurufen, nachdem das 'end'-Ereignis emittiert wurde.

`ERR_STREAM_WRAP`

Verhindert einen Abbruch, wenn ein String-Decoder auf dem Socket gesetzt wurde oder sich der Decoder im objectMode befindet.

const Socket = require('node:net').Socket;
const instance = new Socket();

instance.setEncoding('utf8');

`ERR_STREAM_WRITE_AFTER_END`

Es wurde versucht, stream.write() aufzurufen, nachdem stream.end() aufgerufen wurde.

`ERR_STRING_TOO_LONG`

Es wurde versucht, einen String zu erstellen, der länger als die maximal zulässige Länge ist.

`ERR_SYNTHETIC`

Ein künstliches Fehlerobjekt, das verwendet wird, um den Aufrufstapel für Diagnoseberichte zu erfassen.

`ERR_SYSTEM_ERROR`

Innerhalb des Node.js-Prozesses ist ein unspezifischer oder nicht näher bezeichneter Systemfehler aufgetreten. Das Fehlerobjekt verfügt über eine err.info-Objekteigenschaft mit zusätzlichen Details.

`ERR_TAP_LEXER_ERROR`

Ein Fehler, der einen fehlerhaften Lexer-Status darstellt.

`ERR_TAP_PARSER_ERROR`

Ein Fehler, der einen fehlerhaften Parser-Status darstellt. Zusätzliche Informationen über das Token, das den Fehler verursacht, sind über die cause-Eigenschaft verfügbar.

`ERR_TAP_VALIDATION_ERROR`

Dieser Fehler stellt eine fehlgeschlagene TAP-Validierung dar.

`ERR_TEST_FAILURE`

Dieser Fehler stellt einen fehlgeschlagenen Test dar. Zusätzliche Informationen über den Fehler sind über die cause-Eigenschaft verfügbar. Die Eigenschaft failureType gibt an, was der Test gemacht hat, als der Fehler aufgetreten ist.

`ERR_TLS_ALPN_CALLBACK_INVALID_RESULT`

Dieser Fehler wird ausgelöst, wenn ein ALPNCallback einen Wert zurückgibt, der sich nicht in der Liste der vom Client angebotenen ALPN-Protokolle befindet.

`ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS`

Dieser Fehler wird beim Erstellen eines TLSServer ausgelöst, wenn die TLS-Optionen sowohl ALPNProtocols als auch ALPNCallback enthalten. Diese Optionen schließen sich gegenseitig aus.

`ERR_TLS_CERT_ALTNAME_FORMAT`

Dieser Fehler wird von checkServerIdentity ausgelöst, wenn eine vom Benutzer bereitgestellte subjectaltname-Eigenschaft gegen Codierungsregeln verstößt. Zertifikatobjekte, die von Node.js selbst erstellt werden, entsprechen immer den Codierungsregeln und verursachen diesen Fehler niemals.

`ERR_TLS_CERT_ALTNAME_INVALID`

Während der Verwendung von TLS stimmte der Hostname/die IP des Peers nicht mit einem der subjectAltNames in seinem Zertifikat überein.

`ERR_TLS_DH_PARAM_SIZE`

Während der Verwendung von TLS ist der für das Diffie-Hellman (DH)-Schlüsselaustauschprotokoll angebotene Parameter zu klein. Standardmäßig muss die Schlüssellänge größer oder gleich 1024 Bit sein, um Schwachstellen zu vermeiden, auch wenn dringend empfohlen wird, für eine höhere Sicherheit 2048 Bit oder mehr zu verwenden.

`ERR_TLS_HANDSHAKE_TIMEOUT`

Ein TLS/SSL-Handshake ist fehlgeschlagen, weil das Zeitlimit überschritten wurde. In diesem Fall muss der Server die Verbindung ebenfalls abbrechen.

`ERR_TLS_INVALID_CONTEXT`

Hinzugefügt in: v13.3.0

Der Kontext muss ein SecureContext sein.

`ERR_TLS_INVALID_PROTOCOL_METHOD`

Die angegebene secureProtocol-Methode ist ungültig. Sie ist entweder unbekannt oder deaktiviert, weil sie unsicher ist.

`ERR_TLS_INVALID_PROTOCOL_VERSION`

Gültige TLS-Protokollversionen sind 'TLSv1', 'TLSv1.1' oder 'TLSv1.2'.

`ERR_TLS_INVALID_STATE`

Hinzugefügt in: v13.10.0, v12.17.0

Der TLS-Socket muss verbunden und sicher hergestellt sein. Stellen Sie sicher, dass das 'secure'-Ereignis ausgelöst wird, bevor Sie fortfahren.

`ERR_TLS_PROTOCOL_VERSION_CONFLICT`

Der Versuch, eine TLS-Protokoll-minVersion oder maxVersion festzulegen, steht im Konflikt mit dem Versuch, das secureProtocol explizit festzulegen. Verwenden Sie entweder den einen oder den anderen Mechanismus.

`ERR_TLS_PSK_SET_IDENTITY_HINT_FAILED`

Das Festlegen des PSK-Identitätshinweises ist fehlgeschlagen. Der Hinweis ist möglicherweise zu lang.

`ERR_TLS_RENEGOTIATION_DISABLED`

Es wurde versucht, TLS auf einer Socket-Instanz neu auszuhandeln, bei der die Neuverhandlung deaktiviert ist.

`ERR_TLS_REQUIRED_SERVER_NAME`

Bei der Verwendung von TLS wurde die Methode server.addContext() aufgerufen, ohne einen Hostnamen im ersten Parameter anzugeben.

`ERR_TLS_SESSION_ATTACK`

Es wird eine übermäßige Anzahl von TLS-Neuverhandlungen festgestellt, was ein potenzieller Vektor für Denial-of-Service-Angriffe ist.

`ERR_TLS_SNI_FROM_SERVER`

Es wurde versucht, eine Server Name Indication von einem TLS-serverseitigen Socket auszugeben, was nur von einem Client aus gültig ist.

`ERR_TRACE_EVENTS_CATEGORY_REQUIRED`

Die Methode trace_events.createTracing() erfordert mindestens eine Trace-Event-Kategorie.

`ERR_TRACE_EVENTS_UNAVAILABLE`

Das Modul node:trace_events konnte nicht geladen werden, da Node.js mit dem Flag --without-v8-platform kompiliert wurde.

`ERR_TRANSFORM_ALREADY_TRANSFORMING`

Ein Transform-Stream wurde beendet, während er noch transformiert wurde.

`ERR_TRANSFORM_WITH_LENGTH_0`

Ein Transform-Stream wurde mit noch im Schreibpuffer befindlichen Daten beendet.

`ERR_TTY_INIT_FAILED`

Die Initialisierung eines TTY ist aufgrund eines Systemfehlers fehlgeschlagen.

`ERR_UNAVAILABLE_DURING_EXIT`

Die Funktion wurde innerhalb eines process.on('exit')-Handlers aufgerufen, der nicht innerhalb von process.on('exit')-Handlern aufgerufen werden sollte.

`ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET`

process.setUncaughtExceptionCaptureCallback() wurde zweimal aufgerufen, ohne zuerst den Rückruf auf null zurückzusetzen.

Dieser Fehler soll verhindern, dass ein Rückruf, der von einem anderen Modul registriert wurde, versehentlich überschrieben wird.

`ERR_UNESCAPED_CHARACTERS`

Eine Zeichenkette, die nicht maskierte Zeichen enthielt, wurde empfangen.

`ERR_UNHANDLED_ERROR`

Ein unbehandelter Fehler ist aufgetreten (z. B. wenn ein 'error'-Ereignis von einem EventEmitter ausgelöst wird, aber kein 'error'-Handler registriert ist).

`ERR_UNKNOWN_BUILTIN_MODULE`

Wird verwendet, um eine bestimmte Art von internem Node.js-Fehler zu identifizieren, der normalerweise nicht durch Benutzercode ausgelöst werden sollte. Instanzen dieses Fehlers deuten auf einen internen Fehler innerhalb der Node.js-Binärdatei selbst hin.

`ERR_UNKNOWN_CREDENTIAL`

Eine Unix-Gruppen- oder Benutzerkennung, die nicht existiert, wurde übergeben.

`ERR_UNKNOWN_ENCODING`

Eine ungültige oder unbekannte Codierungsoption wurde an eine API übergeben.

`ERR_UNKNOWN_FILE_EXTENSION`

[Stable: 1 - Experimental]

Stable: 1 Stabilität: 1 - Experimentell

Es wurde versucht, ein Modul mit einer unbekannten oder nicht unterstützten Dateiendung zu laden.

`ERR_UNKNOWN_MODULE_FORMAT`

[Stable: 1 - Experimental]

Stable: 1 Stabilität: 1 - Experimentell

Es wurde versucht, ein Modul mit einem unbekannten oder nicht unterstützten Format zu laden.

`ERR_UNKNOWN_SIGNAL`

Ein ungültiges oder unbekanntes Prozesssignal wurde an eine API übergeben, die ein gültiges Signal erwartet (z. B. subprocess.kill()).

`ERR_UNSUPPORTED_DIR_IMPORT`

Der import einer Verzeichnis-URL wird nicht unterstützt. Verwenden Sie stattdessen einen Selbstbezug zu einem Paket über seinen Namen und definieren Sie einen benutzerdefinierten Unterpfad im Feld "exports" der Datei package.json.

import './'; // nicht unterstützt
import './index.js'; // unterstützt
import 'package-name'; // unterstützt

`ERR_UNSUPPORTED_ESM_URL_SCHEME`

import mit anderen URL-Schemas als file und data wird nicht unterstützt.

`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`

Hinzugefügt in: v22.6.0

Das Entfernen von Typen wird für Dateien, die von einem node_modules-Verzeichnis abstammen, nicht unterstützt.

`ERR_UNSUPPORTED_RESOLVE_REQUEST`

Es wurde versucht, einen ungültigen Modul-Referrer aufzulösen. Dies kann passieren, wenn beim Importieren oder Aufrufen von import.meta.resolve() entweder:

ein Bare-Specifier, der kein eingebautes Modul ist, von einem Modul, dessen URL-Schema nicht file ist.
eine relative URL von einem Modul, dessen URL-Schema kein spezielles Schema ist.

try {
  // Versuch, das Paket 'bare-specifier' von einem `data:`-URL-Modul zu importieren:
  await import('data:text/javascript,import "bare-specifier"');
} catch (e) {
  console.log(e.code); // ERR_UNSUPPORTED_RESOLVE_REQUEST
}

`ERR_USE_AFTER_CLOSE`

[Stabil: 1 - Experimentell]

Stabil: 1 Stabilität: 1 - Experimentell

Es wurde versucht, etwas zu verwenden, das bereits geschlossen war.

`ERR_VALID_PERFORMANCE_ENTRY_TYPE`

Bei Verwendung der Performance Timing API (perf_hooks) wurden keine gültigen Performance Entry Types gefunden.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`

Ein Dynamic-Import-Callback wurde nicht angegeben.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG`

Ein Dynamic-Import-Callback wurde ohne --experimental-vm-modules aufgerufen.

`ERR_VM_MODULE_ALREADY_LINKED`

Das Modul, das verlinkt werden sollte, ist nicht für die Verlinkung geeignet, da einer der folgenden Gründe vorliegt:

Es wurde bereits verlinkt (linkingStatus ist 'linked')
Es wird gerade verlinkt (linkingStatus ist 'linking')
Die Verlinkung für dieses Modul ist fehlgeschlagen (linkingStatus ist 'errored')

`ERR_VM_MODULE_CACHED_DATA_REJECTED`

Die an einen Modulkonstruktor übergebene Option cachedData ist ungültig.

`ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA`

Zwischengespeicherte Daten können nicht für Module erstellt werden, die bereits ausgewertet wurden.

`ERR_VM_MODULE_DIFFERENT_CONTEXT`

Das Modul, das von der Linker-Funktion zurückgegeben wird, stammt aus einem anderen Kontext als das übergeordnete Modul. Verlinkte Module müssen denselben Kontext haben.

`ERR_VM_MODULE_LINK_FAILURE`

Das Modul konnte aufgrund eines Fehlers nicht verlinkt werden.

`ERR_VM_MODULE_NOT_MODULE`

Der erfüllte Wert eines Linking-Promise ist kein vm.Module-Objekt.

`ERR_VM_MODULE_STATUS`

Der aktuelle Status des Moduls erlaubt diese Operation nicht. Die spezifische Bedeutung des Fehlers hängt von der jeweiligen Funktion ab.

`ERR_WASI_ALREADY_STARTED`

Die WASI-Instanz wurde bereits gestartet.

`ERR_WASI_NOT_STARTED`

Die WASI-Instanz wurde noch nicht gestartet.

`ERR_WEBASSEMBLY_RESPONSE`

Hinzugefügt in: v18.1.0

Die Response, die an WebAssembly.compileStreaming oder WebAssembly.instantiateStreaming übergeben wurde, ist keine gültige WebAssembly-Antwort.

`ERR_WORKER_INIT_FAILED`

`ERR_WORKER_OUT_OF_MEMORY`

Die Worker-Instanz wurde beendet, da sie ihr Speicherlimit erreicht hat.

`ERR_WORKER_PATH`

Der Pfad für das Hauptskript eines Workers ist weder ein absoluter Pfad noch ein relativer Pfad, der mit ./ oder ../ beginnt.

`ERR_WORKER_UNSERIALIZABLE_ERROR`

Alle Versuche, eine nicht abgefangene Ausnahme von einem Worker-Thread zu serialisieren, sind fehlgeschlagen.

`ERR_WORKER_UNSUPPORTED_OPERATION`

Die angeforderte Funktionalität wird in Worker-Threads nicht unterstützt.

`ERR_ZLIB_INITIALIZATION_FAILED`

Die Erstellung eines zlib-Objekts ist aufgrund einer falschen Konfiguration fehlgeschlagen.

`HPE_CHUNK_EXTENSIONS_OVERFLOW`

Hinzugefügt in: v21.6.2, v20.11.1, v18.19.1

Es wurden zu viele Daten für eine Chunk-Erweiterung empfangen. Um sich vor böswilligen oder falsch konfigurierten Clients zu schützen, wird ein Error mit diesem Code ausgegeben, wenn mehr als 16 KiB an Daten empfangen werden.

`HPE_HEADER_OVERFLOW`

[Historie]

Version	Änderungen
v11.4.0, v10.15.0	Die maximale Header-Größe in `http_parser` wurde auf 8 KiB gesetzt.

Es wurden zu viele HTTP-Header-Daten empfangen. Um vor bösartigen oder falsch konfigurierten Clients zu schützen, wird die HTTP-Analyse abgebrochen, wenn mehr als maxHeaderSize an HTTP-Header-Daten empfangen werden, ohne dass ein Anforderungs- oder Antwortobjekt erstellt wird, und es wird ein Error mit diesem Code ausgegeben.

`HPE_UNEXPECTED_CONTENT_LENGTH`

Der Server sendet sowohl einen Content-Length-Header als auch Transfer-Encoding: chunked.

Transfer-Encoding: chunked ermöglicht es dem Server, eine persistente HTTP-Verbindung für dynamisch generierte Inhalte aufrechtzuerhalten. In diesem Fall kann der HTTP-Header Content-Length nicht verwendet werden.

Verwenden Sie Content-Length oder Transfer-Encoding: chunked.

`MODULE_NOT_FOUND`

[Historie]

Version	Änderungen
v12.0.0	Eigenschaft `requireStack` hinzugefügt.

Eine Moduldatei konnte vom CommonJS-Modul-Loader nicht aufgelöst werden, während ein require()-Vorgang versucht wurde oder beim Laden des Programmeinstiegspunkts.

Legacy Node.js Fehlercodes

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet. Diese Fehlercodes sind entweder inkonsistent oder wurden entfernt.

`ERR_CANNOT_TRANSFER_OBJECT`

Hinzugefügt in: v10.5.0

Entfernt in: v12.5.0

Der an postMessage() übergebene Wert enthielt ein Objekt, das für die Übertragung nicht unterstützt wird.

`ERR_CPU_USAGE`

Entfernt in: v15.0.0

Der native Aufruf von process.cpuUsage konnte nicht verarbeitet werden.

`ERR_CRYPTO_HASH_DIGEST_NO_UTF16`

Hinzugefügt in: v9.0.0

Entfernt in: v12.12.0

Die UTF-16-Kodierung wurde mit hash.digest() verwendet. Obwohl die Methode hash.digest() die Übergabe eines encoding-Arguments erlaubt, wodurch die Methode eine Zeichenkette anstelle eines Buffer zurückgibt, wird die UTF-16-Kodierung (z. B. ucs oder utf16le) nicht unterstützt.

`ERR_CRYPTO_SCRYPT_INVALID_PARAMETER`

Entfernt in: v23.0.0

Eine inkompatible Optionskombination wurde an crypto.scrypt() oder crypto.scryptSync() übergeben. Neuere Versionen von Node.js verwenden stattdessen den Fehlercode ERR_INCOMPATIBLE_OPTION_PAIR, der mit anderen APIs konsistent ist.

Dieser Fehlercode wurde in Node.js v15.0.0 durch ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST ersetzt, da er nicht mehr korrekt ist, da es jetzt auch andere Arten von übertragbaren Objekten gibt.

`ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST`

[Verlauf]

Version	Änderungen
v21.0.0	Stattdessen wird eine `DOMException` ausgelöst.
v21.0.0	Entfernt in: v21.0.0
v15.0.0	Hinzugefügt in: v15.0.0

Ein Objekt, das explizit im transferList-Argument aufgeführt werden muss, befindet sich im Objekt, das an einen postMessage()-Aufruf übergeben wird, wird aber nicht in der transferList für diesen Aufruf bereitgestellt. Normalerweise ist dies ein MessagePort.

In Node.js-Versionen vor v15.0.0 war der hier verwendete Fehlercode ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST. Die Menge der übertragbaren Objekttypen wurde jedoch erweitert, um mehr Typen als MessagePort abzudecken.

`ERR_NAPI_CONS_PROTOTYPE_OBJECT`

Hinzugefügt in: v9.0.0

Entfernt in: v10.0.0

Wird von der Node-API verwendet, wenn Constructor.prototype kein Objekt ist.

`ERR_NAPI_TSFN_START_IDLE_LOOP`

Hinzugefügt in: v10.6.0, v8.16.0

Entfernt in: v14.2.0, v12.17.0

Auf dem Hauptthread werden Werte aus der Queue, die mit der Thread-sicheren Funktion assoziiert ist, in einer Idle-Schleife entfernt. Dieser Fehler deutet darauf hin, dass ein Fehler beim Versuch aufgetreten ist, die Schleife zu starten.

`ERR_NAPI_TSFN_STOP_IDLE_LOOP`

Hinzugefügt in: v10.6.0, v8.16.0

Entfernt in: v14.2.0, v12.17.0

Sobald keine Elemente mehr in der Queue übrig sind, muss die Idle-Schleife angehalten werden. Dieser Fehler deutet darauf hin, dass das Anhalten der Idle-Schleife fehlgeschlagen ist.

`ERR_NO_LONGER_SUPPORTED`

Während der Serialisierung wurde ein SharedArrayBuffer festgestellt, dessen Speicher nicht von der JavaScript-Engine oder von Node.js verwaltet wird. Ein solcher SharedArrayBuffer kann nicht serialisiert werden.

Dies kann nur vorkommen, wenn native Add-ons SharedArrayBuffer im "externalisierten" Modus erstellen oder vorhandene SharedArrayBuffer in den externalisierten Modus versetzen.

`ERR_UNKNOWN_STDIN_TYPE`

Hinzugefügt in: v8.0.0

Entfernt in: v11.7.0

Es wurde versucht, einen Node.js-Prozess mit einem unbekannten stdin-Dateityp zu starten. Dieser Fehler ist in der Regel ein Hinweis auf einen Fehler innerhalb von Node.js selbst, obwohl es für Benutzercode möglich ist, ihn auszulösen.

`ERR_UNKNOWN_STREAM_TYPE`

Hinzugefügt in: v8.0.0

Entfernt in: v11.7.0

Es wurde versucht, einen Node.js-Prozess mit einem unbekannten stdout- oder stderr-Dateityp zu starten. Dieser Fehler ist in der Regel ein Hinweis auf einen Fehler innerhalb von Node.js selbst, obwohl es für Benutzercode möglich ist, ihn auszulösen.

`ERR_V8BREAKITERATOR`

Die V8 BreakIterator-API wurde verwendet, aber der vollständige ICU-Datensatz ist nicht installiert.

`ERR_VALUE_OUT_OF_RANGE`

Hinzugefügt in: v9.0.0

Entfernt in: v10.0.0

Wird verwendet, wenn ein gegebener Wert außerhalb des akzeptierten Bereichs liegt.

`ERR_VM_MODULE_LINKING_ERRORED`

Hinzugefügt in: v10.0.0

Entfernt in: v18.1.0, v16.17.0

Die Linker-Funktion hat ein Modul zurückgegeben, für das die Verknüpfung fehlgeschlagen ist.

`ERR_VM_MODULE_NOT_LINKED`

Das Modul muss vor der Instanziierung erfolgreich verknüpft werden.

`ERR_WORKER_UNSUPPORTED_EXTENSION`

Hinzugefügt in: v11.0.0

Entfernt in: v16.9.0

Der für das Hauptskript eines Workers verwendete Pfadname hat eine unbekannte Dateierweiterung.

`ERR_ZLIB_BINDING_CLOSED`

Hinzugefügt in: v9.0.0

Entfernt in: v10.0.0

Wird verwendet, wenn versucht wird, ein zlib-Objekt zu verwenden, nachdem es bereits geschlossen wurde.

OpenSSL-Fehlercodes

Zeitgültigkeitsfehler

`CERT_NOT_YET_VALID`

Das Zertifikat ist noch nicht gültig: Das notBefore-Datum liegt nach der aktuellen Zeit.

`CERT_HAS_EXPIRED`

Das Zertifikat ist abgelaufen: Das notAfter-Datum liegt vor der aktuellen Zeit.

`CRL_NOT_YET_VALID`

Die Certificate Revocation List (CRL) hat ein zukünftiges Ausstellungsdatum.

`CRL_HAS_EXPIRED`

Die Certificate Revocation List (CRL) ist abgelaufen.

`CERT_REVOKED`

Das Zertifikat wurde widerrufen; es befindet sich auf einer Certificate Revocation List (CRL).

`UNABLE_TO_GET_ISSUER_CERT`

Das Ausstellerzertifikat eines nachgeschlagenen Zertifikats konnte nicht gefunden werden. Dies bedeutet normalerweise, dass die Liste der vertrauenswürdigen Zertifikate nicht vollständig ist.

`UNABLE_TO_GET_ISSUER_CERT_LOCALLY`

Der Aussteller des Zertifikats ist unbekannt. Dies ist der Fall, wenn der Aussteller nicht in der Liste der vertrauenswürdigen Zertifikate enthalten ist.

`DEPTH_ZERO_SELF_SIGNED_CERT`

Das übergebene Zertifikat ist selbstsigniert und dasselbe Zertifikat kann nicht in der Liste der vertrauenswürdigen Zertifikate gefunden werden.

`SELF_SIGNED_CERT_IN_CHAIN`

Der Aussteller des Zertifikats ist unbekannt. Dies ist der Fall, wenn der Aussteller nicht in der Liste der vertrauenswürdigen Zertifikate enthalten ist.

`CERT_CHAIN_TOO_LONG`

Die Länge der Zertifikatskette ist größer als die maximale Tiefe.

`UNABLE_TO_GET_CRL`

Die vom Zertifikat referenzierte CRL konnte nicht gefunden werden.

`UNABLE_TO_VERIFY_LEAF_SIGNATURE`

Es konnten keine Signaturen verifiziert werden, da die Kette nur ein Zertifikat enthält und dieses nicht selbstsigniert ist.

`CERT_UNTRUSTED`

Die Root Certificate Authority (CA) ist nicht als vertrauenswürdig für den angegebenen Zweck markiert.

Grundlegende Erweiterungsfehler

`INVALID_CA`

Ein CA-Zertifikat ist ungültig. Entweder ist es keine CA oder seine Erweiterungen stimmen nicht mit dem angegebenen Zweck überein.

`PATH_LENGTH_EXCEEDED`

Der basicConstraints-Parameter pathlength wurde überschritten.

`HOSTNAME_MISMATCH`

Das Zertifikat stimmt nicht mit dem angegebenen Namen überein.

Nutzungs- und Richtlinienfehler

`INVALID_PURPOSE`

Das bereitgestellte Zertifikat kann nicht für den angegebenen Zweck verwendet werden.

`CERT_REJECTED`

Die Root-CA ist so gekennzeichnet, dass sie den angegebenen Zweck ablehnt.

Formatierungsfehler

`CERT_SIGNATURE_FAILURE`

Die Signatur des Zertifikats ist ungültig.

`CRL_SIGNATURE_FAILURE`

Die Signatur der Zertifikatssperrliste (CRL) ist ungültig.

`ERROR_IN_CERT_NOT_BEFORE_FIELD`

Das notBefore-Feld des Zertifikats enthält eine ungültige Zeit.

`ERROR_IN_CERT_NOT_AFTER_FIELD`

Das notAfter-Feld des Zertifikats enthält eine ungültige Zeit.

`ERROR_IN_CRL_LAST_UPDATE_FIELD`

Das lastUpdate-Feld der CRL enthält eine ungültige Zeit.

`ERROR_IN_CRL_NEXT_UPDATE_FIELD`

Das nextUpdate-Feld der CRL enthält eine ungültige Zeit.

`UNABLE_TO_DECRYPT_CERT_SIGNATURE`

Die Zertifikatssignatur konnte nicht entschlüsselt werden. Dies bedeutet, dass der tatsächliche Signaturwert nicht bestimmt werden konnte, anstatt dass er nicht mit dem erwarteten Wert übereinstimmt. Dies ist nur für RSA-Schlüssel von Bedeutung.

`UNABLE_TO_DECRYPT_CRL_SIGNATURE`

Die Signatur der Zertifikatssperrliste (CRL) konnte nicht entschlüsselt werden: Dies bedeutet, dass der tatsächliche Signaturwert nicht bestimmt werden konnte, anstatt dass er nicht mit dem erwarteten Wert übereinstimmt.

`UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY`

Der öffentliche Schlüssel in der SubjectPublicKeyInfo des Zertifikats konnte nicht gelesen werden.

Andere OpenSSL-Fehler

`OUT_OF_MEM`

Beim Versuch, Speicher zu reservieren, ist ein Fehler aufgetreten. Dies sollte niemals vorkommen.

Fehler ​

Fehlerweiterleitung und -abfang ​

Klasse: Error ​

new Error(message[, options]) ​

Error.captureStackTrace(targetObject[, constructorOpt]) ​

Error.stackTraceLimit ​

error.cause ​

error.code ​

error.message ​

error.stack ​

Klasse: AssertionError ​

Klasse: RangeError ​

Klasse: ReferenceError ​

Klasse: SyntaxError ​

Klasse: SystemError ​

error.address ​

error.code ​

error.dest ​

error.errno ​

error.info ​

error.message ​

error.path ​

error.port ​

error.syscall ​

Häufige Systemfehler ​

Klasse: TypeError ​

Ausnahmen vs. Fehler ​

OpenSSL-Fehler ​

error.opensslErrorStack ​

error.function ​

error.library ​

error.reason ​

Node.js Fehlercodes ​

ABORT_ERR ​

ERR_ACCESS_DENIED ​

ERR_AMBIGUOUS_ARGUMENT ​

ERR_ARG_NOT_ITERABLE ​

ERR_ASSERTION ​

ERR_ASYNC_CALLBACK ​

ERR_ASYNC_TYPE ​

ERR_BROTLI_COMPRESSION_FAILED ​

ERR_BROTLI_INVALID_PARAM ​

ERR_BUFFER_CONTEXT_NOT_AVAILABLE ​

ERR_BUFFER_OUT_OF_BOUNDS ​

ERR_BUFFER_TOO_LARGE ​

ERR_CANNOT_WATCH_SIGINT ​

ERR_CHILD_CLOSED_BEFORE_REPLY ​

ERR_CHILD_PROCESS_IPC_REQUIRED ​

ERR_CHILD_PROCESS_STDIO_MAXBUFFER ​

ERR_CLOSED_MESSAGE_PORT ​

ERR_CONSOLE_WRITABLE_STREAM ​

ERR_CONSTRUCT_CALL_INVALID ​

ERR_CONSTRUCT_CALL_REQUIRED ​

ERR_CONTEXT_NOT_INITIALIZED ​

ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED ​

ERR_CRYPTO_ECDH_INVALID_FORMAT ​

ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY ​

ERR_CRYPTO_ENGINE_UNKNOWN ​

ERR_CRYPTO_FIPS_FORCED ​

ERR_CRYPTO_FIPS_UNAVAILABLE ​

ERR_CRYPTO_HASH_FINALIZED ​

ERR_CRYPTO_HASH_UPDATE_FAILED ​

ERR_CRYPTO_INCOMPATIBLE_KEY ​

ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS ​

ERR_CRYPTO_INITIALIZATION_FAILED ​

ERR_CRYPTO_INVALID_AUTH_TAG ​

ERR_CRYPTO_INVALID_COUNTER ​

ERR_CRYPTO_INVALID_CURVE ​

ERR_CRYPTO_INVALID_DIGEST ​

ERR_CRYPTO_INVALID_IV ​

ERR_CRYPTO_INVALID_JWK ​

ERR_CRYPTO_INVALID_KEYLEN ​

ERR_CRYPTO_INVALID_KEYPAIR ​

ERR_CRYPTO_INVALID_KEYTYPE ​

ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE ​

ERR_CRYPTO_INVALID_MESSAGELEN ​

ERR_CRYPTO_INVALID_SCRYPT_PARAMS ​

ERR_CRYPTO_INVALID_STATE ​

ERR_CRYPTO_INVALID_TAG_LENGTH ​

ERR_CRYPTO_JOB_INIT_FAILED ​

Fehler

Fehlerweiterleitung und -abfang

Klasse: `Error`

`new Error(message[, options])`

`Error.captureStackTrace(targetObject[, constructorOpt])`

`Error.stackTraceLimit`

`error.cause`

`error.code`

`error.message`

`error.stack`

Klasse: `AssertionError`

Klasse: `RangeError`

Klasse: `ReferenceError`

Klasse: `SyntaxError`

Klasse: `SystemError`

`error.address`

`error.code`

`error.dest`

`error.errno`

`error.info`

`error.message`

`error.path`

`error.port`

`error.syscall`

Häufige Systemfehler

Klasse: `TypeError`

Ausnahmen vs. Fehler

OpenSSL-Fehler

`error.opensslErrorStack`

`error.function`

`error.library`

`error.reason`

Node.js Fehlercodes

`ABORT_ERR`

`ERR_ACCESS_DENIED`

`ERR_AMBIGUOUS_ARGUMENT`

`ERR_ARG_NOT_ITERABLE`

`ERR_ASSERTION`

`ERR_ASYNC_CALLBACK`

`ERR_ASYNC_TYPE`

`ERR_BROTLI_COMPRESSION_FAILED`

`ERR_BROTLI_INVALID_PARAM`

`ERR_BUFFER_CONTEXT_NOT_AVAILABLE`

`ERR_BUFFER_OUT_OF_BOUNDS`

`ERR_BUFFER_TOO_LARGE`

`ERR_CANNOT_WATCH_SIGINT`

`ERR_CHILD_CLOSED_BEFORE_REPLY`

`ERR_CHILD_PROCESS_IPC_REQUIRED`

`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`

`ERR_CLOSED_MESSAGE_PORT`

`ERR_CONSOLE_WRITABLE_STREAM`

`ERR_CONSTRUCT_CALL_INVALID`

`ERR_CONSTRUCT_CALL_REQUIRED`

`ERR_CONTEXT_NOT_INITIALIZED`

`ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED`

`ERR_CRYPTO_ECDH_INVALID_FORMAT`

`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY`

`ERR_CRYPTO_ENGINE_UNKNOWN`

`ERR_CRYPTO_FIPS_FORCED`

`ERR_CRYPTO_FIPS_UNAVAILABLE`

`ERR_CRYPTO_HASH_FINALIZED`

`ERR_CRYPTO_HASH_UPDATE_FAILED`

`ERR_CRYPTO_INCOMPATIBLE_KEY`

`ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS`

`ERR_CRYPTO_INITIALIZATION_FAILED`

`ERR_CRYPTO_INVALID_AUTH_TAG`

`ERR_CRYPTO_INVALID_COUNTER`

`ERR_CRYPTO_INVALID_CURVE`

`ERR_CRYPTO_INVALID_DIGEST`

`ERR_CRYPTO_INVALID_IV`

`ERR_CRYPTO_INVALID_JWK`

`ERR_CRYPTO_INVALID_KEYLEN`

`ERR_CRYPTO_INVALID_KEYPAIR`

`ERR_CRYPTO_INVALID_KEYTYPE`

`ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE`

`ERR_CRYPTO_INVALID_MESSAGELEN`

`ERR_CRYPTO_INVALID_SCRYPT_PARAMS`

`ERR_CRYPTO_INVALID_STATE`

`ERR_CRYPTO_INVALID_TAG_LENGTH`

`ERR_CRYPTO_JOB_INIT_FAILED`