Erreurs

Les applications s'exécutant dans Node.js rencontreront généralement quatre catégories d'erreurs :

Les erreurs JavaScript standard telles que <EvalError>, <SyntaxError>, <RangeError>, <ReferenceError>, <TypeError> et <URIError>.
Les erreurs système déclenchées par des contraintes du système d'exploitation sous-jacent, telles qu'une tentative d'ouverture d'un fichier qui n'existe pas ou une tentative d'envoi de données sur un socket fermé.
Les erreurs spécifiées par l'utilisateur déclenchées par le code de l'application.
Les AssertionErrors sont une classe spéciale d'erreurs qui peuvent être déclenchées lorsque Node.js détecte une violation de logique exceptionnelle qui ne devrait jamais se produire. Elles sont généralement levées par le module node:assert.

Toutes les erreurs JavaScript et système levées par Node.js héritent de, ou sont des instances de, la classe JavaScript standard <Error> et sont garanties de fournir au moins les propriétés disponibles sur cette classe.

Propagation et interception des erreurs

Node.js prend en charge plusieurs mécanismes pour propager et gérer les erreurs qui se produisent pendant l'exécution d'une application. La manière dont ces erreurs sont signalées et gérées dépend entièrement du type d'Error et du style de l'API appelée.

Toutes les erreurs JavaScript sont traitées comme des exceptions qui génèrent et lèvent immédiatement une erreur à l'aide du mécanisme throw standard de JavaScript. Elles sont gérées à l'aide de la construction try…catch fournie par le langage JavaScript.

// Lève une ReferenceError car z n'est pas défini.
try {
  const m = 1 ;
  const n = m + z ;
} catch (err) {
  // Gérer l'erreur ici.
}

Toute utilisation du mécanisme throw de JavaScript lèvera une exception qui doit être gérée, sinon le processus Node.js se terminera immédiatement.

À quelques exceptions près, les API synchrones (toute méthode bloquante qui ne renvoie pas de <Promise> et n'accepte pas non plus une fonction callback, comme fs.readFileSync), utiliseront throw pour signaler les erreurs.

Les erreurs qui se produisent dans les API asynchrones peuvent être signalées de plusieurs manières :

Certaines méthodes asynchrones renvoient une <Promise>, vous devez toujours tenir compte du fait qu'elle peut être rejetée. Consultez l'indicateur --unhandled-rejections pour savoir comment le processus réagira à un rejet de promesse non géré.
La plupart des méthodes asynchrones qui acceptent une fonction callback accepteront un objet Error transmis comme premier argument à cette fonction. Si ce premier argument n'est pas null et est une instance de Error, une erreur s'est produite et doit être gérée.
Lorsqu'une méthode asynchrone est appelée sur un objet qui est un EventEmitter, les erreurs peuvent être routées vers l'événement 'error' de cet objet.
Une poignée de méthodes généralement asynchrones dans l'API Node.js peuvent encore utiliser le mécanisme throw pour lever des exceptions qui doivent être gérées à l'aide de try…catch. Il n'existe pas de liste exhaustive de ces méthodes ; veuillez consulter la documentation de chaque méthode pour déterminer le mécanisme de gestion des erreurs approprié requis.

L'utilisation du mécanisme d'événement 'error' est plus courante pour les API basées sur les flux et basées sur les émetteurs d'événements, qui représentent elles-mêmes une série d'opérations asynchrones dans le temps (par opposition à une seule opération qui peut réussir ou échouer).

Pour tous les objets EventEmitter, si un gestionnaire d'événements 'error' n'est pas fourni, l'erreur sera levée, ce qui entraînera le signalement d'une exception non interceptée par le processus Node.js et son plantage, sauf si : un gestionnaire a été enregistré pour l'événement 'uncaughtException', ou le module node:domain obsolète est utilisé.

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

setImmediate(() => {
  // Cela fera planter le processus car aucun événement 'error'
  // Le gestionnaire a été ajouté.
  ee.emit('error', new Error('Cela va planter'));
});

Les erreurs générées de cette manière ne peuvent pas être interceptées à l'aide de try…catch car elles sont levées après que le code appelant a déjà quitté.

Les développeurs doivent se référer à la documentation de chaque méthode pour déterminer exactement comment les erreurs levées par ces méthodes sont propagées.

Classe : `Error`

Un objet JavaScript <Error> générique qui n'indique aucune circonstance particulière expliquant la raison pour laquelle l'erreur s'est produite. Les objets Error capturent une "trace de pile" détaillant le point du code où l'Error a été instanciée, et peuvent fournir une description textuelle de l'erreur.

Toutes les erreurs générées par Node.js, y compris toutes les erreurs système et JavaScript, seront soit des instances de la classe Error, soit en hériteront.

`new Error(message[, options])`

message <string>
options <Object>
- cause <any> L'erreur qui a causé l'erreur nouvellement créée.

Crée un nouvel objet Error et définit la propriété error.message sur le message texte fourni. Si un objet est passé comme message, le message texte est généré en appelant String(message). Si l'option cause est fournie, elle est affectée à la propriété error.cause. La propriété error.stack représentera le point du code où new Error() a été appelé. Les traces de pile dépendent de l'API de trace de pile de V8. Les traces de pile s'étendent uniquement jusqu'à (a) le début de l'exécution synchrone du code, ou (b) le nombre de frames donné par la propriété Error.stackTraceLimit, la plus petite des deux valeurs étant retenue.

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

targetObject <Object>
constructorOpt <Function>

Crée une propriété .stack sur targetObject, qui, lorsqu'elle est accédée, renvoie une chaîne représentant l'emplacement dans le code où Error.captureStackTrace() a été appelé.

const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Semblable à `new Error().stack`

La première ligne de la trace sera préfixée par ${myObject.name}: ${myObject.message}.

L'argument optionnel constructorOpt accepte une fonction. Si elle est fournie, toutes les frames au-dessus de constructorOpt, y compris constructorOpt, seront omises de la trace de pile générée.

L'argument constructorOpt est utile pour masquer les détails d'implémentation de la génération d'erreurs à l'utilisateur. Par exemple :

function a() {
  b();
}

function b() {
  c();
}

function c() {
  // Crée une erreur sans trace de pile pour éviter de calculer la trace de pile deux fois.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;

  // Capture la trace de pile au-dessus de la fonction b
  Error.captureStackTrace(error, b); // Ni la fonction c, ni b n'est incluse dans la trace de pile
  throw error;
}

a();

`Error.stackTraceLimit`

<number>

La propriété Error.stackTraceLimit spécifie le nombre de frames de pile collectées par une trace de pile (qu'elle soit générée par new Error().stack ou Error.captureStackTrace(obj)).

La valeur par défaut est 10 mais peut être définie à n'importe quel nombre JavaScript valide. Les modifications affecteront toute trace de pile capturée après que la valeur a été modifiée.

Si la valeur définie n'est pas un nombre, ou si elle est définie à un nombre négatif, les traces de pile ne captureront aucun frame.

`error.cause`

Ajouté dans: v16.9.0

<any>

Si elle est présente, la propriété error.cause est la cause sous-jacente de l'Error. Elle est utilisée lors de la capture d'une erreur et de la levée d'une nouvelle avec un message ou un code différent afin d'avoir toujours accès à l'erreur d'origine.

La propriété error.cause est généralement définie en appelant new Error(message, { cause }). Elle n'est pas définie par le constructeur si l'option cause n'est pas fournie.

Cette propriété permet d'enchaîner les erreurs. Lors de la sérialisation d'objets Error, util.inspect() sérialise récursivement error.cause s'il est défini.

const cause = new Error('Le serveur HTTP distant a répondu avec un statut 500');
const symptom = new Error('Le message n'a pas pu être envoyé', { cause });

console.log(symptom);
// Affiche :
//   Error: Le message n'a pas pu être envoyé
//       at REPL2:1:17
//       at Script.runInThisContext (node:vm:130:12)
//       ... 7 lignes correspondant à la trace de pile de la cause ...
//       at [_line] [as _line] (node:internal/readline/interface:886:18) {
//     [cause]: Error: Le serveur HTTP distant a répondu avec un statut 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>

La propriété error.code est une étiquette de chaîne qui identifie le type d'erreur. error.code est la manière la plus stable d'identifier une erreur. Elle ne changera qu'entre les versions majeures de Node.js. En revanche, les chaînes error.message peuvent changer entre toutes les versions de Node.js. Voir Codes d'erreur Node.js pour plus de détails sur les codes spécifiques.

`error.message`

<string>

La propriété error.message est la description de chaîne de l'erreur telle que définie en appelant new Error(message). Le message passé au constructeur apparaîtra également dans la première ligne de la trace de pile de l'Error, cependant changer cette propriété après que l'objet Error a été créé peut ne pas changer la première ligne de la trace de pile (par exemple, lorsque error.stack est lu avant que cette propriété ne soit modifiée).

const err = new Error('Le message');
console.error(err.message);
// Affiche : Le message

`error.stack`

<string>

La propriété error.stack est une chaîne décrivant le point du code où l'Error a été instanciée.

bash

Error: Les choses continuent d'arriver !
   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)

La première ligne est formatée comme \<nom de la classe d'erreur\>: \<message d'erreur\>, et est suivie d'une série de cadres de pile (chaque ligne commençant par "at "). Chaque cadre décrit un site d'appel dans le code qui a conduit à la génération de l'erreur. V8 tente d'afficher un nom pour chaque fonction (par nom de variable, nom de fonction ou nom de méthode d'objet), mais il ne sera parfois pas en mesure de trouver un nom approprié. Si V8 ne peut pas déterminer un nom pour la fonction, seules les informations de localisation seront affichées pour ce cadre. Sinon, le nom de la fonction déterminé sera affiché avec les informations de localisation ajoutées entre parenthèses.

Les cadres ne sont générés que pour les fonctions JavaScript. Si, par exemple, l'exécution passe de manière synchrone par une fonction d'addon C++ appelée cheetahify qui appelle elle-même une fonction JavaScript, le cadre représentant l'appel cheetahify ne sera pas présent dans les traces de pile :

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

function makeFaster() {
  // `cheetahify()` appelle *synchrone* speedy.
  cheetahify(function speedy() {
    throw new Error('oh non !');
  });
}

makeFaster();
// lancera :
//   /home/gbusey/file.js:6
//       throw new Error('oh non !');
//           ^
//   Error: oh non !
//       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

Les informations de localisation seront l'une des suivantes :

native, si le cadre représente un appel interne à V8 (comme dans [].forEach).
plain-filename.js:line:column, si le cadre représente un appel interne à Node.js.
/absolute/path/to/file.js:line:column, si le cadre représente un appel dans un programme utilisateur (utilisant le système de module CommonJS), ou ses dépendances.
\<transport-protocol\>:///url/to/module/file.mjs:line:column, si le cadre représente un appel dans un programme utilisateur (utilisant le système de module ES), ou ses dépendances.

La chaîne représentant la trace de pile est générée paresseusement lorsque la propriété error.stack est consultée.

Le nombre de cadres capturés par la trace de pile est limité par le plus petit de Error.stackTraceLimit ou du nombre de cadres disponibles sur le tick actuel de la boucle d'événement.

Classe : `AssertionError`

Étend : <errors.Error>

Indique l'échec d'une assertion. Pour plus de détails, voir Class: assert.AssertionError.

Classe : `RangeError`

Étend : <errors.Error>

Indique qu'un argument fourni ne se trouvait pas dans l'ensemble ou la plage de valeurs acceptables pour une fonction ; qu'il s'agisse d'une plage numérique ou en dehors de l'ensemble d'options pour un paramètre de fonction donné.

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

Node.js générera et lèvera des instances RangeError immédiatement comme forme de validation des arguments.

Classe : `ReferenceError`

Étend : <errors.Error>

Indique qu'une tentative est faite pour accéder à une variable qui n'est pas définie. De telles erreurs indiquent généralement des fautes de frappe dans le code, ou un programme autrement cassé.

Bien que le code client puisse générer et propager ces erreurs, en pratique, seul V8 le fera.

doesNotExist;
// Lève ReferenceError, doesNotExist n'est pas une variable dans ce programme.

À moins qu'une application ne génère et n'exécute dynamiquement du code, les instances ReferenceError indiquent un bug dans le code ou ses dépendances.

Classe : `SyntaxError`

Étend : <errors.Error>

Indique qu'un programme n'est pas un JavaScript valide. Ces erreurs ne peuvent être générées et propagées qu'à la suite de l'évaluation du code. L'évaluation du code peut se produire à la suite de eval, Function, require ou vm. Ces erreurs sont presque toujours révélatrices d'un programme cassé.

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

Les instances SyntaxError sont irrécupérables dans le contexte qui les a créées ; elles ne peuvent être interceptées que par d'autres contextes.

Classe : `SystemError`

Étend : <errors.Error>

Node.js génère des erreurs système lorsque des exceptions se produisent dans son environnement d'exécution. Celles-ci se produisent généralement lorsqu'une application viole une contrainte du système d'exploitation. Par exemple, une erreur système se produira si une application tente de lire un fichier qui n'existe pas.

address <string> Si présent, l'adresse à laquelle une connexion réseau a échoué
code <string> Le code d'erreur sous forme de chaîne
dest <string> Si présent, le chemin de fichier de destination lors du signalement d'une erreur de système de fichiers
errno <number> Le numéro d'erreur fourni par le système
info <Object> Si présent, des détails supplémentaires sur la condition d'erreur
message <string> Une description de l'erreur lisible par l'homme fournie par le système
path <string> Si présent, le chemin de fichier lors du signalement d'une erreur de système de fichiers
port <number> Si présent, le port de connexion réseau qui n'est pas disponible
syscall <string> Le nom de l'appel système qui a déclenché l'erreur

`error.address`

<string>

Si présent, error.address est une chaîne décrivant l'adresse à laquelle une connexion réseau a échoué.

`error.code`

<string>

La propriété error.code est une chaîne représentant le code d'erreur.

`error.dest`

<string>

Si présent, error.dest est le chemin du fichier de destination lors du signalement d'une erreur de système de fichiers.

`error.errno`

<number>

La propriété error.errno est un nombre négatif qui correspond au code d'erreur défini dans Gestion des erreurs libuv.

Sous Windows, le numéro d'erreur fourni par le système sera normalisé par libuv.

Pour obtenir la représentation sous forme de chaîne du code d'erreur, utilisez util.getSystemErrorName(error.errno).

`error.info`

<Object>

Si présent, error.info est un objet contenant des détails sur la condition d'erreur.

`error.message`

<string>

error.message est une description de l'erreur fournie par le système, lisible par l'homme.

`error.path`

<string>

Si présent, error.path est une chaîne contenant un nom de chemin invalide pertinent.

`error.port`

<number>

Si présent, error.port est le port de connexion réseau qui n'est pas disponible.

`error.syscall`

<string>

La propriété error.syscall est une chaîne décrivant l'appel système qui a échoué.

Erreurs système courantes

Voici une liste d'erreurs système couramment rencontrées lors de l'écriture d'un programme Node.js. Pour une liste complète, consultez la page de manuel errno(3).

EACCES (Permission denied) : Une tentative a été faite pour accéder à un fichier d'une manière interdite par ses permissions d'accès aux fichiers.
EADDRINUSE (Address already in use) : Une tentative de liaison d'un serveur (net, http, ou https) à une adresse locale a échoué car un autre serveur sur le système local occupait déjà cette adresse.
ECONNREFUSED (Connection refused) : Aucune connexion n'a pu être établie car la machine cible l'a activement refusée. Cela résulte généralement d'une tentative de connexion à un service inactif sur l'hôte distant.
ECONNRESET (Connection reset by peer) : Une connexion a été fermée de force par un pair. Cela résulte normalement d'une perte de connexion sur le socket distant en raison d'un délai d'attente ou d'un redémarrage. Couramment rencontrée via les modules http et net.
EEXIST (File exists) : Un fichier existant était la cible d'une opération qui exigeait que la cible n'existe pas.
EISDIR (Is a directory) : Une opération attendait un fichier, mais le chemin d'accès donné était un répertoire.
EMFILE (Too many open files in system) : Le nombre maximal de descripteurs de fichiers autorisés sur le système a été atteint, et les demandes d'un autre descripteur ne peuvent être satisfaites tant qu'au moins un n'a pas été fermé. Cela se produit lors de l'ouverture de nombreux fichiers simultanément en parallèle, en particulier sur les systèmes (notamment macOS) où la limite de descripteurs de fichiers pour les processus est faible. Pour remédier à une limite basse, exécutez ulimit -n 2048 dans le même shell qui exécutera le processus Node.js.
ENOENT (No such file or directory) : Couramment soulevée par les opérations fs pour indiquer qu'un composant du chemin d'accès spécifié n'existe pas. Aucune entité (fichier ou répertoire) n'a pu être trouvée par le chemin donné.
ENOTDIR (Not a directory) : Un composant du chemin d'accès donné existait, mais n'était pas un répertoire comme prévu. Couramment soulevée par fs.readdir.
ENOTEMPTY (Directory not empty) : Un répertoire avec des entrées était la cible d'une opération qui exige un répertoire vide, généralement fs.unlink.
ENOTFOUND (DNS lookup failed) : Indique un échec DNS de EAI_NODATA ou EAI_NONAME. Ce n'est pas une erreur POSIX standard.
EPERM (Operation not permitted) : Une tentative a été faite pour effectuer une opération qui nécessite des privilèges élevés.
EPIPE (Broken pipe) : Une écriture sur un tube, un socket ou un FIFO pour lequel il n'y a pas de processus pour lire les données. Couramment rencontrée aux couches net et http, indiquant que le côté distant du flux vers lequel on écrit a été fermé.
ETIMEDOUT (Operation timed out) : Une requête de connexion ou d'envoi a échoué car la partie connectée n'a pas répondu correctement après un certain temps. Généralement rencontrée par http ou net. Souvent un signe qu'un socket.end() n'a pas été correctement appelé.

Classe : `TypeError`

S'étend de <errors.Error>

Indique qu'un argument fourni n'est pas d'un type autorisé. Par exemple, passer une fonction à un paramètre qui attend une chaîne de caractères serait une TypeError.

require('node:url').parse(() => { });
// Lève TypeError, car elle attendait une chaîne de caractères.

Node.js générera et lèvera des instances TypeError immédiatement comme forme de validation d'argument.

Exceptions vs. erreurs

Une exception JavaScript est une valeur qui est levée à la suite d'une opération non valide ou comme cible d'une instruction throw. Bien qu'il ne soit pas obligatoire que ces valeurs soient des instances de Error ou des classes héritant de Error, toutes les exceptions levées par Node.js ou l'environnement d'exécution JavaScript seront des instances de Error.

Certaines exceptions sont irrécupérables au niveau JavaScript. Ces exceptions feront toujours planter le processus Node.js. Les exemples incluent les vérifications assert() ou les appels abort() dans la couche C++.

Erreurs OpenSSL

Les erreurs provenant de crypto ou tls sont de la classe Error, et en plus des propriétés standard .code et .message, peuvent avoir des propriétés OpenSSL supplémentaires.

`error.opensslErrorStack`

Un tableau d'erreurs qui peut donner un contexte sur l'origine d'une erreur dans la bibliothèque OpenSSL.

`error.function`

La fonction OpenSSL dans laquelle l'erreur trouve son origine.

`error.library`

La bibliothèque OpenSSL dans laquelle l'erreur trouve son origine.

`error.reason`

Une chaîne de caractères lisible décrivant la raison de l'erreur.

Codes d'erreur Node.js

`ABORT_ERR`

Ajouté dans : v15.0.0

Utilisé lorsqu'une opération a été abandonnée (généralement à l'aide d'un AbortController).

Les API qui n'utilisent pas de AbortSignal ne lèvent généralement pas d'erreur avec ce code.

Ce code n'utilise pas la convention régulière ERR_* utilisée par les erreurs Node.js afin d'être compatible avec AbortError de la plate-forme web.

`ERR_ACCESS_DENIED`

Un type d'erreur spécial qui est déclenché chaque fois que Node.js tente d'accéder à une ressource restreinte par le Modèle de permission.

`ERR_AMBIGUOUS_ARGUMENT`

Un argument de fonction est utilisé d'une manière qui suggère que la signature de la fonction peut être mal comprise. Ceci est levé par le module node:assert lorsque le paramètre message dans assert.throws(block, message) correspond au message d'erreur levé par block car cette utilisation suggère que l'utilisateur pense que message est le message attendu plutôt que le message que AssertionError affichera si block ne lève pas d'erreur.

`ERR_ARG_NOT_ITERABLE`

Un argument itérable (c'est-à-dire une valeur qui fonctionne avec les boucles for...of) était requis, mais n'a pas été fourni à une API Node.js.

`ERR_ASSERTION`

Un type d'erreur spécial qui peut être déclenché chaque fois que Node.js détecte une violation de logique exceptionnelle qui ne devrait jamais se produire. Ceux-ci sont généralement levés par le module node:assert.

`ERR_ASYNC_CALLBACK`

Une tentative a été faite pour enregistrer quelque chose qui n'est pas une fonction en tant que callback AsyncHooks.

`ERR_ASYNC_TYPE`

Le type d'une ressource asynchrone était invalide. Les utilisateurs peuvent également définir leurs propres types s'ils utilisent l'API d'intégration publique.

`ERR_BROTLI_COMPRESSION_FAILED`

Les données transmises à un flux Brotli n'ont pas été compressées avec succès.

`ERR_BROTLI_INVALID_PARAM`

Une clé de paramètre non valide a été transmise lors de la construction d'un flux Brotli.

`ERR_BUFFER_CONTEXT_NOT_AVAILABLE`

Une tentative a été faite pour créer une instance Buffer Node.js à partir d'un code d'addon ou d'intégrateur, alors que dans un contexte de moteur JS qui n'est pas associé à une instance Node.js. Les données transmises à la méthode Buffer auront été libérées au moment où la méthode renvoie.

Lors de la rencontre de cette erreur, une alternative possible à la création d'une instance Buffer est de créer un Uint8Array normal, qui ne diffère que par le prototype de l'objet résultant. Les Uint8Array sont généralement acceptés dans toutes les API du cœur de Node.js où les Buffer le sont ; ils sont disponibles dans tous les contextes.

`ERR_BUFFER_OUT_OF_BOUNDS`

Une opération en dehors des limites d'un Buffer a été tentée.

`ERR_BUFFER_TOO_LARGE`

Une tentative a été faite pour créer un Buffer plus grand que la taille maximale autorisée.

`ERR_CANNOT_WATCH_SIGINT`

Node.js n'a pas pu surveiller le signal SIGINT.

`ERR_CHILD_CLOSED_BEFORE_REPLY`

Un processus enfant a été fermé avant que le parent ne reçoive une réponse.

`ERR_CHILD_PROCESS_IPC_REQUIRED`

Utilisé lorsqu'un processus enfant est créé sans spécifier de canal IPC.

`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`

Utilisé lorsque le processus principal essaie de lire des données à partir de STDERR/STDOUT du processus enfant, et que la longueur des données est supérieure à l'option maxBuffer.

`ERR_CLOSED_MESSAGE_PORT`

[Historique]

Version	Modifications
v16.2.0, v14.17.1	Le message d'erreur a été réintroduit.
v11.12.0	Le message d'erreur a été supprimé.
v10.5.0	Ajouté dans : v10.5.0

Il y a eu une tentative d'utilisation d'une instance MessagePort dans un état fermé, généralement après que .close() ait été appelé.

`ERR_CONSOLE_WRITABLE_STREAM`

Console a été instancié sans flux stdout, ou Console a un flux stdout ou stderr non accessible en écriture.

`ERR_CONSTRUCT_CALL_INVALID`

Ajouté dans: v12.5.0

Un constructeur de classe a été appelé et n'est pas appelable.

`ERR_CONSTRUCT_CALL_REQUIRED`

Un constructeur pour une classe a été appelé sans new.

`ERR_CONTEXT_NOT_INITIALIZED`

Le contexte vm transmis à l'API n'est pas encore initialisé. Cela peut se produire lorsqu'une erreur se produit (et est interceptée) lors de la création du contexte, par exemple, lorsque l'allocation échoue ou que la taille maximale de la pile d'appels est atteinte lors de la création du contexte.

`ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED`

Un moteur OpenSSL a été demandé (par exemple, via les options TLS clientCertEngine ou privateKeyEngine) qui n'est pas pris en charge par la version d'OpenSSL utilisée, probablement en raison de l'indicateur de compilation OPENSSL_NO_ENGINE.

`ERR_CRYPTO_ECDH_INVALID_FORMAT`

Une valeur invalide pour l'argument format a été passée à la méthode getPublicKey() de la classe crypto.ECDH().

`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY`

Une valeur invalide pour l'argument key a été passée à la méthode computeSecret() de la classe crypto.ECDH(). Cela signifie que la clé publique se trouve en dehors de la courbe elliptique.

`ERR_CRYPTO_ENGINE_UNKNOWN`

Un identifiant de moteur cryptographique invalide a été passé à require('node:crypto').setEngine().

`ERR_CRYPTO_FIPS_FORCED`

L'argument de ligne de commande --force-fips a été utilisé mais il y a eu une tentative d'activer ou de désactiver le mode FIPS dans le module node:crypto.

`ERR_CRYPTO_FIPS_UNAVAILABLE`

Une tentative d'activer ou de désactiver le mode FIPS a été faite, mais le mode FIPS n'était pas disponible.

`ERR_CRYPTO_HASH_FINALIZED`

hash.digest() a été appelé plusieurs fois. La méthode hash.digest() ne doit être appelée qu'une seule fois par instance d'un objet Hash.

`ERR_CRYPTO_HASH_UPDATE_FAILED`

hash.update() a échoué pour une raison quelconque. Cela devrait rarement, voire jamais, arriver.

`ERR_CRYPTO_INCOMPATIBLE_KEY`

Les clés cryptographiques données sont incompatibles avec l'opération tentée.

`ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS`

L'encodage de clé publique ou privée sélectionné est incompatible avec d'autres options.

`ERR_CRYPTO_INITIALIZATION_FAILED`

Ajouté dans : v15.0.0

L'initialisation du sous-système crypto a échoué.

`ERR_CRYPTO_INVALID_AUTH_TAG`

Ajouté dans : v15.0.0

Une balise d'authentification invalide a été fournie.

`ERR_CRYPTO_INVALID_COUNTER`

Ajouté dans : v15.0.0

Un compteur invalide a été fourni pour un chiffrement en mode compteur.

`ERR_CRYPTO_INVALID_CURVE`

Ajouté dans : v15.0.0

Une courbe elliptique invalide a été fournie.

Le type de l'objet de clé crypto donné n'est pas valide pour l'opération tentée.

`ERR_CRYPTO_INVALID_MESSAGELEN`

Ajouté dans : v15.0.0

Une longueur de message invalide a été fournie.

`ERR_CRYPTO_INVALID_SCRYPT_PARAMS`

Node.js a été compilé sans le support scrypt. Ce n'est pas possible avec les binaires de la version officielle, mais cela peut arriver avec des versions personnalisées, y compris les versions de distribution.

`ERR_CRYPTO_SIGN_KEY_REQUIRED`

Une key de signature n'a pas été fournie à la méthode sign.sign().

`ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH`

crypto.timingSafeEqual() a été appelé avec des arguments Buffer, TypedArray ou DataView de longueurs différentes.

`ERR_CRYPTO_UNKNOWN_CIPHER`

Un chiffrement inconnu a été spécifié.

`ERR_CRYPTO_UNKNOWN_DH_GROUP`

Un nom de groupe Diffie-Hellman inconnu a été donné. Voir crypto.getDiffieHellman() pour une liste des noms de groupes valides.

`ERR_CRYPTO_UNSUPPORTED_OPERATION`

Ajouté dans : v15.0.0, v14.18.0

Une tentative d'invocation d'une opération crypto non prise en charge a été faite.

`ERR_DEBUGGER_ERROR`

Ajouté dans : v16.4.0, v14.17.4

Une erreur s'est produite avec le débogueur.

`ERR_DEBUGGER_STARTUP_ERROR`

Ajouté dans : v16.4.0, v14.17.4

Le débogueur a expiré en attendant que l'hôte/port requis soit libre.

`ERR_DIR_CLOSED`

Le fs.Dir a été préalablement fermé.

`ERR_DIR_CONCURRENT_OPERATION`

Ajouté dans : v14.3.0

Un appel synchrone de lecture ou de fermeture a été tenté sur un fs.Dir qui a des opérations asynchrones en cours.

`ERR_DLOPEN_DISABLED`

Ajouté dans : v16.10.0, v14.19.0

Le chargement des addons natifs a été désactivé à l'aide de --no-addons.

`ERR_DLOPEN_FAILED`

Ajouté dans : v15.0.0

Un appel à process.dlopen() a échoué.

`ERR_DNS_SET_SERVERS_FAILED`

c-ares n'a pas réussi à définir le serveur DNS.

`ERR_DOMAIN_CALLBACK_NOT_AVAILABLE`

Le module node:domain n'était pas utilisable car il n'a pas pu établir les hooks de gestion des erreurs requis, car process.setUncaughtExceptionCaptureCallback() avait été appelé à un moment antérieur.

`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`

process.setUncaughtExceptionCaptureCallback() n'a pas pu être appelé car le module node:domain a été chargé à un moment antérieur.

La trace de pile est étendue pour inclure le moment où le module node:domain a été chargé.

`ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION`

v8.startupSnapshot.setDeserializeMainFunction() n'a pas pu être appelé car il avait déjà été appelé auparavant.

`ERR_ENCODING_INVALID_ENCODED_DATA`

Les données fournies à l'API TextDecoder() étaient invalides selon l'encodage fourni.

`ERR_ENCODING_NOT_SUPPORTED`

L'encodage fourni à l'API TextDecoder() n'était pas l'un des Encodages pris en charge par WHATWG.

`ERR_EVAL_ESM_CANNOT_PRINT`

--print ne peut pas être utilisé avec une entrée ESM.

`ERR_EVENT_RECURSION`

Lancée lorsqu'une tentative est faite pour distribuer récursivement un événement sur EventTarget.

`ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE`

Le contexte d'exécution JS n'est pas associé à un environnement Node.js. Cela peut se produire lorsque Node.js est utilisé comme une bibliothèque intégrée et que certains hooks pour le moteur JS ne sont pas correctement configurés.

`ERR_FALSY_VALUE_REJECTION`

Une Promise qui a été transformée en rappel via util.callbackify() a été rejetée avec une valeur falsy.

`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`

Ajouté dans : v14.0.0

Une tentative a été faite de copier vers un type de fichier inconnu avec fs.cp().

`ERR_FS_EISDIR`

Le chemin est un répertoire.

`ERR_FS_FILE_TOO_LARGE`

Une tentative a été faite pour lire un fichier dont la taille est supérieure à la taille maximale autorisée pour un Buffer.

`ERR_HTTP2_ALTSVC_INVALID_ORIGIN`

Les trames HTTP/2 ALTSVC nécessitent une origine valide.

`ERR_HTTP2_ALTSVC_LENGTH`

Les trames HTTP/2 ALTSVC sont limitées à un maximum de 16 382 octets de payload.

`ERR_HTTP2_CONNECT_AUTHORITY`

Pour les requêtes HTTP/2 utilisant la méthode CONNECT, le pseudo-en-tête :authority est obligatoire.

`ERR_HTTP2_CONNECT_PATH`

Pour les requêtes HTTP/2 utilisant la méthode CONNECT, le pseudo-en-tête :path est interdit.

`ERR_HTTP2_CONNECT_SCHEME`

Pour les requêtes HTTP/2 utilisant la méthode CONNECT, le pseudo-en-tête :scheme est interdit.

`ERR_HTTP2_ERROR`

Une erreur HTTP/2 non spécifique s’est produite.

`ERR_HTTP2_GOAWAY_SESSION`

De nouveaux flux HTTP/2 ne peuvent pas être ouverts après que Http2Session a reçu une trame GOAWAY du pair connecté.

`ERR_HTTP2_HEADERS_AFTER_RESPOND`

Des en-têtes supplémentaires ont été spécifiés après qu’une réponse HTTP/2 a été initiée.

`ERR_HTTP2_HEADERS_SENT`

Une tentative a été faite pour envoyer plusieurs en-têtes de réponse.

`ERR_HTTP2_HEADER_SINGLE_VALUE`

Plusieurs valeurs ont été fournies pour un champ d’en-tête HTTP/2 qui devait avoir une seule valeur.

`ERR_HTTP2_INFO_STATUS_NOT_ALLOWED`

Les codes d’état HTTP informatifs (1xx) ne peuvent pas être définis comme code d’état de réponse sur les réponses HTTP/2.

`ERR_HTTP2_INVALID_CONNECTION_HEADERS`

Les en-têtes spécifiques à la connexion HTTP/1 ne peuvent pas être utilisés dans les requêtes et les réponses HTTP/2.

`ERR_HTTP2_INVALID_HEADER_VALUE`

Une valeur d’en-tête HTTP/2 non valide a été spécifiée.

`ERR_HTTP2_INVALID_INFO_STATUS`

Un code d'état informationnel HTTP non valide a été spécifié. Les codes d'état informationnels doivent être des entiers compris entre 100 et 199 (inclus).

`ERR_HTTP2_INVALID_ORIGIN`

Les trames ORIGIN HTTP/2 nécessitent une origine valide.

`ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH`

Les instances Buffer et Uint8Array transmises à l'API http2.getUnpackedSettings() doivent avoir une longueur multiple de six.

`ERR_HTTP2_INVALID_PSEUDOHEADER`

Seuls les pseudo-en-têtes HTTP/2 valides (:status, :path, :authority, :scheme et :method) peuvent être utilisés.

`ERR_HTTP2_INVALID_SESSION`

Une action a été effectuée sur un objet Http2Session qui avait déjà été détruit.

`ERR_HTTP2_INVALID_SETTING_VALUE`

Une valeur non valide a été spécifiée pour un paramètre HTTP/2.

`ERR_HTTP2_INVALID_STREAM`

Une opération a été effectuée sur un flux qui avait déjà été détruit.

`ERR_HTTP2_MAX_PENDING_SETTINGS_ACK`

Chaque fois qu'une trame SETTINGS HTTP/2 est envoyée à un homologue connecté, ce dernier est tenu d'envoyer un accusé de réception indiquant qu'il a reçu et appliqué les nouveaux SETTINGS. Par défaut, un nombre maximal de trames SETTINGS non accusées peuvent être envoyées à un moment donné. Ce code d'erreur est utilisé lorsque cette limite est atteinte.

`ERR_HTTP2_NESTED_PUSH`

Une tentative a été faite pour initier un nouveau flux push depuis un flux push. Les flux push imbriqués ne sont pas autorisés.

`ERR_HTTP2_NO_MEM`

Mémoire insuffisante lors de l'utilisation de l'API http2session.setLocalWindowSize(windowSize).

`ERR_HTTP2_NO_SOCKET_MANIPULATION`

Une tentative a été faite pour manipuler directement (lire, écrire, mettre en pause, reprendre, etc.) un socket attaché à une Http2Session.

`ERR_HTTP2_ORIGIN_LENGTH`

Les trames ORIGIN HTTP/2 sont limitées à une longueur de 16382 octets.

`ERR_HTTP2_OUT_OF_STREAMS`

Le nombre de flux créés sur une seule session HTTP/2 a atteint la limite maximale.

`ERR_HTTP2_PAYLOAD_FORBIDDEN`

Une charge utile de message a été spécifiée pour un code de réponse HTTP pour lequel une charge utile est interdite.

`ERR_HTTP2_PING_CANCEL`

Un ping HTTP/2 a été annulé.

`ERR_HTTP2_PING_LENGTH`

Les charges utiles du ping HTTP/2 doivent avoir une longueur exacte de 8 octets.

`ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED`

Un pseudo-en-tête HTTP/2 a été utilisé de manière inappropriée. Les pseudo-en-têtes sont des noms de clés d'en-tête qui commencent par le préfixe :.

`ERR_HTTP2_PUSH_DISABLED`

Une tentative a été faite pour créer un flux push, qui avait été désactivé par le client.

`ERR_HTTP2_SEND_FILE`

Une tentative a été faite pour utiliser l'API Http2Stream.prototype.responseWithFile() afin d'envoyer un répertoire.

`ERR_HTTP2_SEND_FILE_NOSEEK`

Une tentative a été faite pour utiliser l'API Http2Stream.prototype.responseWithFile() afin d'envoyer autre chose qu'un fichier régulier, mais des options offset ou length ont été fournies.

`ERR_HTTP2_SESSION_ERROR`

La Http2Session s'est fermée avec un code d'erreur non nul.

`ERR_HTTP2_SETTINGS_CANCEL`

Les paramètres de Http2Session ont été annulés.

`ERR_HTTP2_SOCKET_BOUND`

Une tentative a été faite pour connecter un objet Http2Session à un net.Socket ou tls.TLSSocket qui avait déjà été lié à un autre objet Http2Session.

`ERR_HTTP2_SOCKET_UNBOUND`

Une tentative a été faite pour utiliser la propriété socket d'une Http2Session qui a déjà été fermée.

`ERR_HTTP2_STATUS_101`

L'utilisation du code de statut Informationnel 101 est interdite dans HTTP/2.

`ERR_HTTP2_STATUS_INVALID`

Un code de statut HTTP invalide a été spécifié. Les codes de statut doivent être un entier compris entre 100 et 599 (inclus).

`ERR_HTTP2_STREAM_CANCEL`

Un Http2Stream a été détruit avant que des données ne soient transmises à l'homologue connecté.

`ERR_HTTP2_STREAM_ERROR`

Un code d'erreur non nul a été spécifié dans une trame RST_STREAM.

`ERR_HTTP2_STREAM_SELF_DEPENDENCY`

Lors de la définition de la priorité d'un flux HTTP/2, le flux peut être marqué comme une dépendance pour un flux parent. Ce code d'erreur est utilisé lorsqu'une tentative est faite pour marquer un flux comme dépendant de lui-même.

`ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS`

Le nombre de paramètres personnalisés pris en charge (10) a été dépassé.

`ERR_HTTP2_TOO_MANY_INVALID_FRAMES`

Ajouté dans : v15.14.0

La limite des trames de protocole HTTP/2 invalides acceptables envoyées par le pair, telle que spécifiée par l'option maxSessionInvalidFrames, a été dépassée.

`ERR_HTTP2_TRAILERS_ALREADY_SENT`

Les en-têtes de fin ont déjà été envoyés sur le Http2Stream.

`ERR_HTTP2_TRAILERS_NOT_READY`

La méthode http2stream.sendTrailers() ne peut être appelée qu'après l'émission de l'événement 'wantTrailers' sur un objet Http2Stream. L'événement 'wantTrailers' ne sera émis que si l'option waitForTrailers est définie pour le Http2Stream.

`ERR_HTTP2_UNSUPPORTED_PROTOCOL`

http2.connect() a reçu une URL qui utilise un protocole autre que http: ou https:.

`ERR_HTTP_BODY_NOT_ALLOWED`

Une erreur est levée lors de l'écriture dans une réponse HTTP qui n'autorise pas de contenu.

`ERR_HTTP_CONTENT_LENGTH_MISMATCH`

La taille du corps de la réponse ne correspond pas à la valeur de l'en-tête content-length spécifié.

`ERR_HTTP_HEADERS_SENT`

Une tentative a été faite pour ajouter plus d'en-têtes après que les en-têtes aient déjà été envoyés.

`ERR_HTTP_INVALID_HEADER_VALUE`

Une valeur d'en-tête HTTP invalide a été spécifiée.

`ERR_HTTP_INVALID_STATUS_CODE`

Le code d'état était en dehors de la plage de codes d'état standard (100-999).

`ERR_HTTP_REQUEST_TIMEOUT`

Le client n'a pas envoyé la requête complète dans le délai imparti.

`ERR_HTTP_SOCKET_ASSIGNED`

Le ServerResponse donné était déjà assigné à un socket.

`ERR_HTTP_SOCKET_ENCODING`

La modification du codage du socket n'est pas autorisée par la RFC 7230 Section 3.

`ERR_HTTP_TRAILER_INVALID`

L'en-tête Trailer a été défini alors que le codage de transfert ne le prend pas en charge.

`ERR_ILLEGAL_CONSTRUCTOR`

Une tentative a été faite pour construire un objet en utilisant un constructeur non public.

`ERR_IMPORT_ATTRIBUTE_MISSING`

Ajouté dans : v21.1.0

Un attribut d'importation est manquant, empêchant l'importation du module spécifié.

`ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE`

Ajouté dans : v21.1.0

Un attribut type d’importation a été fourni, mais le module spécifié est d’un type différent.

`ERR_IMPORT_ATTRIBUTE_UNSUPPORTED`

Ajouté dans : v21.0.0, v20.10.0, v18.19.0

Un attribut d’importation n’est pas pris en charge par cette version de Node.js.

`ERR_INCOMPATIBLE_OPTION_PAIR`

Une paire d’options est incompatible l’une avec l’autre et ne peut pas être utilisée en même temps.

`ERR_INPUT_TYPE_NOT_ALLOWED`

[Stable: 1 - Experimental]

Stable: 1 Stability: 1 - Expérimental

L’indicateur --input-type a été utilisé pour tenter d’exécuter un fichier. Cet indicateur ne peut être utilisé qu’avec une entrée via --eval, --print ou STDIN.

`ERR_INSPECTOR_ALREADY_ACTIVATED`

Lors de l’utilisation du module node:inspector, une tentative a été faite pour activer l’inspecteur alors qu’il avait déjà commencé à écouter sur un port. Utilisez inspector.close() avant de l’activer à une adresse différente.

`ERR_INSPECTOR_ALREADY_CONNECTED`

Lors de l’utilisation du module node:inspector, une tentative de connexion a été effectuée alors que l’inspecteur était déjà connecté.

`ERR_INSPECTOR_CLOSED`

Lors de l’utilisation du module node:inspector, une tentative a été faite pour utiliser l’inspecteur après que la session ait déjà été fermée.

`ERR_INSPECTOR_COMMAND`

Une erreur s’est produite lors de l’exécution d’une commande via le module node:inspector.

`ERR_INSPECTOR_NOT_ACTIVE`

L’inspector n’est pas actif lorsque inspector.waitForDebugger() est appelé.

`ERR_INSPECTOR_NOT_AVAILABLE`

Le module node:inspector n’est pas disponible pour être utilisé.

`ERR_INSPECTOR_NOT_CONNECTED`

Lors de l’utilisation du module node:inspector, une tentative a été faite pour utiliser l’inspecteur avant qu’il ne soit connecté.

`ERR_INSPECTOR_NOT_WORKER`

Une API a été appelée sur le thread principal qui ne peut être utilisée qu’à partir du thread worker.

`ERR_INTERNAL_ASSERTION`

Il y avait un bug dans Node.js ou une utilisation incorrecte des éléments internes de Node.js. Pour corriger l’erreur, ouvrez un ticket sur https://github.com/nodejs/node/issues.

`ERR_INVALID_ADDRESS`

L'adresse fournie n'est pas comprise par l'API Node.js.

`ERR_INVALID_ADDRESS_FAMILY`

La famille d'adresses fournie n'est pas comprise par l'API Node.js.

`ERR_INVALID_ARG_TYPE`

Un argument de type incorrect a été passé à une API Node.js.

`ERR_INVALID_ARG_VALUE`

Une valeur non valide ou non prise en charge a été passée pour un argument donné.

`ERR_INVALID_ASYNC_ID`

Un asyncId ou triggerAsyncId non valide a été passé en utilisant AsyncHooks. Un ID inférieur à -1 ne devrait jamais se produire.

`ERR_INVALID_BUFFER_SIZE`

Un swap a été effectué sur un Buffer mais sa taille n'était pas compatible avec l'opération.

`ERR_INVALID_CHAR`

Des caractères non valides ont été détectés dans les en-têtes.

`ERR_INVALID_CURSOR_POS`

Un curseur sur un flux donné ne peut pas être déplacé vers une ligne spécifiée sans une colonne spécifiée.

`ERR_INVALID_FD`

Un descripteur de fichier ('fd') n'était pas valide (par exemple, il s'agissait d'une valeur négative).

`ERR_INVALID_FD_TYPE`

Un type de descripteur de fichier ('fd') n'était pas valide.

`ERR_INVALID_FILE_URL_HOST`

Une API Node.js qui consomme des URL file: (telles que certaines fonctions dans le module fs) a rencontré une URL de fichier avec un hôte incompatible. Cette situation ne peut se produire que sur les systèmes de type Unix où seul localhost ou un hôte vide est pris en charge.

`ERR_INVALID_FILE_URL_PATH`

Une API Node.js qui consomme des URL file: (telles que certaines fonctions du module fs) a rencontré une URL de fichier avec un chemin incompatible. La sémantique exacte pour déterminer si un chemin peut être utilisé dépend de la plate-forme.

`ERR_INVALID_HANDLE_TYPE`

Une tentative a été faite pour envoyer un "handle" non pris en charge sur un canal de communication IPC à un processus enfant. Voir subprocess.send() et process.send() pour plus d'informations.

`ERR_INVALID_HTTP_TOKEN`

Un jeton HTTP non valide a été fourni.

`ERR_INVALID_IP_ADDRESS`

Une adresse IP n'est pas valide.

`ERR_INVALID_MIME_SYNTAX`

La syntaxe d'un MIME n'est pas valide.

`ERR_INVALID_MODULE`

Ajouté dans : v15.0.0, v14.18.0

Une tentative a été faite pour charger un module qui n'existe pas ou qui n'est pas valide d'une autre manière.

`ERR_INVALID_MODULE_SPECIFIER`

La chaîne de module importée est une URL, un nom de paquetage ou un spécificateur de sous-chemin de paquetage invalide.

`ERR_INVALID_OBJECT_DEFINE_PROPERTY`

Une erreur s'est produite lors de la définition d'un attribut invalide sur la propriété d'un objet.

`ERR_INVALID_PACKAGE_CONFIG`

Un fichier package.json invalide n'a pas pu être analysé.

`ERR_INVALID_PACKAGE_TARGET`

Le champ "exports" de package.json contient une valeur de mappage de cible invalide pour la résolution de module tentée.

`ERR_INVALID_PROTOCOL`

Un options.protocol invalide a été passé à http.request().

`ERR_INVALID_REPL_EVAL_CONFIG`

Les options breakEvalOnSigint et eval ont toutes deux été définies dans la configuration REPL, ce qui n'est pas pris en charge.

`ERR_INVALID_REPL_INPUT`

L'entrée ne peut pas être utilisée dans le REPL. Les conditions dans lesquelles cette erreur est utilisée sont décrites dans la documentation REPL.

`ERR_INVALID_RETURN_PROPERTY`

Levée si une option de fonction ne fournit pas une valeur valide pour l'une de ses propriétés d'objet retournées lors de l'exécution.

`ERR_INVALID_RETURN_PROPERTY_VALUE`

Levée si une option de fonction ne fournit pas un type de valeur attendu pour l'une de ses propriétés d'objet retournées lors de l'exécution.

`ERR_INVALID_RETURN_VALUE`

Levée si une option de fonction ne renvoie pas un type de valeur attendu lors de l'exécution, par exemple lorsqu'une fonction est censée renvoyer une promesse.

`ERR_INVALID_STATE`

Ajouté dans : v15.0.0

Indique qu'une opération ne peut pas être effectuée en raison d'un état invalide. Par exemple, un objet peut déjà avoir été détruit ou peut être en train d'effectuer une autre opération.

`ERR_INVALID_SYNC_FORK_INPUT`

Un Buffer, TypedArray, DataView ou string a été fourni comme entrée stdio à un fork asynchrone. Voir la documentation du module child_process pour plus d'informations.

`ERR_INVALID_THIS`

Une fonction API Node.js a été appelée avec une valeur this incompatible.

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

const buf = Buffer.alloc(1);
urlSearchParams.has.call(buf, 'foo');
// Lève un TypeError avec le code 'ERR_INVALID_THIS'

`ERR_INVALID_TUPLE`

Un élément dans l'itérable fourni au WHATWG constructeur URLSearchParams ne représentait pas un tuple [nom, valeur] - c'est-à-dire, si un élément n'est pas itérable, ou ne consiste pas en exactement deux éléments.

`ERR_INVALID_TYPESCRIPT_SYNTAX`

Ajouté dans : v23.0.0

La syntaxe TypeScript fournie n'est pas valide ou n'est pas prise en charge. Cela peut se produire lors de l'utilisation d'une syntaxe TypeScript qui nécessite une transformation avec suppression de type.

`ERR_INVALID_URI`

Un URI invalide a été passé.

`ERR_INVALID_URL`

Une URL invalide a été passée au WHATWG constructeur URL ou à l'ancien url.parse() pour être analysée. L'objet d'erreur lancé a généralement une propriété supplémentaire 'input' qui contient l'URL qui n'a pas pu être analysée.

`ERR_INVALID_URL_SCHEME`

Une tentative a été faite d'utiliser une URL d'un schéma (protocole) incompatible à des fins spécifiques. Il est uniquement utilisé dans la prise en charge de l'API WHATWG URL dans le module fs (qui n'accepte que les URL avec le schéma 'file'), mais peut également être utilisé dans d'autres API Node.js à l'avenir.

`ERR_IPC_CHANNEL_CLOSED`

Une tentative a été faite d'utiliser un canal de communication IPC qui était déjà fermé.

`ERR_IPC_DISCONNECTED`

Une tentative a été faite de déconnecter un canal de communication IPC qui était déjà déconnecté. Voir la documentation du module child_process pour plus d'informations.

`ERR_IPC_ONE_PIPE`

Une tentative a été faite de créer un processus Node.js enfant en utilisant plus d'un canal de communication IPC. Voir la documentation du module child_process pour plus d'informations.

`ERR_IPC_SYNC_FORK`

Une tentative d'ouverture d'un canal de communication IPC avec un processus Node.js forké de manière synchrone a été effectuée. Consultez la documentation du module child_process pour plus d'informations.

`ERR_IP_BLOCKED`

L'adresse IP est bloquée par net.BlockList.

`ERR_LOADER_CHAIN_INCOMPLETE`

Ajouté dans : v18.6.0, v16.17.0

Un hook de chargement ESM est retourné sans appeler next() et sans signaler explicitement un court-circuit.

`ERR_LOAD_SQLITE_EXTENSION`

Ajouté dans : v23.5.0

Une erreur s'est produite lors du chargement d'une extension SQLite.

`ERR_MEMORY_ALLOCATION_FAILED`

Une tentative d'allocation de mémoire (généralement dans la couche C++) a été effectuée, mais elle a échoué.

`ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE`

Ajouté dans : v14.5.0, v12.19.0

Un message envoyé à un MessagePort n'a pas pu être désérialisé dans le Context vm cible. Tous les objets Node.js ne peuvent pas être instanciés avec succès dans n'importe quel contexte pour le moment, et tenter de les transférer à l'aide de postMessage() peut échouer du côté de la réception dans ce cas.

`ERR_METHOD_NOT_IMPLEMENTED`

Une méthode est requise mais non implémentée.

`ERR_MISSING_ARGS`

Un argument requis d'une API Node.js n'a pas été transmis. Ceci n'est utilisé que pour une stricte conformité à la spécification de l'API (qui dans certains cas peut accepter func(undefined) mais pas func()). Dans la plupart des API Node.js natives, func(undefined) et func() sont traités de manière identique, et le code d'erreur ERR_INVALID_ARG_TYPE peut être utilisé à la place.

`ERR_MISSING_OPTION`

Pour les API qui acceptent les objets d'options, certaines options peuvent être obligatoires. Ce code est levé si une option requise est manquante.

`ERR_MISSING_PASSPHRASE`

Une tentative de lecture d'une clé chiffrée a été effectuée sans spécifier de phrase secrète.

`ERR_MISSING_PLATFORM_FOR_WORKER`

La plateforme V8 utilisée par cette instance de Node.js ne prend pas en charge la création de Workers. Ceci est causé par un manque de support d'intégration pour les Workers. En particulier, cette erreur ne se produira pas avec les builds standard de Node.js.

`ERR_MODULE_NOT_FOUND`

Un fichier de module n'a pas pu être résolu par le chargeur de modules ECMAScript lors d'une tentative d'opération import ou lors du chargement du point d'entrée du programme.

`ERR_MULTIPLE_CALLBACK`

Un rappel a été appelé plus d'une fois.

Un rappel est presque toujours destiné à n'être appelé qu'une seule fois, car la requête peut être satisfaite ou rejetée, mais pas les deux en même temps. Ce dernier serait possible en appelant un rappel plus d'une fois.

`ERR_NAPI_CONS_FUNCTION`

Lors de l'utilisation de Node-API, un constructeur transmis n'était pas une fonction.

`ERR_NAPI_INVALID_DATAVIEW_ARGS`

Lors de l'appel de napi_create_dataview(), un offset donné était en dehors des limites de la vue de données ou offset + length était supérieur à la longueur d'un buffer donné.

`ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT`

Lors de l'appel de napi_create_typedarray(), l'offset fourni n'était pas un multiple de la taille de l'élément.

`ERR_NAPI_INVALID_TYPEDARRAY_LENGTH`

Lors de l'appel de napi_create_typedarray(), (length * size_of_element) + byte_offset était supérieur à la longueur du buffer donné.

`ERR_NAPI_TSFN_CALL_JS`

Une erreur s'est produite lors de l'appel de la partie JavaScript de la fonction thread-safe.

`ERR_NAPI_TSFN_GET_UNDEFINED`

Une erreur s'est produite lors de la tentative de récupération de la valeur JavaScript undefined.

`ERR_NON_CONTEXT_AWARE_DISABLED`

Un addon natif non conscient du contexte a été chargé dans un processus qui les interdit.

`ERR_NOT_BUILDING_SNAPSHOT`

Une tentative a été faite pour utiliser des opérations qui ne peuvent être utilisées que lors de la construction d'un instantané de démarrage V8, même si Node.js n'en construit pas un.

`ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION`

Ajouté dans : v21.7.0, v20.12.0

L'opération ne peut pas être effectuée lorsqu'elle ne se trouve pas dans une application mono-exécutable.

`ERR_NOT_SUPPORTED_IN_SNAPSHOT`

Une tentative a été faite pour effectuer des opérations qui ne sont pas prises en charge lors de la construction d'un instantané de démarrage.

`ERR_NO_CRYPTO`

Une tentative a été faite pour utiliser les fonctionnalités de cryptographie alors que Node.js n'a pas été compilé avec la prise en charge de la cryptographie OpenSSL.

`ERR_NO_ICU`

Une tentative d'utilisation de fonctionnalités nécessitant ICU a été effectuée, mais Node.js n'a pas été compilé avec le support ICU.

`ERR_NO_TYPESCRIPT`

Ajouté dans : v23.0.0

Une tentative d'utilisation de fonctionnalités nécessitant la prise en charge native de TypeScript a été effectuée, mais Node.js n'a pas été compilé avec la prise en charge de TypeScript.

`ERR_OPERATION_FAILED`

Ajouté dans : v15.0.0

Une opération a échoué. Ceci est généralement utilisé pour signaler l'échec général d'une opération asynchrone.

`ERR_OUT_OF_RANGE`

Une valeur donnée est hors de la plage acceptée.

`ERR_PACKAGE_IMPORT_NOT_DEFINED`

Le champ "imports" du package.json ne définit pas le mapping de spécificateur de package interne donné.

`ERR_PACKAGE_PATH_NOT_EXPORTED`

Le champ "exports" du package.json n'exporte pas le sous-chemin demandé. Étant donné que les exports sont encapsulés, les modules internes privés qui ne sont pas exportés ne peuvent pas être importés via la résolution de package, sauf si vous utilisez une URL absolue.

`ERR_PARSE_ARGS_INVALID_OPTION_VALUE`

Ajouté dans : v18.3.0, v16.17.0

Lorsque strict est défini sur true, est lancé par util.parseArgs() si une valeur <boolean> est fournie pour une option de type <string>, ou si une valeur <string> est fournie pour une option de type <boolean>.

`ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL`

Ajouté dans : v18.3.0, v16.17.0

Lancé par util.parseArgs(), lorsqu'un argument positionnel est fourni et que allowPositionals est défini sur false.

`ERR_PARSE_ARGS_UNKNOWN_OPTION`

Ajouté dans : v18.3.0, v16.17.0

Lorsque strict est défini sur true, est lancé par util.parseArgs() si un argument n'est pas configuré dans options.

`ERR_PERFORMANCE_INVALID_TIMESTAMP`

Une valeur d'horodatage invalide a été fournie pour une marque ou une mesure de performance.

`ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS`

Stable: 1 Stability: 1 - Expérimental

Lors d'une tentative d'utiliser require() sur un Module ES, une bordure CommonJS vers ESM ou ESM vers CommonJS participe à un cycle immédiat. Cela n'est pas autorisé car les Modules ES ne peuvent pas être évalués pendant qu'ils sont déjà en cours d'évaluation.

Pour éviter le cycle, l'appel require() impliqué dans un cycle ne doit pas se produire au niveau supérieur d'un Module ES (via createRequire()) ou d'un module CommonJS, et doit être effectué de manière paresseuse dans une fonction interne.

`ERR_REQUIRE_ESM`

[History]

Version	Changes
v23.0.0	require() prend désormais en charge le chargement des modules ES synchrones par défaut.

[Stable: 0 - Deprecated]

Stable: 0 Stability: 0 - Déprécié

Une tentative a été faite pour require() un Module ES.

Cette erreur est dépréciée car require() prend désormais en charge le chargement des modules ES synchrones. Lorsque require() rencontre un module ES qui contient un await de niveau supérieur, il lèvera ERR_REQUIRE_ASYNC_MODULE à la place.

`ERR_SCRIPT_EXECUTION_INTERRUPTED`

L'exécution du script a été interrompue par SIGINT (Par exemple, + a été pressé.)

`ERR_SCRIPT_EXECUTION_TIMEOUT`

L'exécution du script a expiré, probablement en raison de bugs dans le script en cours d'exécution.

`ERR_SERVER_ALREADY_LISTEN`

La méthode server.listen() a été appelée alors qu'un net.Server était déjà à l'écoute. Cela s'applique à toutes les instances de net.Server, y compris les instances Server HTTP, HTTPS et HTTP/2.

`ERR_SERVER_NOT_RUNNING`

La méthode server.close() a été appelée alors qu'un net.Server n'était pas en cours d'exécution. Ceci s'applique à toutes les instances de net.Server, y compris les instances Server HTTP, HTTPS et HTTP/2.

`ERR_SINGLE_EXECUTABLE_APPLICATION_ASSET_NOT_FOUND`

Ajouté dans : v21.7.0, v20.12.0

Une clé a été transmise aux API d'application exécutable unique pour identifier un actif, mais aucune correspondance n'a été trouvée.

`ERR_SOCKET_ALREADY_BOUND`

Une tentative a été faite pour lier un socket qui a déjà été lié.

`ERR_SOCKET_BAD_BUFFER_SIZE`

Une taille invalide (négative) a été passée pour les options recvBufferSize ou sendBufferSize dans dgram.createSocket().

`ERR_SOCKET_BAD_PORT`

Une fonction API attendant un port >= 0 et < 65536 a reçu une valeur invalide.

`ERR_SOCKET_BAD_TYPE`

Une fonction API attendant un type de socket (udp4 ou udp6) a reçu une valeur invalide.

`ERR_SOCKET_BUFFER_SIZE`

Lors de l'utilisation de dgram.createSocket(), la taille du Buffer de réception ou d'envoi n'a pas pu être déterminée.

`ERR_SOCKET_CLOSED`

Une tentative a été faite pour opérer sur un socket déjà fermé.

`ERR_SOCKET_CLOSED_BEFORE_CONNECTION`

Lors de l'appel de net.Socket.write() sur un socket en cours de connexion et que le socket a été fermé avant que la connexion ne soit établie.

`ERR_SOCKET_CONNECTION_TIMEOUT`

Le socket n'a pas pu se connecter à une adresse renvoyée par le DNS dans le délai d'attente autorisé lors de l'utilisation de l'algorithme de sélection automatique de la famille.

`ERR_SOCKET_DGRAM_IS_CONNECTED`

Un appel dgram.connect() a été effectué sur un socket déjà connecté.

`ERR_SOCKET_DGRAM_NOT_CONNECTED`

Un appel dgram.disconnect() ou dgram.remoteAddress() a été effectué sur un socket déconnecté.

`ERR_SOCKET_DGRAM_NOT_RUNNING`

Un appel a été effectué et le sous-système UDP n'était pas en cours d'exécution.

`ERR_SOURCE_MAP_CORRUPT`

La source map n'a pas pu être analysée car elle n'existe pas ou est corrompue.

`ERR_SOURCE_MAP_MISSING_SOURCE`

Un fichier importé à partir d'une source map n'a pas été trouvé.

`ERR_SQLITE_ERROR`

Ajouté dans : v22.5.0

Une erreur a été renvoyée par SQLite.

`ERR_SRI_PARSE`

Une chaîne a été fournie pour une vérification d'intégrité des sous-ressources, mais n'a pas pu être analysée. Vérifiez le format des attributs d'intégrité en consultant la spécification d'intégrité des sous-ressources.

`ERR_STREAM_ALREADY_FINISHED`

Une méthode de flux a été appelée qui ne peut pas se terminer car le flux est terminé.

`ERR_STREAM_CANNOT_PIPE`

Une tentative a été faite pour appeler stream.pipe() sur un flux Writable.

`ERR_STREAM_DESTROYED`

Une méthode de flux a été appelée qui ne peut pas se terminer car le flux a été détruit à l'aide de stream.destroy().

`ERR_STREAM_NULL_VALUES`

Une tentative a été faite pour appeler stream.write() avec un chunk null.

`ERR_STREAM_PREMATURE_CLOSE`

Une erreur renvoyée par stream.finished() et stream.pipeline(), lorsqu'un flux ou un pipeline se termine de manière non gracieuse sans erreur explicite.

`ERR_STREAM_PUSH_AFTER_EOF`

Une tentative a été faite pour appeler stream.push() après qu'un null (EOF) ait été poussé vers le flux.

`ERR_STREAM_UNABLE_TO_PIPE`

Une tentative a été faite pour rediriger vers un flux fermé ou détruit dans un pipeline.

`ERR_STREAM_UNSHIFT_AFTER_END_EVENT`

Une tentative a été faite pour appeler stream.unshift() après que l'événement 'end' ait été émis.

`ERR_STREAM_WRAP`

Empêche un abandon si un décodeur de chaîne a été défini sur le Socket ou si le décodeur est en objectMode.

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

instance.setEncoding('utf8');

`ERR_STREAM_WRITE_AFTER_END`

Une tentative a été faite d'appeler stream.write() après que stream.end() a été appelé.

`ERR_STRING_TOO_LONG`

Une tentative a été faite de créer une chaîne de caractères plus longue que la longueur maximale autorisée.

`ERR_SYNTHETIC`

Un objet d'erreur artificiel utilisé pour capturer la pile d'appels pour les rapports de diagnostic.

`ERR_SYSTEM_ERROR`

Une erreur système non spécifiée ou non spécifique s'est produite dans le processus Node.js. L'objet d'erreur aura une propriété d'objet err.info avec des détails supplémentaires.

`ERR_TAP_LEXER_ERROR`

Une erreur représentant un état d'analyse lexicale défaillant.

`ERR_TAP_PARSER_ERROR`

Une erreur représentant un état d'analyse syntaxique défaillant. Des informations supplémentaires sur le jeton à l'origine de l'erreur sont disponibles via la propriété cause.

`ERR_TAP_VALIDATION_ERROR`

Cette erreur représente une validation TAP échouée.

`ERR_TEST_FAILURE`

Cette erreur représente un test échoué. Des informations supplémentaires sur l'échec sont disponibles via la propriété cause. La propriété failureType spécifie ce que le test faisait lorsque l'échec s'est produit.

`ERR_TLS_ALPN_CALLBACK_INVALID_RESULT`

Cette erreur est levée lorsqu'un ALPNCallback renvoie une valeur qui ne figure pas dans la liste des protocoles ALPN proposés par le client.

`ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS`

Cette erreur est levée lors de la création d'un TLSServer si les options TLS incluent à la fois ALPNProtocols et ALPNCallback. Ces options s'excluent mutuellement.

`ERR_TLS_CERT_ALTNAME_FORMAT`

Cette erreur est levée par checkServerIdentity si une propriété subjectaltname fournie par l'utilisateur viole les règles d'encodage. Les objets de certificat produits par Node.js lui-même sont toujours conformes aux règles d'encodage et ne provoqueront jamais cette erreur.

`ERR_TLS_CERT_ALTNAME_INVALID`

Lors de l'utilisation de TLS, le nom d'hôte/l'adresse IP du pair ne correspond à aucun des subjectAltNames dans son certificat.

`ERR_TLS_DH_PARAM_SIZE`

Lors de l'utilisation de TLS, le paramètre proposé pour le protocole d'accord de clé Diffie-Hellman (DH) est trop petit. Par défaut, la longueur de la clé doit être supérieure ou égale à 1024 bits pour éviter les vulnérabilités, même s'il est fortement recommandé d'utiliser 2048 bits ou plus pour une sécurité renforcée.

`ERR_TLS_HANDSHAKE_TIMEOUT`

Un handshake TLS/SSL a expiré. Dans ce cas, le serveur doit également abandonner la connexion.

`ERR_TLS_INVALID_CONTEXT`

Ajouté dans: v13.3.0

Le contexte doit être un SecureContext.

`ERR_TLS_INVALID_PROTOCOL_METHOD`

La méthode secureProtocol spécifiée n'est pas valide. Elle est soit inconnue, soit désactivée car elle n'est pas sécurisée.

`ERR_TLS_INVALID_PROTOCOL_VERSION`

Les versions de protocole TLS valides sont 'TLSv1', 'TLSv1.1' ou 'TLSv1.2'.

`ERR_TLS_INVALID_STATE`

Ajouté dans : v13.10.0, v12.17.0

Le socket TLS doit être connecté et sécurisé. Assurez-vous que l'événement 'secure' est émis avant de continuer.

`ERR_TLS_PROTOCOL_VERSION_CONFLICT`

Tenter de définir un protocole TLS minVersion ou maxVersion entre en conflit avec une tentative de définition explicite de secureProtocol. Utilisez l'un ou l'autre mécanisme.

`ERR_TLS_PSK_SET_IDENTITY_HINT_FAILED`

Échec de la définition de l'indice d'identité PSK. L'indice est peut-être trop long.

`ERR_TLS_RENEGOTIATION_DISABLED`

Une tentative de renégociation TLS a été effectuée sur une instance de socket avec renégociation désactivée.

`ERR_TLS_REQUIRED_SERVER_NAME`

Lors de l'utilisation de TLS, la méthode server.addContext() a été appelée sans fournir de nom d'hôte dans le premier paramètre.

`ERR_TLS_SESSION_ATTACK`

Une quantité excessive de renégociations TLS est détectée, ce qui constitue un vecteur potentiel d'attaques par déni de service.

`ERR_TLS_SNI_FROM_SERVER`

Une tentative a été faite d'émettre une indication de nom de serveur à partir d'un socket TLS côté serveur, ce qui n'est valable que depuis un client.

`ERR_TRACE_EVENTS_CATEGORY_REQUIRED`

La méthode trace_events.createTracing() nécessite au moins une catégorie d'événement de trace.

`ERR_TRACE_EVENTS_UNAVAILABLE`

Le module node:trace_events n'a pas pu être chargé car Node.js a été compilé avec l'indicateur --without-v8-platform.

`ERR_TRANSFORM_ALREADY_TRANSFORMING`

Un flux Transform s'est terminé alors qu'il était encore en transformation.

`ERR_TRANSFORM_WITH_LENGTH_0`

Un flux Transform s'est terminé avec des données encore dans le tampon d'écriture.

`ERR_TTY_INIT_FAILED`

L'initialisation d'un TTY a échoué en raison d'une erreur système.

`ERR_UNAVAILABLE_DURING_EXIT`

La fonction a été appelée dans un gestionnaire process.on('exit') qui ne devrait pas être appelée dans un gestionnaire process.on('exit').

`ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET`

process.setUncaughtExceptionCaptureCallback() a été appelé deux fois, sans d'abord réinitialiser le rappel à null.

Cette erreur est conçue pour éviter d'écraser accidentellement un rappel enregistré à partir d'un autre module.

`ERR_UNESCAPED_CHARACTERS`

Une chaîne contenant des caractères non échappés a été reçue.

`ERR_UNHANDLED_ERROR`

Une erreur non gérée s'est produite (par exemple, lorsqu'un événement 'error' est émis par un EventEmitter mais qu'un gestionnaire 'error' n'est pas enregistré).

`ERR_UNKNOWN_BUILTIN_MODULE`

Utilisé pour identifier un type spécifique d'erreur interne de Node.js qui ne devrait généralement pas être déclenchée par le code utilisateur. Les instances de cette erreur pointent vers un bug interne dans le binaire Node.js lui-même.

`ERR_UNKNOWN_CREDENTIAL`

Un identifiant de groupe ou d'utilisateur Unix qui n'existe pas a été passé.

`ERR_UNKNOWN_ENCODING`

Une option d'encodage invalide ou inconnue a été passée à une API.

`ERR_UNKNOWN_FILE_EXTENSION`

[Stable: 1 - Experimental]

Stable: 1 Stabilité: 1 - Expérimental

Une tentative a été faite pour charger un module avec une extension de fichier inconnue ou non prise en charge.

`ERR_UNKNOWN_MODULE_FORMAT`

[Stable: 1 - Experimental]

Stable: 1 Stabilité: 1 - Expérimental

Une tentative a été faite pour charger un module avec un format inconnu ou non pris en charge.

`ERR_UNKNOWN_SIGNAL`

Un signal de processus invalide ou inconnu a été passé à une API attendant un signal valide (tel que subprocess.kill()).

`ERR_UNSUPPORTED_DIR_IMPORT`

L'instruction import d'une URL de répertoire n'est pas prise en charge. Utilisez plutôt l'auto-référence à un paquet en utilisant son nom et définissez un sous-chemin personnalisé dans le champ "exports" du fichier package.json.

import './'; // non pris en charge
import './index.js'; // pris en charge
import 'package-name'; // pris en charge

`ERR_UNSUPPORTED_ESM_URL_SCHEME`

L'instruction import avec des schémas d'URL autres que file et data n'est pas prise en charge.

`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`

Ajouté dans : v22.6.0

La suppression des types n'est pas prise en charge pour les fichiers descendants d'un répertoire node_modules.

`ERR_UNSUPPORTED_RESOLVE_REQUEST`

Une tentative de résolution d'un référent de module invalide a été effectuée. Cela peut se produire lors de l'importation ou de l'appel de import.meta.resolve() avec :

un spécificateur nu qui n'est pas un module intégré à partir d'un module dont le schéma d'URL n'est pas file.
une URL relative à partir d'un module dont le schéma d'URL n'est pas un schéma spécial.

try {
  // Tentative d'importation du paquet 'bare-specifier' depuis un module d'URL `data:` :
  await import('data:text/javascript,import "bare-specifier"');
} catch (e) {
  console.log(e.code); // ERR_UNSUPPORTED_RESOLVE_REQUEST
}

`ERR_USE_AFTER_CLOSE`

[Stable: 1 - Experimental]

Stable: 1 Stabilité : 1 - Expérimental

Une tentative d'utilisation de quelque chose qui était déjà fermé a été effectuée.

`ERR_VALID_PERFORMANCE_ENTRY_TYPE`

Lors de l'utilisation de l'API Performance Timing (perf_hooks), aucun type d'entrée de performance valide n'est trouvé.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`

Un rappel d'importation dynamique n'a pas été spécifié.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG`

Un rappel d'importation dynamique a été invoqué sans --experimental-vm-modules.

`ERR_VM_MODULE_ALREADY_LINKED`

Le module qui a tenté d'être lié n'est pas éligible au lien, pour l'une des raisons suivantes :

Il a déjà été lié (linkingStatus est 'linked')
Il est en cours de liaison (linkingStatus est 'linking')
La liaison a échoué pour ce module (linkingStatus est 'errored')

`ERR_VM_MODULE_CACHED_DATA_REJECTED`

L'option cachedData passée à un constructeur de module n'est pas valide.

`ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA`

Les données mises en cache ne peuvent pas être créées pour les modules qui ont déjà été évalués.

`ERR_VM_MODULE_DIFFERENT_CONTEXT`

Le module renvoyé par la fonction linker provient d'un contexte différent de celui du module parent. Les modules liés doivent partager le même contexte.

`ERR_VM_MODULE_LINK_FAILURE`

Le module n'a pas pu être lié en raison d'un échec.

`ERR_VM_MODULE_NOT_MODULE`

La valeur accomplie d'une promesse de liaison n'est pas un objet vm.Module.

`ERR_VM_MODULE_STATUS`

L'état actuel du module ne permet pas cette opération. La signification spécifique de l'erreur dépend de la fonction spécifique.

`ERR_WASI_ALREADY_STARTED`

L'instance WASI a déjà démarré.

`ERR_WASI_NOT_STARTED`

L'instance WASI n'a pas été démarrée.

`ERR_WEBASSEMBLY_RESPONSE`

Ajouté dans : v18.1.0

La Response qui a été passée à WebAssembly.compileStreaming ou à WebAssembly.instantiateStreaming n'est pas une réponse WebAssembly valide.

`ERR_WORKER_INIT_FAILED`

`ERR_WORKER_OUT_OF_MEMORY`

L'instance Worker s'est arrêtée car elle a atteint sa limite de mémoire.

`ERR_WORKER_PATH`

Le chemin d'accès au script principal d'un worker n'est ni un chemin absolu, ni un chemin relatif commençant par ./ ou ../.

`ERR_WORKER_UNSERIALIZABLE_ERROR`

Toutes les tentatives de sérialisation d'une exception non interceptée d'un thread de worker ont échoué.

`ERR_WORKER_UNSUPPORTED_OPERATION`

La fonctionnalité demandée n'est pas prise en charge dans les threads de worker.

`ERR_ZLIB_INITIALIZATION_FAILED`

La création d'un objet zlib a échoué en raison d'une configuration incorrecte.

`HPE_CHUNK_EXTENSIONS_OVERFLOW`

Ajouté dans : v21.6.2, v20.11.1, v18.19.1

Trop de données ont été reçues pour une extension de segment. Afin de se protéger contre les clients malveillants ou mal configurés, si plus de 16 Kio de données sont reçues, une Error avec ce code sera émise.

`HPE_HEADER_OVERFLOW`

[Historique]

Version	Modifications
v11.4.0, v10.15.0	La taille maximale de l'en-tête dans `http_parser` a été fixée à 8 KiB.

Trop de données d'en-tête HTTP ont été reçues. Afin de se protéger contre les clients malveillants ou mal configurés, si plus de maxHeaderSize de données d'en-tête HTTP sont reçues, l'analyse HTTP sera abandonnée sans qu'un objet de requête ou de réponse ne soit créé, et une Error avec ce code sera émise.

`HPE_UNEXPECTED_CONTENT_LENGTH`

Le serveur envoie à la fois un en-tête Content-Length et Transfer-Encoding: chunked.

Transfer-Encoding: chunked permet au serveur de maintenir une connexion persistante HTTP pour le contenu généré dynamiquement. Dans ce cas, l'en-tête HTTP Content-Length ne peut pas être utilisé.

Utilisez Content-Length ou Transfer-Encoding: chunked.

`MODULE_NOT_FOUND`

[Historique]

Version	Modifications
v12.0.0	Ajout de la propriété `requireStack`.

Un fichier de module n'a pas pu être résolu par le chargeur de modules CommonJS lors d'une tentative d'opération require() ou lors du chargement du point d'entrée du programme.

Codes d'erreur Node.js hérités

[Stable: 0 - Déprécié]

Stable: 0 Stabilité: 0 - Déprécié. Ces codes d'erreur sont soit incohérents, soit ont été supprimés.

`ERR_CANNOT_TRANSFER_OBJECT`

Ajouté dans: v10.5.0

Supprimé dans: v12.5.0

La valeur passée à postMessage() contenait un objet qui n'est pas supporté pour le transfert.

`ERR_CPU_USAGE`

Supprimé dans: v15.0.0

L'appel natif de process.cpuUsage n'a pas pu être traité.

`ERR_CRYPTO_HASH_DIGEST_NO_UTF16`

Ajouté dans: v9.0.0

Supprimé dans: v12.12.0

L'encodage UTF-16 a été utilisé avec hash.digest(). Bien que la méthode hash.digest() autorise la transmission d'un argument encoding, ce qui fait que la méthode renvoie une chaîne de caractères plutôt qu'un Buffer, l'encodage UTF-16 (par exemple ucs ou utf16le) n'est pas pris en charge.

`ERR_CRYPTO_SCRYPT_INVALID_PARAMETER`

Supprimé dans : v23.0.0

Une combinaison d'options incompatibles a été transmise à crypto.scrypt() ou crypto.scryptSync(). Les nouvelles versions de Node.js utilisent désormais le code d'erreur ERR_INCOMPATIBLE_OPTION_PAIR à la place, ce qui est cohérent avec d'autres API.

Ce code d'erreur a été remplacé par ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST dans Node.js v15.0.0, car il n'est plus précis étant donné qu'il existe désormais d'autres types d'objets transférables.

`ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST`

[Historique]

Version	Modifications
v21.0.0	Une `DOMException` est lancée à la place.
v21.0.0	Supprimé dans: v21.0.0
v15.0.0	Ajouté dans: v15.0.0

Un objet qui doit être explicitement listé dans l'argument transferList se trouve dans l'objet passé à un appel postMessage(), mais n'est pas fourni dans le transferList pour cet appel. Généralement, il s'agit d'un MessagePort.

Dans les versions de Node.js antérieures à v15.0.0, le code d'erreur utilisé ici était ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST. Cependant, l'ensemble des types d'objets transférables a été élargi pour couvrir plus de types que MessagePort.

`ERR_NAPI_CONS_PROTOTYPE_OBJECT`

Ajouté dans: v9.0.0

Supprimé dans: v10.0.0

Utilisé par la Node-API lorsque Constructor.prototype n'est pas un objet.

`ERR_NAPI_TSFN_START_IDLE_LOOP`

Ajouté dans : v10.6.0, v8.16.0

Supprimé dans : v14.2.0, v12.17.0

Sur le thread principal, les valeurs sont supprimées de la file d'attente associée à la fonction thread-safe dans une boucle d'inactivité. Cette erreur indique qu'une erreur s'est produite lors de la tentative de démarrage de la boucle.

`ERR_NAPI_TSFN_STOP_IDLE_LOOP`

Ajouté dans : v10.6.0, v8.16.0

Supprimé dans : v14.2.0, v12.17.0

Une fois qu'il ne reste plus d'éléments dans la file d'attente, la boucle d'inactivité doit être suspendue. Cette erreur indique que la boucle d'inactivité n'a pas pu s'arrêter.

`ERR_NO_LONGER_SUPPORTED`

Un SharedArrayBuffer dont la mémoire n'est pas gérée par le moteur JavaScript ou par Node.js a été rencontré lors de la sérialisation. Un tel SharedArrayBuffer ne peut pas être sérialisé.

Cela ne peut se produire que lorsque des modules complémentaires natifs créent des SharedArrayBuffer en mode "externalisé", ou mettent des SharedArrayBuffer existants en mode externalisé.

`ERR_UNKNOWN_STDIN_TYPE`

Ajouté dans : v8.0.0

Supprimé dans : v11.7.0

Une tentative a été faite pour lancer un processus Node.js avec un type de fichier stdin inconnu. Cette erreur est généralement une indication d'un bug dans Node.js lui-même, bien qu'il soit possible que le code utilisateur la déclenche.

`ERR_UNKNOWN_STREAM_TYPE`

Ajouté dans : v8.0.0

Supprimé dans : v11.7.0

Une tentative a été faite pour lancer un processus Node.js avec un type de fichier stdout ou stderr inconnu. Cette erreur est généralement une indication d'un bug dans Node.js lui-même, bien qu'il soit possible que le code utilisateur la déclenche.

`ERR_V8BREAKITERATOR`

L'API V8 BreakIterator a été utilisée mais l'ensemble complet de données ICU n'est pas installé.

`ERR_VALUE_OUT_OF_RANGE`

Ajouté dans : v9.0.0

Supprimé dans : v10.0.0

Utilisé lorsqu'une valeur donnée est hors de la plage acceptée.

`ERR_VM_MODULE_LINKING_ERRORED`

Ajouté dans : v10.0.0

Supprimé dans : v18.1.0, v16.17.0

La fonction de linker a retourné un module pour lequel la liaison a échoué.

`ERR_VM_MODULE_NOT_LINKED`

Le module doit être lié avec succès avant l'instanciation.

`ERR_WORKER_UNSUPPORTED_EXTENSION`

Ajouté dans : v11.0.0

Supprimé dans : v16.9.0

Le nom de chemin utilisé pour le script principal d'un worker a une extension de fichier inconnue.

`ERR_ZLIB_BINDING_CLOSED`

Ajouté dans : v9.0.0

Supprimé dans : v10.0.0

Utilisé lorsqu'une tentative est faite d'utiliser un objet zlib après qu'il a déjà été fermé.

Codes d'erreur OpenSSL

Erreurs de validité temporelle

`CERT_NOT_YET_VALID`

Le certificat n'est pas encore valide : la date notBefore est postérieure à l'heure actuelle.

`CERT_HAS_EXPIRED`

Le certificat a expiré : la date notAfter est antérieure à l'heure actuelle.

`CRL_NOT_YET_VALID`

La liste de révocation de certificats (CRL) a une date de publication future.

`CRL_HAS_EXPIRED`

La liste de révocation de certificats (CRL) a expiré.

`CERT_REVOKED`

Le certificat a été révoqué ; il figure sur une liste de révocation de certificats (CRL).

`UNABLE_TO_GET_ISSUER_CERT`

Le certificat de l'émetteur d'un certificat recherché n'a pas pu être trouvé. Cela signifie normalement que la liste des certificats de confiance n'est pas complète.

`UNABLE_TO_GET_ISSUER_CERT_LOCALLY`

L'émetteur du certificat est inconnu. C'est le cas si l'émetteur n'est pas inclus dans la liste des certificats de confiance.

`DEPTH_ZERO_SELF_SIGNED_CERT`

Le certificat transmis est auto-signé et le même certificat n'a pas pu être trouvé dans la liste des certificats de confiance.

`SELF_SIGNED_CERT_IN_CHAIN`

L'émetteur du certificat est inconnu. C'est le cas si l'émetteur n'est pas inclus dans la liste des certificats de confiance.

`CERT_CHAIN_TOO_LONG`

La longueur de la chaîne de certificats est supérieure à la profondeur maximale.

`UNABLE_TO_GET_CRL`

La CRL référencée par le certificat n'a pas pu être trouvée.

`UNABLE_TO_VERIFY_LEAF_SIGNATURE`

Aucune signature n'a pu être vérifiée car la chaîne ne contient qu'un seul certificat et il n'est pas auto-signé.

`CERT_UNTRUSTED`

L'autorité de certification (CA) racine n'est pas marquée comme approuvée pour l'usage spécifié.

Erreurs d'extension de base

`INVALID_CA`

Un certificat CA est invalide. Soit ce n'est pas une CA, soit ses extensions ne sont pas compatibles avec l'usage fourni.

`PATH_LENGTH_EXCEEDED`

Le paramètre pathlength basicConstraints a été dépassé.

`HOSTNAME_MISMATCH`

Le certificat ne correspond pas au nom fourni.

Erreurs d'usage et de politique

`INVALID_PURPOSE`

Le certificat fourni ne peut pas être utilisé aux fins spécifiées.

`CERT_REJECTED`

L'autorité de certification racine est marquée pour rejeter l'objectif spécifié.

Erreurs de formatage

`CERT_SIGNATURE_FAILURE`

La signature du certificat n'est pas valide.

`CRL_SIGNATURE_FAILURE`

La signature de la liste de révocation de certificats (CRL) n'est pas valide.

`ERROR_IN_CERT_NOT_BEFORE_FIELD`

Le champ notBefore du certificat contient une heure non valide.

`ERROR_IN_CERT_NOT_AFTER_FIELD`

Le champ notAfter du certificat contient une heure non valide.

`ERROR_IN_CRL_LAST_UPDATE_FIELD`

Le champ lastUpdate de la CRL contient une heure non valide.

`ERROR_IN_CRL_NEXT_UPDATE_FIELD`

Le champ nextUpdate de la CRL contient une heure non valide.

`UNABLE_TO_DECRYPT_CERT_SIGNATURE`

La signature du certificat n'a pas pu être déchiffrée. Cela signifie que la valeur réelle de la signature n'a pas pu être déterminée, plutôt que de ne pas correspondre à la valeur attendue ; ceci n'est significatif que pour les clés RSA.

`UNABLE_TO_DECRYPT_CRL_SIGNATURE`

La signature de la liste de révocation de certificats (CRL) n'a pas pu être déchiffrée : cela signifie que la valeur réelle de la signature n'a pas pu être déterminée, plutôt que de ne pas correspondre à la valeur attendue.

`UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY`

La clé publique dans le SubjectPublicKeyInfo du certificat n'a pas pu être lue.

Autres erreurs OpenSSL

`OUT_OF_MEM`

Une erreur s'est produite lors de la tentative d'allocation de mémoire. Cela ne devrait jamais arriver.

Erreurs ​

Propagation et interception des erreurs ​

Classe : Error ​

new Error(message[, options]) ​

Error.captureStackTrace(targetObject[, constructorOpt]) ​

Error.stackTraceLimit ​

error.cause ​

error.code ​

error.message ​

error.stack ​

Classe : AssertionError ​

Classe : RangeError ​

Classe : ReferenceError ​

Classe : SyntaxError ​

Classe : SystemError ​

error.address ​

error.code ​

error.dest ​

error.errno ​

error.info ​

error.message ​

error.path ​

error.port ​

error.syscall ​

Erreurs système courantes ​

Classe : TypeError ​

Exceptions vs. erreurs ​

Erreurs OpenSSL ​

error.opensslErrorStack ​

error.function ​

error.library ​

error.reason ​

Codes d'erreur Node.js ​

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 ​

Erreurs

Propagation et interception des erreurs

Classe : `Error`

`new Error(message[, options])`

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

`Error.stackTraceLimit`

`error.cause`

`error.code`

`error.message`

`error.stack`

Classe : `AssertionError`

Classe : `RangeError`

Classe : `ReferenceError`

Classe : `SyntaxError`

Classe : `SystemError`

`error.address`

`error.code`

`error.dest`

`error.errno`

`error.info`

`error.message`

`error.path`

`error.port`

`error.syscall`

Erreurs système courantes

Classe : `TypeError`

Exceptions vs. erreurs

Erreurs OpenSSL

`error.opensslErrorStack`

`error.function`

`error.library`

`error.reason`

Codes d'erreur Node.js

`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`