Erreurs

Les applications exécutées dans Node.js rencontrent généralement quatre catégories d'erreurs :

Erreurs JavaScript standard telles que <EvalError>, <SyntaxError>, <RangeError>, <ReferenceError>, <TypeError> et <URIError>.
Erreurs système déclenchées par des contraintes du système d'exploitation sous-jacent, telles que la tentative d'ouverture d'un fichier inexistant ou la tentative d'envoi de données sur un socket fermé.
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 logique exceptionnelle qui ne devrait jamais se produire. Celles-ci sont généralement générées par le module node:assert.

Toutes les erreurs JavaScript et système générées par Node.js héritent ou sont des instances de la classe JavaScript standard <Error> et garantissent 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 de propagation et de gestion des erreurs qui se produisent lors de l'exécution d'une application. La manière dont ces erreurs sont signalées et traité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 en utilisant le mécanisme standard throw 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> ni n'accepte de fonction callback, telle que 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 pourrait ê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 acheminées vers l'événement 'error' de cet objet.
Une poignée de méthodes généralement asynchrones de l'API Node.js peuvent toujours 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 vous référer à 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 au fil du temps (par opposition à une seule opération qui peut réussir ou échouer).

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

const EventEmitter = require('node:events')
const ee = new EventEmitter()
setImmediate(() => {
  // Cela plantera le processus car aucun gestionnaire d'événement 'error'
  // n'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 générées par ces méthodes sont propagées.

Classe : `Error`

Un objet JavaScript générique <Error> qui ne désigne aucune circonstance spécifique expliquant la survenue de l’erreur. Les objets Error capturent une « pile d’appels » détaillant le point du code où l’objet Error a été instancié, 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é la nouvelle erreur créée.

Crée un nouvel objet Error et affecte la propriété error.message au 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 piles d’appels dépendent de l’API de pile d’appels de V8. Les piles d’appels 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, selon la plus petite valeur.

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

targetObject <Object>
constructorOpt <Function>

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

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

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

L’argument facultatif constructorOpt accepte une fonction. S’il est donné, 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éer 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 de la trace de pile au-dessus de la fonction b
  Error.captureStackTrace(error, b) // Ni la fonction c, ni la fonction b ne sont incluses dans la trace de pile
  throw error
}

a()

`Error.stackTraceLimit`

<nombre>

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 sur 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 elle est définie sur une valeur non numérique, ou sur un nombre négatif, les traces de pile ne captureront aucune frame.

`error.cause`

Ajouté dans : v16.9.0

<quelconque>

Si elle est présente, la propriété error.cause est la cause sous-jacente de l'Error. Elle est utilisée lorsqu'on intercepte une erreur et qu'on en lève une nouvelle avec un message ou un code différent afin d'avoir toujours accès à l'erreur originale.

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 de chaîner les erreurs. Lors de la sérialisation des objets Error, util.inspect() sérialise récursivement error.cause si elle est définie.

const cause = new Error('Le serveur HTTP distant a répondu avec un statut 500')
const symptom = new Error("L'envoi du message a échoué", { cause })

console.log(symptom)
// Affiche :
//   Error: L'envoi du message a échoué
//       at REPL2:1:17
//       at Script.runInThisContext (node:vm:130:12)
//       ... 7 lignes correspondant à la trace de la 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 le moyen le 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. Consultez les 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 l'erreur sous forme de chaîne, 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 la pile de l'Error, cependant, modifier cette propriété après la création de l'objet Error peut ne pas modifier la première ligne de la trace de la 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é.

bash

Error: Des choses continuent à se produire !
   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 d'images de pile (chaque ligne commençant par "at "). Chaque image 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 pourra parfois pas trouver de nom approprié. Si V8 ne peut pas déterminer un nom pour la fonction, seules les informations de localisation seront affichées pour cette image. Sinon, le nom de fonction déterminé sera affiché avec les informations de localisation ajoutées entre parenthèses.

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

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

function makeFaster() {
  // `cheetahify()` appelle *de manière synchrone* speedy.
  cheetahify(function speedy() {
    throw new Error('oh no !')
  })
}

makeFaster()
// lancera :
//   /home/gbusey/file.js:6
//       throw new Error('oh no!');
//           ^
//   Error: oh no!
//       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 l'image représente un appel interne à V8 (comme dans [].forEach).
plain-filename.js:line:column, si l'image représente un appel interne à Node.js.
/absolute/path/to/file.js:line:column, si l'image représente un appel dans un programme utilisateur (utilisant le système de modules CommonJS), ou ses dépendances.
\<transport-protocol\>:///url/to/module/file.mjs:line:column, si l'image représente un appel dans un programme utilisateur (utilisant le système de modules ES), ou ses dépendances.

La chaîne représentant la trace de la pile est générée de manière différée lorsque la propriété error.stack est accédée.

Le nombre d'images capturées par la trace de la pile est limité par la plus petite valeur entre Error.stackTraceLimit et le nombre d'images disponibles sur le cycle d'événements actuel.

Classe : `AssertionError`

- Hérite de : <errors.Error>

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

Classe : `RangeError`

- Hérite de : <errors.Error>

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

require('node:net').connect(-1)
// Lève une exception "RangeError: l'option \"port\" doit être >= 0 et < 65536 : -1"

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

Classe : `ReferenceError`

- Hérite de : <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 défaillant.

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

doesNotExist
// Lève une 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 bogue dans le code ou ses dépendances.

Classe : `SyntaxError`

- Hérite de : <errors.Error>

Indique qu'un programme n'est pas du 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 suite à eval, Function, require ou vm. Ces erreurs sont presque toujours indicatives d'un programme défaillant.

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`

- Hérite de : <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 vers laquelle une connexion réseau a échoué
code <string> Le code d'erreur sous forme de chaîne de caractères
dest <string> Si présent, le chemin d'accès au 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 d'accès au 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ésente, error.address est une chaîne de caractères décrivant l'adresse vers laquelle une connexion réseau a échoué.

`error.code`

<string>

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

`error.dest`

<string>

Si présente, error.dest est le chemin d'accès à la destination du fichier lors de la déclaration 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 libuv Error handling.

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

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

`error.info`

<Object>

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

`error.message`

<string>

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

`error.path`

<string>

Si présente, error.path est une chaîne de caractères contenant un nom de chemin invalide pertinent.

`error.port`

<number>

Si présente, 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 de caractères décrivant l'appel système qui a échoué.

Erreurs système courantes

Voici une liste des erreurs système fréquemment 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 refusée) : une tentative d'accès à un fichier a été effectuée d'une manière interdite par ses permissions d'accès au fichier.
EADDRINUSE (Adresse déjà utilisée) : 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 (Connexion refusée) : 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 (Connexion réinitialisée par le pair) : une connexion a été fermée de force par un pair. Cela résulte normalement d'une perte de connexion sur la socket distante due à un délai d'attente ou à un redémarrage. Fréquemment rencontrée via les modules http et net.
EEXIST (Fichier existe) : un fichier existant était la cible d'une opération qui nécessitait que la cible n'existe pas.
EISDIR (Est un répertoire) : une opération attendait un fichier, mais le chemin d'accès donné était un répertoire.
EMFILE (Trop de fichiers ouverts dans le système) : 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 que lorsqu'au moins un a été fermé. Ceci est rencontré lors de l'ouverture de nombreux fichiers simultanément, en particulier sur les systèmes (en particulier, macOS) où la limite de descripteurs de fichiers est faible pour les processus. Pour remédier à une limite basse, exécutez ulimit -n 2048 dans le même shell qui exécutera le processus Node.js.
ENOENT (Aucun fichier ou répertoire de ce type) : soulevé couramment 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 (N'est pas un répertoire) : un composant du chemin d'accès donné existait, mais n'était pas un répertoire comme prévu. Soulevé couramment par fs.readdir.
ENOTEMPTY (Répertoire non vide) : un répertoire contenant des entrées était la cible d'une opération nécessitant un répertoire vide, généralement fs.unlink.
ENOTFOUND (Recherche DNS échouée) : indique une défaillance DNS de EAI_NODATA ou EAI_NONAME. Ce n'est pas une erreur POSIX standard.
EPERM (Opération non autorisée) : une tentative a été effectuée pour effectuer une opération nécessitant des privilèges élevés.
EPIPE (Tuyau cassé) : une écriture sur un pipe, une socket ou un FIFO pour lequel il n'y a aucun processus pour lire les données. Fréquemment rencontrée aux niveaux net et http, indiquant que le côté distant du flux en écriture a été fermé.
ETIMEDOUT (Opération expirée) : une demande 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`

Étend <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(() => {})
// Lance une TypeError, car une chaîne de caractères était attendue.

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

Exceptions vs. erreurs

Une exception JavaScript est une valeur qui est levée suite à une opération invalide ou comme cible d'une instruction throw. Bien qu'il ne soit pas nécessaire que ces valeurs soient des instances de Error ou des classes qui héritent de Error, toutes les exceptions levées par Node.js ou le runtime JavaScript seront des instances de Error.

Certaines exceptions sont irrécupérables au niveau JavaScript. De telles exceptions provoqueront toujours le crash du processus Node.js. Des 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 supplémentaires spécifiques à OpenSSL.

`error.opensslErrorStack`

Un tableau d'erreurs qui peuvent donner un contexte sur l'endroit dans la bibliothèque OpenSSL où une erreur provient.

`error.function`

La fonction OpenSSL à l'origine de l'erreur.

`error.library`

La bibliothèque OpenSSL à l'origine de l'erreur.

`error.reason`

Une chaîne de caractères lisible par l'homme 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é interrompue (typiquement à l'aide d'un AbortController).

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

Ce code n'utilise pas la convention ERR_* régulière que les erreurs Node.js utilisent afin d'être compatible avec AbortError de la plateforme web.

`ERR_ACCESS_DENIED`

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

`ERR_AMBIGUOUS_ARGUMENT`

Un argument de fonction est utilisé d’une manière qui suggère une mauvaise compréhension de la signature de la fonction. 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 cet usage suggère que l’utilisateur croit que message est le message attendu plutôt que le message que AssertionError affichera si block ne lève pas d’exception.

`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 logique exceptionnelle qui ne devrait jamais se produire. Ces erreurs sont généralement levées par le module node:assert.

`ERR_ASYNC_CALLBACK`

Une tentative a été faite pour enregistrer quelque chose qui n’est pas une fonction comme rappel 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 invalide a été passée 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 du code d’addon ou d’intégration, dans un contexte de moteur JS qui n’est pas associé à une instance Node.js. Les données passées à la méthode Buffer auront été libérées au moment où la méthode retournera.

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 principales 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 de réponse.

`ERR_CHILD_PROCESS_IPC_REQUIRED`

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

`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`

Utilisé lorsque le processus principal essaie de lire des données depuis le 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 l'appel de .close().

`ERR_CONSOLE_WRITABLE_STREAM`

Console a été instancié sans flux stdout, ou Console a un flux stdout ou stderr non inscriptible.

`ERR_CONSTRUCT_CALL_INVALID`

Ajouté dans : v12.5.0

Un constructeur de classe a été appelé qui 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 passé à 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 du drapeau 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 crypto invalide a été passé à require('node:crypto').setEngine().

`ERR_CRYPTO_FIPS_FORCED`

L'argument de ligne de commande --force-fips a été utilisé, mais une tentative d'activation ou de désactivation du mode FIPS a été effectuée dans le module node:crypto.

`ERR_CRYPTO_FIPS_UNAVAILABLE`

Une tentative d'activation ou de désactivation du mode FIPS a été effectuée, 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 crypto fournies 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 clé cryptographique fourni est invalide 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 prise en charge de scrypt. Non possible avec les binaires de version officielle, mais cela peut arriver avec des builds personnalisées, y compris les builds de distribution.

`ERR_CRYPTO_SIGN_KEY_REQUIRED`

Une clé 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é. Consultez crypto.getDiffieHellman() pour une liste des noms de groupe valides.

`ERR_CRYPTO_UNSUPPORTED_OPERATION`

Ajouté dans : v15.0.0, v14.18.0

Une tentative d'appel d'une opération cryptographique non prise en charge a été effectuée.

`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 dépassé le délai d'attente en attendant que l'hôte/port requis soit libre.

`ERR_DIR_CLOSED`

Le fs.Dir a été précédemment fermé.

`ERR_DIR_CONCURRENT_OPERATION`

Ajouté dans : v14.3.0

Un appel de lecture ou de fermeture synchrone 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 modules 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é précédemment.

`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`

process.setUncaughtExceptionCaptureCallback() n'a pas pu être appelé car le module node:domain a été chargé précédemment.

La trace de la 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 spécifié.

`ERR_ENCODING_NOT_SUPPORTED`

L'encodage fourni à l'API TextDecoder() ne faisait pas partie des Encodages supportés 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 dispatcher 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 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é callbackifiée via util.callbackify() a été rejetée avec une valeur fausse.

`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`

Ajouté dans : v14.0.0

Une tentative de copie vers un type de fichier inconnu a été effectuée avec fs.cp().

`ERR_FS_EISDIR`

Le chemin est un répertoire.

`ERR_FS_FILE_TOO_LARGE`

Une tentative de lecture d'un fichier dont la taille dépasse la taille maximale autorisée pour un Buffer a été effectuée.

`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 charge utile.

`ERR_HTTP2_CONNECT_AUTHORITY`

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

`ERR_HTTP2_CONNECT_PATH`

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

`ERR_HTTP2_CONNECT_SCHEME`

Pour les requêtes HTTP/2 utilisant la méthode CONNECT, l'en-tête pseudo :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 le lancement d'une réponse HTTP/2.

`ERR_HTTP2_HEADERS_SENT`

Une tentative d'envoi de plusieurs en-têtes de réponse a été effectuée.

`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 sont interdits dans les requêtes et les réponses HTTP/2.

`ERR_HTTP2_INVALID_HEADER_VALUE`

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

`ERR_HTTP2_INVALID_INFO_STATUS`

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

`ERR_HTTP2_INVALID_ORIGIN`

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

`ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH`

Les instances Buffer et Uint8Array passées à 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 invalide 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 HTTP/2 SETTINGS est envoyée à un pair connecté, le pair 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 maximum de trames SETTINGS non accusées peuvent être envoyées à un moment donné. Ce code d'erreur est utilisé lorsque cette limite a été 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 HTTP/2 ORIGIN 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`

Une requête ping HTTP/2 a été annulée.

`ERR_HTTP2_PING_LENGTH`

Les charges utiles des requêtes ping HTTP/2 doivent avoir exactement 8 octets de longueur.

`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 a été désactivé par le client.

`ERR_HTTP2_SEND_FILE`

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

`ERR_HTTP2_SEND_FILE_NOSEEK`

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

`ERR_HTTP2_SESSION_ERROR`

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

`ERR_HTTP2_SETTINGS_CANCEL`

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

`ERR_HTTP2_SOCKET_BOUND`

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

`ERR_HTTP2_SOCKET_UNBOUND`

Une tentative a été faite d'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 d'information 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 flux Http2Stream a été détruit avant que des données ne soient transmises au pair 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 et une dépendance 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 de frames de protocole HTTP/2 invalides acceptables envoyées par le pair, comme spécifié via l’option maxSessionInvalidFrames, a été dépassée.

`ERR_HTTP2_TRAILERS_ALREADY_SENT`

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

`ERR_HTTP2_TRAILERS_NOT_READY`

La méthode http2stream.sendTrailers() ne peut pas être appelée avant que l’événement 'wantTrailers' ne soit émis 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 utilisant 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 le 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ée.

`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ées.

`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 de statut se situait en dehors de la plage de codes de statut régulière (100-999).

`ERR_HTTP_REQUEST_TIMEOUT`

Le client n’a pas envoyé la requête entière dans le délai imparti.

`ERR_HTTP_SOCKET_ASSIGNED`

Le ServerResponse donné a déjà une socket assignée.

`ERR_HTTP_SOCKET_ENCODING`

Il n’est pas autorisé de modifier l’encodage de la socket selon la RFC 7230, section 3.

`ERR_HTTP_TRAILER_INVALID`

L’en-tête Trailer a été défini même si 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 simultanément.

`ERR_INPUT_TYPE_NOT_ALLOWED`

[Stable : 1 - Expérimental]

Stable : 1 Stabilité : 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 d'activation de l'inspecteur a été effectuée alors qu'il avait déjà commencé à écouter sur un port. Utilisez inspector.close() avant de l'activer sur 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 d'utilisation de l'inspecteur a été effectuée après la fermeture de la session.

`ERR_INSPECTOR_COMMAND`

Une erreur s'est produite lors de l'émission d'une commande via le module node:inspector.

`ERR_INSPECTOR_NOT_ACTIVE`

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

`ERR_INSPECTOR_NOT_AVAILABLE`

Le module node:inspector n'est pas disponible.

`ERR_INSPECTOR_NOT_CONNECTED`

Lors de l'utilisation du module node:inspector, une tentative d'utilisation de l'inspecteur a été effectuée avant sa connexion.

`ERR_INSPECTOR_NOT_WORKER`

Une API a été appelée sur le thread principal, alors qu'elle ne peut être utilisée que depuis le thread worker.

`ERR_INTERNAL_ASSERTION`

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

`ERR_INVALID_ADDRESS`

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

`ERR_INVALID_ADDRESS_FAMILY`

La famille d'adresses fournie n'est pas reconnue 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 invalide ou non prise en charge a été passée pour un argument donné.

`ERR_INVALID_ASYNC_ID`

Un asyncId ou un triggerAsyncId invalide a été passé en utilisant AsyncHooks. Un identifiant inférieur à -1 ne devrait jamais se produire.

`ERR_INVALID_BUFFER_SIZE`

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

`ERR_INVALID_CHAR`

Des caractères invalides 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 colonne spécifiée.

`ERR_INVALID_FD`

Un descripteur de fichier ('fd') n'était pas valide (par exemple, c'était 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 utilise des URL de type file: (comme certaines fonctions du 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ù seuls localhost ou un hôte vide sont pris en charge.

`ERR_INVALID_FILE_URL_PATH`

Une API Node.js qui utilise des URL de type file: (comme 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 plateforme.

`ERR_INVALID_HANDLE_TYPE`

Une tentative a été faite pour envoyer une "handle" non prise en charge via 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 invalide 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 de chargement d'un module qui n'existe pas ou qui n'est pas valide a été effectuée.

`ERR_INVALID_MODULE_SPECIFIER`

La chaîne de module importée est un spécificateur d'URL, de nom de package ou de sous-chemin de package non valide.

`ERR_INVALID_OBJECT_DEFINE_PROPERTY`

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

`ERR_INVALID_PACKAGE_CONFIG`

Un fichier package.json non valide a échoué à l'analyse.

`ERR_INVALID_PACKAGE_TARGET`

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

`ERR_INVALID_PROTOCOL`

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

`ERR_INVALID_REPL_EVAL_CONFIG`

Les options breakEvalOnSigint et eval ont é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`

Lancée si une option de fonction ne fournit pas une valeur valide pour l'une des propriétés de son objet retourné lors de l'exécution.

`ERR_INVALID_RETURN_PROPERTY_VALUE`

Lancée si une option de fonction ne fournit pas un type de valeur attendu pour l'une des propriétés de son objet retourné lors de l'exécution.

`ERR_INVALID_RETURN_VALUE`

Lancé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 terminée en raison d'un état non valide. Par exemple, un objet peut avoir déjà été détruit ou peut effectuer une autre opération.

`ERR_INVALID_SYNC_FORK_INPUT`

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

`ERR_INVALID_THIS`

Une fonction de l'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')
// Lance une TypeError avec le code 'ERR_INVALID_THIS'

`ERR_INVALID_TUPLE`

Un élément dans l'itérable fourni au constructeur URLSearchParams de l'API WHATWG URL ne représentait pas un tuple [nom, valeur] – c'est-à-dire, si un élément n'est pas itérable, ou ne contient pas 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 le suppression de type.

`ERR_INVALID_URI`

Une URI invalide a été passée.

`ERR_INVALID_URL`

Une URL invalide a été passée au constructeur URL de l'API WHATWG URL ou à la fonction héritée url.parse() pour être analysée. L'objet d'erreur généré possède généralement une propriété supplémentaire 'input' qui contient l'URL dont l'analyse a échoué.

`ERR_INVALID_URL_SCHEME`

Une tentative a été faite pour utiliser une URL d'un schéma (protocole) incompatible à une fin spécifique. Elle est uniquement utilisée dans le support de l'API WHATWG URL dans le module fs (qui n'accepte que les URL avec le schéma 'file'), mais pourrait également être utilisée dans d'autres API Node.js à l'avenir.

`ERR_IPC_CHANNEL_CLOSED`

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

`ERR_IPC_DISCONNECTED`

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

`ERR_IPC_ONE_PIPE`

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

`ERR_IPC_SYNC_FORK`

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

`ERR_IP_BLOCKED`

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

`ERR_LOADER_CHAIN_INCOMPLETE`

Ajouté dans : v18.6.0, v16.17.0

Un crochet de chargeur ESM a 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 a été faite pour allouer de la mémoire (généralement dans la couche C++), 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 contexte vm cible. Tous les objets Node.js ne peuvent pas être instanciés avec succès dans tous les contextes pour le moment, et tenter de les transférer à l'aide de postMessage() peut échouer du côté récepteur 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é passé. Ceci est uniquement utilisé pour la conformité stricte à 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 des objets d'options, certaines options peuvent être obligatoires. Ce code est déclenché si une option requise est manquante.

`ERR_MISSING_PASSPHRASE`

Une tentative a été faite pour lire une clé chiffré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. Cela est dû à un manque de prise en charge de l'intégration pour les Workers. En particulier, cette erreur ne se produira pas avec les versions 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`

Une fonction de rappel a été appelée plus d'une fois.

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

`ERR_NAPI_CONS_FUNCTION`

Lors de l'utilisation de Node-API, un constructeur passé 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 du dataview ou offset + length était supérieur à la longueur du 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 undefined JavaScript.

`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 d'utiliser des opérations qui ne peuvent être utilisées que lors de la création d'un snapshot de démarrage V8, même si Node.js n'en crée pas.

`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 n'est pas dans une application mono-exécutable.

`ERR_NOT_SUPPORTED_IN_SNAPSHOT`

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

`ERR_NO_CRYPTO`

Une tentative a été faite d'utiliser des fonctionnalités cryptographiques alors que Node.js n'a pas été compilé avec la prise en charge cryptographique 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 la prise en charge d'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 en dehors de la plage acceptée.

`ERR_PACKAGE_IMPORT_NOT_DEFINED`

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

`ERR_PACKAGE_PATH_NOT_EXPORTED`

Le champ "exports" de package.json n'exporte pas le sous-chemin demandé. Étant donné que les exportations sont encapsulées, 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 une URL absolue est utilisée.

`ERR_PARSE_ARGS_INVALID_OPTION_VALUE`

Ajouté dans : v18.3.0, v16.17.0

Lorsque strict est défini sur true, 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, 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 Stabilité : 1 - Expérimental

Lorsqu'on tente d'utiliser require() sur un module ES, une limite CommonJS vers ESM ou ESM vers CommonJS participe à un cycle immédiat. Ceci n'est pas autorisé car les modules ES ne peuvent pas être évalués lorsqu'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 différée dans une fonction interne.

`ERR_REQUIRE_ESM`

[Historique]

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

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

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

Une tentative a été faite pour utiliser require() sur un module ES.

Cette erreur est dépréciée depuis que require() prend désormais en charge le chargement des modules ES synchrones. Lorsque require() rencontre un module ES contenant 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, Ctrl+C a été pressé).

`ERR_SCRIPT_EXECUTION_TIMEOUT`

L'exécution du script a dépassé le délai imparti, probablement en raison de bogues dans le script exécuté.

`ERR_SERVER_ALREADY_LISTEN`

La méthode server.listen() a été appelée alors qu'un net.Server était déjà en écoute. Ceci s'applique à toutes les instances de net.Server, y compris les instances de serveur 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é passée aux API d'application exécutable unique pour identifier un actif, mais aucune correspondance n'a pu être 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 attendante d'un port >= 0 et < 65536 a reçu une valeur invalide.

`ERR_SOCKET_BAD_TYPE`

Une fonction API attendante d'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 l'établissement de la connexion.

`ERR_SOCKET_CONNECTION_TIMEOUT`

Le socket n'a pas pu se connecter à une adresse renvoyée par le DNS dans le délai imparti 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é depuis 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 de caractères 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 mais ne peut pas aboutir 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 mais ne peut pas aboutir 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 bloc 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é dans le flux.

`ERR_STREAM_UNABLE_TO_PIPE`

Une tentative a été faite pour effectuer un pipe 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 l'émission de l'événement 'end'.

`ERR_STREAM_WRAP`

Empêche un arrêt si un décodeur de chaînes 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 au sein du 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 de lexeur défaillant.

`ERR_TAP_PARSER_ERROR`

Une erreur représentant un état d'analyseur 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 ayant échoué.

`ERR_TEST_FAILURE`

Cette erreur représente un test ayant é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 sont mutuellement exclusives.

`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 Certificate produits par Node.js lui-même respectent toujours les 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'IP du pair ne correspondait à aucun des subjectAltNames de 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é accrue.

`ERR_TLS_HANDSHAKE_TIMEOUT`

Une négociation TLS/SSL a expiré. Dans ce cas, le serveur doit également interrompre 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 est invalide. Elle est soit inconnue, soit désactivée car elle est non 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`

Tentative de définir un minVersion ou un maxVersion de protocole TLS en conflit avec une tentative de définir explicitement secureProtocol. Utilisez un seul 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 la 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`

Un nombre excessif de renégociations TLS est détecté, ce qui constitue un vecteur potentiel pour les attaques par déni de service.

`ERR_TLS_SNI_FROM_SERVER`

Une tentative a été faite pour émettre une indication de nom de serveur (SNI) à partir d'un socket côté serveur TLS, ce qui n'est valide que du côté 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 cours de transformation.

`ERR_TRANSFORM_WITH_LENGTH_0`

Un flux Transform s'est terminé avec des données encore présentes dans la mémoire 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 au sein d'un gestionnaire process.on('exit') qui ne doit pas être appelé au sein d'un gestionnaire process.on('exit').

`ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET`

process.setUncaughtExceptionCaptureCallback() a été appelé deux fois, sans avoir préalablement réinitialisé le rappel à null.

Cette erreur est conçue pour empêcher l'écrasement accidentel d'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'aucun gestionnaire 'error' n'est 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é par le code utilisateur. Les instances de cette erreur signalent un bogue interne au sein du 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 - Expérimental]

Stable : 1 Stabilité : 1 - Expérimental

Une tentative de chargement d'un module avec une extension de fichier inconnue ou non prise en charge a été effectuée.

`ERR_UNKNOWN_MODULE_FORMAT`

[Stable : 1 - Expérimental]

Stable : 1 Stabilité : 1 - Expérimental

Une tentative de chargement d'un module avec un format inconnu ou non pris en charge a été effectuée.

`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'importation d'une URL de répertoire n'est pas prise en charge. Utilisez plutôt la référence automatique d'un package en utilisant son nom et définissez un sous-chemin personnalisé dans le champ "exports" du fichier package.json.

import './' // non supporté
import './index.js' // supporté
import 'package-name' // supporté

`ERR_UNSUPPORTED_ESM_URL_SCHEME`

L'importation 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

Le retrait de type n'est pas pris en charge pour les fichiers descendants d'un répertoire node_modules.

`ERR_UNSUPPORTED_RESOLVE_REQUEST`

Une tentative a été faite pour résoudre un référent de module invalide. 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 package 'bare-specifier' à partir d'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 - Expérimental]

Stable : 1 Stabilité : 1 - Expérimental

Une tentative a été faite pour utiliser quelque chose qui était déjà fermé.

`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é appelé 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 est invalide.

`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 de liaison 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'une erreur.

`ERR_VM_MODULE_NOT_MODULE`

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

`ERR_VM_MODULE_STATUS`

Le statut du module actuel 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 a été terminée car elle a atteint sa limite de mémoire.

`ERR_WORKER_PATH`

Le chemin d'accès pour le 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 provenant d'un thread worker ont échoué.

`ERR_WORKER_UNSUPPORTED_OPERATION`

La fonctionnalité demandée n'est pas prise en charge dans les threads 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 les extensions de bloc. Afin de se protéger contre les clients malveillants ou mal configurés, si plus de 16 KiB de données sont reçues, une erreur avec ce code sera émise.

`HPE_HEADER_OVERFLOW`

[Historique]

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

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 s'interrompra sans qu'un objet requête ou réponse ne soit créé, et une Erreur 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 HTTP persistante 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	Propriété `requireStack` ajoutée.

Un fichier 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 pris en charge 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() permette de passer un argument encoding, ce qui fait que la méthode renvoie une chaîne 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 incompatible a été passée à crypto.scrypt() ou crypto.scryptSync(). Les nouvelles versions de Node.js utilisent à la place le code d'erreur ERR_INCOMPATIBLE_OPTION_PAIR, ce qui est cohérent avec les 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, d’autres types d’objets transférables existant désormais.

`ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST`

[Historique]

Version	Modifications
v21.0.0	Une exception `DOMException` est levé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 répertorié dans l’argument transferList se trouve dans l’objet passé à un appel postMessage(), mais n’est pas fourni dans le transferList de cet appel. Généralement, il s’agit d’un MessagePort.

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

`ERR_NAPI_CONS_PROTOTYPE_OBJECT`

Ajouté dans : v9.0.0

Supprimé dans : v10.0.0

Utilisé par le 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 inactive. 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 inactive doit être suspendue. Cette erreur indique que la boucle inactive 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 les modules natifs créent des SharedArrayBuffer en mode « externalisé » ou placent un SharedArrayBuffer existant 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 indique généralement un bogue dans Node.js lui-même, bien qu'il soit possible que du code utilisateur le 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 indique généralement un bogue dans Node.js lui-même, bien qu'il soit possible que du code utilisateur le déclenche.

`ERR_V8BREAKITERATOR`

L'API V8 BreakIterator a été utilisée, mais le jeu de données ICU complet 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 en dehors 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 liaison a renvoyé un module pour lequel la liaison a échoué.

`ERR_VM_MODULE_NOT_LINKED`

Le module doit être correctement lié 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 pour 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 d'émission 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'autorité de certification d'un certificat recherché n'a pas pu être trouvé. Cela signifie généralement que la liste des certificats de confiance n'est pas complète.

`UNABLE_TO_GET_ISSUER_CERT_LOCALLY`

L'émetteur du certificat n'est pas connu. 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 ne peut pas être trouvé dans la liste des certificats de confiance.

`SELF_SIGNED_CERT_IN_CHAIN`

L'émetteur du certificat n'est pas connu. 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 référence CRL du 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 racine (CA) n'est pas marquée comme étant approuvée pour l'usage spécifié.

Erreurs d'extension de base

`INVALID_CA`

Un certificat d'autorité de certification est invalide. Soit ce n'est pas une autorité de certification, soit ses extensions ne sont pas cohérentes avec l'usage fourni.

`PATH_LENGTH_EXCEEDED`

Le paramètre de longueur de chemin basicConstraints a été dépassé.

`HOSTNAME_MISMATCH`

Le certificat ne correspond pas au nom fourni.

Erreurs d'utilisation et de politique

`INVALID_PURPOSE`

Le certificat fourni ne peut pas être utilisé pour l'usage spécifié.

`CERT_REJECTED`

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

Erreurs de formatage

`CERT_SIGNATURE_FAILURE`

La signature du certificat est invalide.

`CRL_SIGNATURE_FAILURE`

La signature de la liste de révocation de certificats (CRL) est invalide.

`ERROR_IN_CERT_NOT_BEFORE_FIELD`

Le champ notBefore du certificat contient une heure invalide.

`ERROR_IN_CERT_NOT_AFTER_FIELD`

Le champ notAfter du certificat contient une heure invalide.

`ERROR_IN_CRL_LAST_UPDATE_FIELD`

Le champ lastUpdate de la CRL contient une heure invalide.

`ERROR_IN_CRL_NEXT_UPDATE_FIELD`

Le champ nextUpdate de la CRL contient une heure invalide.

`UNABLE_TO_DECRYPT_CERT_SIGNATURE`

La signature du certificat n'a pas pu être décrypté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écrypté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`