Errori

Le applicazioni in esecuzione su Node.js generalmente riscontrano quattro categorie di errori:

Errori JavaScript standard come <EvalError>, <SyntaxError>, <RangeError>, <ReferenceError>, <TypeError> e <URIError>.
Errori di sistema attivati da vincoli del sistema operativo sottostante, come il tentativo di aprire un file che non esiste o il tentativo di inviare dati su un socket chiuso.
Errori specificati dall'utente attivati dal codice dell'applicazione.
Gli AssertionError sono una classe speciale di errore che può essere attivata quando Node.js rileva una violazione della logica eccezionale che non dovrebbe mai verificarsi. Questi vengono sollevati in genere dal modulo node:assert.

Tutti gli errori JavaScript e di sistema sollevati da Node.js ereditano da, o sono istanze di, la classe JavaScript standard <Error> e hanno la garanzia di fornire almeno le proprietà disponibili su quella classe.

Propagazione e intercettazione degli errori

Node.js supporta diversi meccanismi per la propagazione e la gestione degli errori che si verificano durante l'esecuzione di un'applicazione. Il modo in cui questi errori vengono segnalati e gestiti dipende interamente dal tipo di Error e dallo stile dell'API che viene chiamata.

Tutti gli errori JavaScript vengono gestiti come eccezioni che immediatamente generano e lanciano un errore utilizzando il meccanismo standard throw di JavaScript. Questi vengono gestiti utilizzando il costrutto try…catch fornito dal linguaggio JavaScript.

// Lancia un ReferenceError perché z non è definito.
try {
  const m = 1;
  const n = m + z;
} catch (err) {
  // Gestisci l'errore qui.
}

Qualsiasi utilizzo del meccanismo throw di JavaScript solleverà un'eccezione che deve essere gestita, altrimenti il processo Node.js si chiuderà immediatamente.

Con poche eccezioni, le API sincrone (qualsiasi metodo di blocco che non restituisce un <Promise> né accetta una funzione callback, come fs.readFileSync), useranno throw per segnalare gli errori.

Gli errori che si verificano all'interno delle API asincrone possono essere segnalati in diversi modi:

Alcuni metodi asincroni restituiscono un <Promise>, dovresti sempre tenere conto del fatto che potrebbe essere rifiutato. Vedi il flag --unhandled-rejections per come il processo reagirà a un rifiuto di promise non gestito.
La maggior parte dei metodi asincroni che accettano una funzione callback accetteranno un oggetto Error passato come primo argomento a quella funzione. Se quel primo argomento non è null ed è un'istanza di Error, allora si è verificato un errore che dovrebbe essere gestito.
Quando un metodo asincrono viene chiamato su un oggetto che è un EventEmitter, gli errori possono essere indirizzati all'evento 'error' di quell'oggetto.
Una manciata di metodi tipicamente asincroni nell'API Node.js possono ancora usare il meccanismo throw per sollevare eccezioni che devono essere gestite usando try…catch. Non esiste un elenco completo di tali metodi; fare riferimento alla documentazione di ciascun metodo per determinare il meccanismo di gestione degli errori appropriato richiesto.

L'uso del meccanismo dell'evento 'error' è più comune per le API basate su stream e basate su emettitori di eventi, che a loro volta rappresentano una serie di operazioni asincrone nel tempo (invece di una singola operazione che può avere successo o fallire).

Per tutti gli oggetti EventEmitter, se non viene fornito un gestore di eventi 'error', l'errore verrà lanciato, facendo sì che il processo Node.js segnali un'eccezione non catturata e si blocchi a meno che: non sia stato registrato un gestore per l'evento 'uncaughtException', oppure venga utilizzato il modulo deprecato node:domain.

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

setImmediate(() => {
  // Questo bloccherà il processo perché non è stato aggiunto alcun gestore
  // di eventi 'error'.
  ee.emit('error', new Error('This will crash'));
});

Gli errori generati in questo modo non possono essere intercettati usando try…catch poiché vengono lanciati dopo che il codice chiamante è già uscito.

Gli sviluppatori devono fare riferimento alla documentazione per ogni metodo per determinare esattamente come vengono propagati gli errori sollevati da tali metodi.

Classe: `Error`

Un oggetto JavaScript generico <Error> che non denota alcuna circostanza specifica del motivo per cui si è verificato l'errore. Gli oggetti Error catturano una "stack trace" che descrive in dettaglio il punto del codice in cui è stato istanziato Error e possono fornire una descrizione testuale dell'errore.

Tutti gli errori generati da Node.js, inclusi tutti gli errori di sistema e JavaScript, saranno istanze di o erediteranno dalla classe Error.

`new Error(message[, options])`

message <stringa>
options <Oggetto>
- cause <qualsiasi> L'errore che ha causato l'errore appena creato.

Crea un nuovo oggetto Error e imposta la proprietà error.message sul messaggio di testo fornito. Se un oggetto viene passato come message, il messaggio di testo viene generato chiamando String(message). Se viene fornita l'opzione cause, viene assegnata alla proprietà error.cause. La proprietà error.stack rappresenterà il punto nel codice in cui è stato chiamato new Error(). Le stack trace dipendono dalla stack trace API di V8. Le stack trace si estendono solo fino a (a) l'inizio dell'esecuzione del codice sincrono oppure (b) il numero di frame fornito dalla proprietà Error.stackTraceLimit, a seconda di quale sia minore.

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

targetObject <Oggetto>
constructorOpt <Funzione>

Crea una proprietà .stack su targetObject, che quando viene acceduta restituisce una stringa che rappresenta la posizione nel codice in cui è stato chiamato Error.captureStackTrace().

const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Simile a `new Error().stack`

La prima riga della traccia sarà preceduta da ${myObject.name}: ${myObject.message}.

L'argomento opzionale constructorOpt accetta una funzione. Se fornito, tutti i frame sopra constructorOpt, incluso constructorOpt, verranno omessi dalla stack trace generata.

L'argomento constructorOpt è utile per nascondere i dettagli di implementazione della generazione degli errori all'utente. Per esempio:

function a() {
  b();
}

function b() {
  c();
}

function c() {
  // Crea un errore senza stack trace per evitare di calcolare la stack trace due volte.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;

  // Cattura la stack trace sopra la funzione b
  Error.captureStackTrace(error, b); // Né la funzione c, né b sono incluse nella stack trace
  throw error;
}

a();

`Error.stackTraceLimit`

<number>

La proprietà Error.stackTraceLimit specifica il numero di frame dello stack raccolti da una traccia dello stack (sia che sia generata da new Error().stack o Error.captureStackTrace(obj)).

Il valore predefinito è 10, ma può essere impostato su qualsiasi numero JavaScript valido. Le modifiche influenzeranno qualsiasi traccia dello stack acquisita dopo che il valore è stato modificato.

Se impostato su un valore non numerico o su un numero negativo, le tracce dello stack non acquisiranno alcun frame.

`error.cause`

Aggiunto in: v16.9.0

<any>

Se presente, la proprietà error.cause è la causa sottostante dell'Error. Viene utilizzata quando si intercetta un errore e se ne lancia uno nuovo con un messaggio o un codice diverso al fine di avere ancora accesso all'errore originale.

La proprietà error.cause è in genere impostata chiamando new Error(message, { cause }). Non viene impostata dal costruttore se l'opzione cause non viene fornita.

Questa proprietà consente di concatenare gli errori. Quando si serializzano oggetti Error, util.inspect() serializza ricorsivamente error.cause se è impostato.

const cause = new Error('The remote HTTP server responded with a 500 status');
const symptom = new Error('The message failed to send', { cause });

console.log(symptom);
// Prints:
//   Error: The message failed to send
//       at REPL2:1:17
//       at Script.runInThisContext (node:vm:130:12)
//       ... 7 lines matching cause stack trace ...
//       at [_line] [as _line] (node:internal/readline/interface:886:18) {
//     [cause]: Error: The remote HTTP server responded with a 500 status
//         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`

<stringa>

La proprietà error.code è un'etichetta stringa che identifica il tipo di errore. error.code è il modo più stabile per identificare un errore. Cambierà solo tra le versioni principali di Node.js. Al contrario, le stringhe error.message possono cambiare tra qualsiasi versione di Node.js. Vedi Codici di errore di Node.js per i dettagli sui codici specifici.

`error.message`

<stringa>

La proprietà error.message è la descrizione stringa dell'errore come impostato chiamando new Error(message). Il message passato al costruttore apparirà anche nella prima riga dello stack trace dell'Error, tuttavia cambiare questa proprietà dopo che l'oggetto Error è stato creato potrebbe non cambiare la prima riga dello stack trace (ad esempio, quando error.stack viene letto prima che questa proprietà venga cambiata).

const err = new Error('Il messaggio');
console.error(err.message);
// Stampa: Il messaggio

`error.stack`

<stringa>

La proprietà error.stack è una stringa che descrive il punto del codice in cui è stato istanziato l'Error.

bash

Error: Le cose continuano ad accadere!
   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 prima riga è formattata come \<nome della classe di errore\>: \<messaggio di errore\>, ed è seguita da una serie di frame dello stack (ogni riga inizia con "at "). Ogni frame descrive un punto di chiamata all'interno del codice che ha portato alla generazione dell'errore. V8 tenta di visualizzare un nome per ogni funzione (per nome di variabile, nome di funzione o nome di metodo di oggetto), ma occasionalmente non sarà in grado di trovare un nome adatto. Se V8 non riesce a determinare un nome per la funzione, verranno visualizzate solo le informazioni sulla posizione per quel frame. Altrimenti, il nome della funzione determinato verrà visualizzato con le informazioni sulla posizione aggiunte tra parentesi.

I frame vengono generati solo per le funzioni JavaScript. Se, ad esempio, l'esecuzione passa in modo sincrono attraverso una funzione addon C++ chiamata cheetahify che a sua volta chiama una funzione JavaScript, il frame che rappresenta la chiamata cheetahify non sarà presente negli stack trace:

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

function makeFaster() {
  // `cheetahify()` chiama *sincronamente* speedy.
  cheetahify(function speedy() {
    throw new Error('oh no!');
  });
}

makeFaster();
// lancerà:
//   /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

Le informazioni sulla posizione saranno una delle seguenti:

native, se il frame rappresenta una chiamata interna a V8 (come in [].forEach).
nomefile-semplice.js:riga:colonna, se il frame rappresenta una chiamata interna a Node.js.
/percorso/assoluto/al/file.js:riga:colonna, se il frame rappresenta una chiamata in un programma utente (utilizzando il sistema di moduli CommonJS) o nelle sue dipendenze.
\<protocollo-di-trasporto\>:///url/al/modulo/file.mjs:riga:colonna, se il frame rappresenta una chiamata in un programma utente (utilizzando il sistema di moduli ES) o nelle sue dipendenze.

La stringa che rappresenta lo stack trace viene generata pigramente quando si accede alla proprietà error.stack.

Il numero di frame acquisiti dallo stack trace è limitato al minore tra Error.stackTraceLimit o il numero di frame disponibili sull'attuale tick del ciclo di eventi.

Classe: `AssertionError`

Estende: <errors.Error>

Indica il fallimento di un'asserzione. Per i dettagli, vedi Classe: assert.AssertionError.

Classe: `RangeError`

Estende: <errors.Error>

Indica che un argomento fornito non rientrava nell'insieme o nell'intervallo di valori accettabili per una funzione; sia che si tratti di un intervallo numerico, sia che sia al di fuori dell'insieme di opzioni per un determinato parametro di funzione.

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

Node.js genererà e lancerà istanze di RangeError immediatamente come forma di convalida degli argomenti.

Classe: `ReferenceError`

Estende: <errors.Error>

Indica che si sta tentando di accedere a una variabile che non è definita. Tali errori indicano comunemente errori di battitura nel codice o un programma altrimenti corrotto.

Sebbene il codice client possa generare e propagare questi errori, in pratica, solo V8 lo farà.

doesNotExist;
// Lancia ReferenceError, doesNotExist non è una variabile in questo programma.

A meno che un'applicazione non stia generando ed eseguendo dinamicamente codice, le istanze di ReferenceError indicano un bug nel codice o nelle sue dipendenze.

Classe: `SyntaxError`

Estende: <errors.Error>

Indica che un programma non è JavaScript valido. Questi errori possono essere generati e propagati solo a seguito della valutazione del codice. La valutazione del codice può avvenire a seguito di eval, Function, require o vm. Questi errori sono quasi sempre indicativi di un programma corrotto.

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

Le istanze di SyntaxError sono irrecuperabili nel contesto che le ha create: possono essere intercettate solo da altri contesti.

Classe: `SystemError`

Estende: <errors.Error>

Node.js genera errori di sistema quando si verificano eccezioni all'interno del suo ambiente di runtime. Questi si verificano di solito quando un'applicazione viola un vincolo del sistema operativo. Ad esempio, si verificherà un errore di sistema se un'applicazione tenta di leggere un file che non esiste.

address <stringa> Se presente, l'indirizzo a cui una connessione di rete non è riuscita
code <stringa> Il codice di errore stringa
dest <stringa> Se presente, il percorso del file di destinazione quando si segnala un errore del file system
errno <numero> Il numero di errore fornito dal sistema
info <Oggetto> Se presente, dettagli extra sulla condizione di errore
message <stringa> Una descrizione leggibile dall'uomo fornita dal sistema dell'errore
path <stringa> Se presente, il percorso del file quando si segnala un errore del file system
port <numero> Se presente, la porta di connessione di rete che non è disponibile
syscall <stringa> Il nome della chiamata di sistema che ha attivato l'errore

`error.address`

<stringa>

Se presente, error.address è una stringa che descrive l'indirizzo a cui una connessione di rete non è riuscita.

`error.code`

<stringa>

La proprietà error.code è una stringa che rappresenta il codice di errore.

`error.dest`

<stringa>

Se presente, error.dest è il percorso del file di destinazione quando si segnala un errore del file system.

`error.errno`

<numero>

La proprietà error.errno è un numero negativo che corrisponde al codice di errore definito in Gestione degli errori di libuv.

Su Windows, il numero di errore fornito dal sistema verrà normalizzato da libuv.

Per ottenere la rappresentazione in stringa del codice di errore, usa util.getSystemErrorName(error.errno).

`error.info`

<Oggetto>

Se presente, error.info è un oggetto con dettagli sulla condizione di errore.

`error.message`

<stringa>

error.message è una descrizione leggibile dall'uomo fornita dal sistema dell'errore.

`error.path`

<stringa>

Se presente, error.path è una stringa contenente un percorso non valido pertinente.

`error.port`

<numero>

Se presente, error.port è la porta di connessione di rete che non è disponibile.

`error.syscall`

<stringa>

La proprietà error.syscall è una stringa che descrive la syscall che non è riuscita.

Errori di sistema comuni

Questo è un elenco di errori di sistema che si incontrano comunemente quando si scrive un programma Node.js. Per un elenco completo, consultare la pagina man errno(3).

EACCES (Permesso negato): È stato fatto un tentativo di accedere a un file in un modo proibito dalle sue autorizzazioni di accesso al file.
EADDRINUSE (Indirizzo già in uso): Un tentativo di associare un server (net, http o https) a un indirizzo locale non è riuscito a causa di un altro server sul sistema locale che già occupa tale indirizzo.
ECONNREFUSED (Connessione rifiutata): Non è stato possibile stabilire una connessione perché la macchina di destinazione l'ha rifiutata attivamente. Ciò di solito deriva dal tentativo di connettersi a un servizio inattivo sull'host straniero.
ECONNRESET (Connessione ripristinata dal peer): Una connessione è stata chiusa forzatamente da un peer. Ciò normalmente deriva da una perdita di connessione sul socket remoto a causa di un timeout o di un riavvio. Comunemente incontrato tramite i moduli http e net.
EEXIST (File esistente): Un file esistente era l'obiettivo di un'operazione che richiedeva che l'obiettivo non esistesse.
EISDIR (È una directory): Un'operazione si aspettava un file, ma il percorso specificato era una directory.
EMFILE (Troppi file aperti nel sistema): È stato raggiunto il numero massimo di descrittori di file consentiti sul sistema e le richieste per un altro descrittore non possono essere soddisfatte fino a quando almeno uno non è stato chiuso. Ciò si verifica quando si aprono molti file contemporaneamente in parallelo, in particolare sui sistemi (in particolare macOS) in cui esiste un limite basso di descrittori di file per i processi. Per rimediare a un limite basso, eseguire ulimit -n 2048 nella stessa shell che eseguirà il processo Node.js.
ENOENT (Nessun file o directory): Comunemente sollevato dalle operazioni fs per indicare che un componente del percorso specificato non esiste. Nessuna entità (file o directory) è stata trovata dal percorso specificato.
ENOTDIR (Non è una directory): Un componente del percorso specificato esisteva, ma non era una directory come previsto. Comunemente sollevato da fs.readdir.
ENOTEMPTY (Directory non vuota): Una directory con voci era l'obiettivo di un'operazione che richiede una directory vuota, di solito fs.unlink.
ENOTFOUND (Ricerca DNS non riuscita): Indica un errore DNS di EAI_NODATA o EAI_NONAME. Questo non è un errore POSIX standard.
EPERM (Operazione non consentita): È stato fatto un tentativo di eseguire un'operazione che richiede privilegi elevati.
EPIPE (Pipe interrotta): Una scrittura su una pipe, socket o FIFO per cui non esiste un processo per leggere i dati. Comunemente incontrato nei livelli net e http, indicativo del fatto che il lato remoto del flusso su cui si sta scrivendo è stato chiuso.
ETIMEDOUT (Operazione scaduta): Una richiesta di connessione o di invio non è riuscita perché la parte connessa non ha risposto correttamente dopo un certo periodo di tempo. Solitamente incontrato da http o net. Spesso un segno che socket.end() non è stato chiamato correttamente.

Classe: `TypeError`

Estende <errors.Error>

Indica che un argomento fornito non è di un tipo consentito. Ad esempio, passare una funzione a un parametro che si aspetta una stringa risulterebbe in un TypeError.

require('node:url').parse(() => { });
// Lancia TypeError, dato che si aspettava una stringa.

Node.js genererà e lancerà istanze di TypeError immediatamente come forma di validazione degli argomenti.

Eccezioni vs. errori

Un'eccezione JavaScript è un valore che viene lanciato come risultato di un'operazione non valida o come obiettivo di un'istruzione throw. Sebbene non sia richiesto che questi valori siano istanze di Error o classi che ereditano da Error, tutte le eccezioni lanciate da Node.js o dal runtime JavaScript saranno istanze di Error.

Alcune eccezioni sono irrecuperabili a livello JavaScript. Tali eccezioni causeranno sempre l'arresto anomalo del processo Node.js. Esempi includono i controlli assert() o le chiamate abort() nel livello C++.

Errori OpenSSL

Gli errori che hanno origine in crypto o tls sono di classe Error e, oltre alle proprietà standard .code e .message, possono avere alcune proprietà aggiuntive specifiche di OpenSSL.

`error.opensslErrorStack`

Un array di errori che possono fornire un contesto sull'origine di un errore all'interno della libreria OpenSSL.

`error.function`

La funzione OpenSSL in cui ha origine l'errore.

`error.library`

La libreria OpenSSL in cui ha origine l'errore.

`error.reason`

Una stringa leggibile che descrive il motivo dell'errore.

Codici di errore Node.js

`ABORT_ERR`

Aggiunto in: v15.0.0

Usato quando un'operazione è stata interrotta (in genere usando un AbortController).

Le API che non utilizzano AbortSignal in genere non sollevano un errore con questo codice.

Questo codice non utilizza la convenzione regolare ERR_* che gli errori di Node.js usano per essere compatibile con AbortError della piattaforma web.

`ERR_ACCESS_DENIED`

Un tipo speciale di errore che viene attivato ogni volta che Node.js tenta di ottenere l'accesso a una risorsa limitata dal Modello di autorizzazioni.

`ERR_AMBIGUOUS_ARGUMENT`

Un argomento di una funzione viene utilizzato in un modo che suggerisce che la firma della funzione potrebbe essere fraintesa. Viene generato dal modulo node:assert quando il parametro message in assert.throws(block, message) corrisponde al messaggio di errore generato da block perché tale utilizzo suggerisce che l'utente crede che message sia il messaggio previsto piuttosto che il messaggio che AssertionError visualizzerà se block non genera.

`ERR_ARG_NOT_ITERABLE`

È stato richiesto un argomento iterabile (ovvero un valore che funziona con i loop for...of), ma non è stato fornito a un'API di Node.js.

`ERR_ASSERTION`

Un tipo speciale di errore che può essere attivato ogni volta che Node.js rileva una violazione della logica eccezionale che non dovrebbe mai verificarsi. Questi vengono sollevati tipicamente dal modulo node:assert.

`ERR_ASYNC_CALLBACK`

È stato fatto un tentativo di registrare qualcosa che non è una funzione come callback AsyncHooks.

`ERR_ASYNC_TYPE`

Il tipo di una risorsa asincrona non era valido. Gli utenti sono anche in grado di definire i propri tipi se utilizzano l'API embedder pubblica.

`ERR_BROTLI_COMPRESSION_FAILED`

I dati passati a uno stream Brotli non sono stati compressi correttamente.

`ERR_BROTLI_INVALID_PARAM`

È stata passata una chiave di parametro non valida durante la costruzione di uno stream Brotli.

`ERR_BUFFER_CONTEXT_NOT_AVAILABLE`

È stato fatto un tentativo di creare un'istanza di Buffer di Node.js da un addon o codice embedder, mentre in un contesto del motore JS che non è associato a un'istanza di Node.js. I dati passati al metodo Buffer saranno stati rilasciati al momento della restituzione del metodo.

Quando si verifica questo errore, una possibile alternativa alla creazione di un'istanza Buffer è creare un normale Uint8Array, che differisce solo nel prototipo dell'oggetto risultante. Gli Uint8Array sono generalmente accettati in tutte le API principali di Node.js dove sono presenti i Buffer; sono disponibili in tutti i contesti.

`ERR_BUFFER_OUT_OF_BOUNDS`

È stato tentato un'operazione al di fuori dei limiti di un Buffer.

`ERR_BUFFER_TOO_LARGE`

È stato fatto un tentativo di creare un Buffer più grande della dimensione massima consentita.

`ERR_CANNOT_WATCH_SIGINT`

Node.js non è stato in grado di monitorare il segnale SIGINT.

`ERR_CHILD_CLOSED_BEFORE_REPLY`

Un processo figlio è stato chiuso prima che il processo padre ricevesse una risposta.

`ERR_CHILD_PROCESS_IPC_REQUIRED`

Utilizzato quando un processo figlio viene creato senza specificare un canale IPC.

`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`

Utilizzato quando il processo principale sta cercando di leggere dati da STDERR/STDOUT del processo figlio e la lunghezza dei dati è maggiore dell'opzione maxBuffer.

`ERR_CLOSED_MESSAGE_PORT`

[Cronologia]

Versione	Modifiche
v16.2.0, v14.17.1	Il messaggio di errore è stato reintrodotto.
v11.12.0	Il messaggio di errore è stato rimosso.
v10.5.0	Aggiunto in: v10.5.0

C'è stato un tentativo di utilizzare un'istanza MessagePort in uno stato chiuso, di solito dopo che è stato chiamato .close().

`ERR_CONSOLE_WRITABLE_STREAM`

Console è stato istanziato senza flusso stdout, oppure Console ha un flusso stdout o stderr non scrivibile.

`ERR_CONSTRUCT_CALL_INVALID`

Aggiunto in: v12.5.0

È stato chiamato un costruttore di classe che non è invocabile.

`ERR_CONSTRUCT_CALL_REQUIRED`

Un costruttore per una classe è stato chiamato senza new.

`ERR_CONTEXT_NOT_INITIALIZED`

Il contesto vm passato all'API non è ancora inizializzato. Ciò può accadere quando si verifica (e viene intercettato) un errore durante la creazione del contesto, ad esempio, quando l'allocazione fallisce o viene raggiunta la dimensione massima dello stack di chiamate quando viene creato il contesto.

`ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED`

È stato richiesto un motore OpenSSL (ad esempio, tramite le opzioni TLS clientCertEngine o privateKeyEngine) che non è supportato dalla versione di OpenSSL in uso, probabilmente a causa del flag in fase di compilazione OPENSSL_NO_ENGINE.

`ERR_CRYPTO_ECDH_INVALID_FORMAT`

È stato passato un valore non valido per l'argomento format al metodo getPublicKey() della classe crypto.ECDH().

`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY`

È stato passato un valore non valido per l'argomento key al metodo computeSecret() della classe crypto.ECDH(). Significa che la chiave pubblica si trova al di fuori della curva ellittica.

`ERR_CRYPTO_ENGINE_UNKNOWN`

Un identificatore del motore di crittografia non valido è stato passato a require('node:crypto').setEngine().

`ERR_CRYPTO_FIPS_FORCED`

L'argomento della riga di comando --force-fips è stato utilizzato ma c'è stato un tentativo di abilitare o disabilitare la modalità FIPS nel modulo node:crypto.

`ERR_CRYPTO_FIPS_UNAVAILABLE`

È stato fatto un tentativo di abilitare o disabilitare la modalità FIPS, ma la modalità FIPS non era disponibile.

`ERR_CRYPTO_HASH_FINALIZED`

hash.digest() è stato chiamato più volte. Il metodo hash.digest() deve essere chiamato non più di una volta per istanza di un oggetto Hash.

`ERR_CRYPTO_HASH_UPDATE_FAILED`

hash.update() non è riuscito per qualsiasi motivo. Questo dovrebbe accadere raramente, se non mai.

`ERR_CRYPTO_INCOMPATIBLE_KEY`

Le chiavi crittografiche fornite sono incompatibili con l'operazione tentata.

`ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS`

La codifica della chiave pubblica o privata selezionata è incompatibile con altre opzioni.

`ERR_CRYPTO_INITIALIZATION_FAILED`

Aggiunto in: v15.0.0

L'inizializzazione del sottosistema di crittografia non è riuscita.

`ERR_CRYPTO_INVALID_AUTH_TAG`

Aggiunto in: v15.0.0

È stato fornito un tag di autenticazione non valido.

`ERR_CRYPTO_INVALID_COUNTER`

Aggiunto in: v15.0.0

È stato fornito un contatore non valido per una cifra in modalità contatore.

`ERR_CRYPTO_INVALID_CURVE`

Aggiunto in: v15.0.0

È stata fornita una curva ellittica non valida.

Il tipo dell'oggetto chiave crittografica fornito non è valido per l'operazione tentata.

`ERR_CRYPTO_INVALID_MESSAGELEN`

Aggiunto in: v15.0.0

È stata fornita una lunghezza del messaggio non valida.

`ERR_CRYPTO_INVALID_SCRYPT_PARAMS`

Node.js è stato compilato senza il supporto scrypt. Non è possibile con i binari di rilascio ufficiali, ma può accadere con build personalizzate, incluse le build di distribuzione.

`ERR_CRYPTO_SIGN_KEY_REQUIRED`

Una key di firma non è stata fornita al metodo sign.sign().

`ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH`

crypto.timingSafeEqual() è stato chiamato con argomenti Buffer, TypedArray o DataView di lunghezze diverse.

`ERR_CRYPTO_UNKNOWN_CIPHER`

È stata specificata una cifratura sconosciuta.

`ERR_CRYPTO_UNKNOWN_DH_GROUP`

È stato fornito un nome di gruppo Diffie-Hellman sconosciuto. Vedere crypto.getDiffieHellman() per un elenco di nomi di gruppo validi.

`ERR_CRYPTO_UNSUPPORTED_OPERATION`

Aggiunto in: v15.0.0, v14.18.0

È stato effettuato un tentativo di invocare un'operazione crittografica non supportata.

`ERR_DEBUGGER_ERROR`

Aggiunto in: v16.4.0, v14.17.4

Si è verificato un errore con il debugger.

`ERR_DEBUGGER_STARTUP_ERROR`

Aggiunto in: v16.4.0, v14.17.4

Il debugger è andato in timeout in attesa che l'host/porta richiesto fosse libero.

`ERR_DIR_CLOSED`

Il fs.Dir è stato precedentemente chiuso.

`ERR_DIR_CONCURRENT_OPERATION`

Aggiunto in: v14.3.0

È stato tentato una chiamata sincrona di lettura o chiusura su un fs.Dir che ha operazioni asincrone in corso.

`ERR_DLOPEN_DISABLED`

Aggiunto in: v16.10.0, v14.19.0

Il caricamento degli addon nativi è stato disabilitato utilizzando --no-addons.

`ERR_DLOPEN_FAILED`

Aggiunto in: v15.0.0

Una chiamata a process.dlopen() è fallita.

`ERR_DNS_SET_SERVERS_FAILED`

c-ares non è riuscito a impostare il server DNS.

`ERR_DOMAIN_CALLBACK_NOT_AVAILABLE`

Il modulo node:domain non era utilizzabile poiché non è stato in grado di stabilire gli hook di gestione degli errori richiesti, perché process.setUncaughtExceptionCaptureCallback() era stato chiamato in un momento precedente.

`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`

process.setUncaughtExceptionCaptureCallback() non è stato possibile chiamarlo perché il modulo node:domain è stato caricato in un momento precedente.

La traccia dello stack è estesa per includere il momento in cui il modulo node:domain era stato caricato.

`ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION`

v8.startupSnapshot.setDeserializeMainFunction() non è stato possibile chiamarlo perché era già stato chiamato in precedenza.

`ERR_ENCODING_INVALID_ENCODED_DATA`

I dati forniti all'API TextDecoder() non erano validi secondo la codifica fornita.

`ERR_ENCODING_NOT_SUPPORTED`

La codifica fornita all'API TextDecoder() non era una delle Codifiche supportate da WHATWG.

`ERR_EVAL_ESM_CANNOT_PRINT`

--print non può essere utilizzato con input ESM.

`ERR_EVENT_RECURSION`

Generato quando si tenta di inviare ricorsivamente un evento su EventTarget.

`ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE`

Il contesto di esecuzione JS non è associato a un ambiente Node.js. Ciò può verificarsi quando Node.js viene utilizzato come libreria incorporata e alcuni hook per il motore JS non sono configurati correttamente.

`ERR_FALSY_VALUE_REJECTION`

Una Promise che è stata callbackizzata tramite util.callbackify() è stata rifiutata con un valore falsy.

`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`

Aggiunto in: v14.0.0

È stato effettuato un tentativo di copiare in un tipo di file sconosciuto con fs.cp().

`ERR_FS_EISDIR`

Il percorso è una directory.

`ERR_FS_FILE_TOO_LARGE`

È stato effettuato un tentativo di leggere un file la cui dimensione è maggiore della dimensione massima consentita per un Buffer.

`ERR_HTTP2_ALTSVC_INVALID_ORIGIN`

I frame HTTP/2 ALTSVC richiedono un'origine valida.

`ERR_HTTP2_ALTSVC_LENGTH`

I frame HTTP/2 ALTSVC sono limitati a un massimo di 16.382 byte di payload.

`ERR_HTTP2_CONNECT_AUTHORITY`

Per le richieste HTTP/2 che utilizzano il metodo CONNECT, è richiesto lo pseudo-header :authority.

`ERR_HTTP2_CONNECT_PATH`

Per le richieste HTTP/2 che utilizzano il metodo CONNECT, lo pseudo-header :path è proibito.

`ERR_HTTP2_CONNECT_SCHEME`

Per le richieste HTTP/2 che utilizzano il metodo CONNECT, lo pseudo-header :scheme è proibito.

`ERR_HTTP2_ERROR`

Si è verificato un errore HTTP/2 non specifico.

`ERR_HTTP2_GOAWAY_SESSION`

Nuovi Stream HTTP/2 non possono essere aperti dopo che la Http2Session ha ricevuto un frame GOAWAY dal peer connesso.

`ERR_HTTP2_HEADERS_AFTER_RESPOND`

Sono stati specificati header aggiuntivi dopo che è stata avviata una risposta HTTP/2.

`ERR_HTTP2_HEADERS_SENT`

È stato effettuato un tentativo di inviare più header di risposta.

`ERR_HTTP2_HEADER_SINGLE_VALUE`

Sono stati forniti più valori per un campo header HTTP/2 che doveva avere un solo valore.

`ERR_HTTP2_INFO_STATUS_NOT_ALLOWED`

I codici di stato HTTP informativi (1xx) non possono essere impostati come codice di stato di risposta sulle risposte HTTP/2.

`ERR_HTTP2_INVALID_CONNECTION_HEADERS`

Gli header specifici della connessione HTTP/1 sono vietati per l'uso in richieste e risposte HTTP/2.

`ERR_HTTP2_INVALID_HEADER_VALUE`

È stato specificato un valore di header HTTP/2 non valido.

`ERR_HTTP2_INVALID_INFO_STATUS`

È stato specificato un codice di stato informativo HTTP non valido. I codici di stato informativi devono essere un numero intero compreso tra 100 e 199 (inclusi).

`ERR_HTTP2_INVALID_ORIGIN`

I frame HTTP/2 ORIGIN richiedono un'origine valida.

`ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH`

Le istanze Buffer e Uint8Array passate all'API http2.getUnpackedSettings() devono avere una lunghezza multipla di sei.

`ERR_HTTP2_INVALID_PSEUDOHEADER`

Possono essere utilizzati solo pseudoheader HTTP/2 validi (:status, :path, :authority, :scheme e :method).

`ERR_HTTP2_INVALID_SESSION`

È stata eseguita un'azione su un oggetto Http2Session che era già stato distrutto.

`ERR_HTTP2_INVALID_SETTING_VALUE`

È stato specificato un valore non valido per un'impostazione HTTP/2.

`ERR_HTTP2_INVALID_STREAM`

È stata eseguita un'operazione su un flusso che era già stato distrutto.

`ERR_HTTP2_MAX_PENDING_SETTINGS_ACK`

Ogni volta che viene inviato un frame SETTINGS HTTP/2 a un peer connesso, il peer è tenuto a inviare un riconoscimento di aver ricevuto e applicato le nuove SETTINGS. Per impostazione predefinita, è possibile inviare un numero massimo di frame SETTINGS non riconosciuti in un dato momento. Questo codice di errore viene utilizzato quando tale limite è stato raggiunto.

`ERR_HTTP2_NESTED_PUSH`

È stato effettuato un tentativo di avviare un nuovo stream push dall'interno di uno stream push. Gli stream push nidificati non sono consentiti.

`ERR_HTTP2_NO_MEM`

Memoria insufficiente durante l'utilizzo dell'API http2session.setLocalWindowSize(windowSize).

`ERR_HTTP2_NO_SOCKET_MANIPULATION`

È stato effettuato un tentativo di manipolare direttamente (leggere, scrivere, mettere in pausa, riprendere, ecc.) un socket collegato a una Http2Session.

`ERR_HTTP2_ORIGIN_LENGTH`

I frame HTTP/2 ORIGIN sono limitati a una lunghezza di 16382 byte.

`ERR_HTTP2_OUT_OF_STREAMS`

Il numero di stream creati su una singola sessione HTTP/2 ha raggiunto il limite massimo.

`ERR_HTTP2_PAYLOAD_FORBIDDEN`

È stato specificato un payload del messaggio per un codice di risposta HTTP per il quale un payload è vietato.

`ERR_HTTP2_PING_CANCEL`

Un ping HTTP/2 è stato annullato.

`ERR_HTTP2_PING_LENGTH`

I payload dei ping HTTP/2 devono essere esattamente di 8 byte.

`ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED`

È stato utilizzato impropriamente un pseudo-header HTTP/2. Gli pseudo-header sono nomi di chiavi di header che iniziano con il prefisso :.

`ERR_HTTP2_PUSH_DISABLED`

È stato effettuato un tentativo di creare uno stream push, che era stato disabilitato dal client.

`ERR_HTTP2_SEND_FILE`

È stato effettuato un tentativo di utilizzare l'API Http2Stream.prototype.responseWithFile() per inviare una directory.

`ERR_HTTP2_SEND_FILE_NOSEEK`

È stato effettuato un tentativo di utilizzare l'API Http2Stream.prototype.responseWithFile() per inviare qualcosa di diverso da un file regolare, ma sono state fornite le opzioni offset o length.

`ERR_HTTP2_SESSION_ERROR`

La Http2Session è stata chiusa con un codice di errore diverso da zero.

`ERR_HTTP2_SETTINGS_CANCEL`

Le impostazioni Http2Session sono state annullate.

`ERR_HTTP2_SOCKET_BOUND`

È stato effettuato un tentativo di connettere un oggetto Http2Session a un net.Socket o tls.TLSSocket che era già stato associato a un altro oggetto Http2Session.

`ERR_HTTP2_SOCKET_UNBOUND`

È stato effettuato un tentativo di utilizzare la proprietà socket di una Http2Session che è già stata chiusa.

`ERR_HTTP2_STATUS_101`

L'uso del codice di stato informativo 101 è vietato in HTTP/2.

`ERR_HTTP2_STATUS_INVALID`

È stato specificato un codice di stato HTTP non valido. I codici di stato devono essere un intero compreso tra 100 e 599 (inclusi).

`ERR_HTTP2_STREAM_CANCEL`

Un Http2Stream è stato distrutto prima che qualsiasi dato fosse trasmesso al peer connesso.

`ERR_HTTP2_STREAM_ERROR`

È stato specificato un codice di errore diverso da zero in un frame RST_STREAM.

`ERR_HTTP2_STREAM_SELF_DEPENDENCY`

Quando si imposta la priorità per un flusso HTTP/2, il flusso può essere contrassegnato come dipendenza per un flusso padre. Questo codice di errore viene utilizzato quando si tenta di contrassegnare un flusso e dipendente da se stesso.

`ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS`

È stato superato il numero di impostazioni personalizzate supportate (10).

`ERR_HTTP2_TOO_MANY_INVALID_FRAMES`

Aggiunta in: v15.14.0

È stato superato il limite di frame di protocollo HTTP/2 non validi accettabili inviati dal peer, come specificato tramite l'opzione maxSessionInvalidFrames.

`ERR_HTTP2_TRAILERS_ALREADY_SENT`

I trailer di intestazione sono già stati inviati sull'Http2Stream.

`ERR_HTTP2_TRAILERS_NOT_READY`

Il metodo http2stream.sendTrailers() non può essere chiamato finché non viene emesso l'evento 'wantTrailers' su un oggetto Http2Stream. L'evento 'wantTrailers' verrà emesso solo se l'opzione waitForTrailers è impostata per l'Http2Stream.

`ERR_HTTP2_UNSUPPORTED_PROTOCOL`

A http2.connect() è stato passato un URL che utilizza qualsiasi protocollo diverso da http: o https:.

`ERR_HTTP_BODY_NOT_ALLOWED`

Viene generato un errore quando si scrive su una risposta HTTP che non consente contenuti.

`ERR_HTTP_CONTENT_LENGTH_MISMATCH`

La dimensione del body della risposta non corrisponde al valore dell'header content-length specificato.

`ERR_HTTP_HEADERS_SENT`

È stato effettuato un tentativo di aggiungere più header dopo che gli header erano già stati inviati.

`ERR_HTTP_INVALID_HEADER_VALUE`

È stato specificato un valore di header HTTP non valido.

`ERR_HTTP_INVALID_STATUS_CODE`

Il codice di stato era al di fuori dell'intervallo di codici di stato regolari (100-999).

`ERR_HTTP_REQUEST_TIMEOUT`

Il client non ha inviato l'intera richiesta entro il tempo consentito.

`ERR_HTTP_SOCKET_ASSIGNED`

Alla ServerResponse fornita era già stato assegnato un socket.

`ERR_HTTP_SOCKET_ENCODING`

La modifica della codifica del socket non è consentita secondo la RFC 7230 Sezione 3.

`ERR_HTTP_TRAILER_INVALID`

L'header Trailer è stato impostato anche se la codifica di trasferimento non lo supporta.

`ERR_ILLEGAL_CONSTRUCTOR`

È stato effettuato un tentativo di costruire un oggetto utilizzando un costruttore non pubblico.

`ERR_IMPORT_ATTRIBUTE_MISSING`

Aggiunta in: v21.1.0

Manca un attributo di importazione, impedendo l'importazione del modulo specificato.

`ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE`

Aggiunto in: v21.1.0

È stato fornito un attributo type di importazione, ma il modulo specificato è di un tipo diverso.

`ERR_IMPORT_ATTRIBUTE_UNSUPPORTED`

Aggiunto in: v21.0.0, v20.10.0, v18.19.0

Un attributo di importazione non è supportato da questa versione di Node.js.

`ERR_INCOMPATIBLE_OPTION_PAIR`

Una coppia di opzioni è incompatibile tra loro e non può essere utilizzata contemporaneamente.

`ERR_INPUT_TYPE_NOT_ALLOWED`

[Stable: 1 - Sperimentale]

Stabile: 1 Stabilità: 1 - Sperimentale

Il flag --input-type è stato utilizzato per tentare di eseguire un file. Questo flag può essere utilizzato solo con input tramite --eval, --print o STDIN.

`ERR_INSPECTOR_ALREADY_ACTIVATED`

Durante l'utilizzo del modulo node:inspector, è stato fatto un tentativo di attivare l'inspector quando aveva già iniziato ad ascoltare su una porta. Usa inspector.close() prima di attivarlo su un indirizzo diverso.

`ERR_INSPECTOR_ALREADY_CONNECTED`

Durante l'utilizzo del modulo node:inspector, è stato fatto un tentativo di connettersi quando l'inspector era già connesso.

`ERR_INSPECTOR_CLOSED`

Durante l'utilizzo del modulo node:inspector, è stato fatto un tentativo di utilizzare l'inspector dopo che la sessione era già stata chiusa.

`ERR_INSPECTOR_COMMAND`

Si è verificato un errore durante l'esecuzione di un comando tramite il modulo node:inspector.

`ERR_INSPECTOR_NOT_ACTIVE`

L'inspector non è attivo quando viene chiamato inspector.waitForDebugger().

`ERR_INSPECTOR_NOT_AVAILABLE`

Il modulo node:inspector non è disponibile per l'uso.

`ERR_INSPECTOR_NOT_CONNECTED`

Durante l'utilizzo del modulo node:inspector, è stato fatto un tentativo di utilizzare l'inspector prima che fosse connesso.

`ERR_INSPECTOR_NOT_WORKER`

È stata chiamata un'API nel thread principale che può essere utilizzata solo dal thread worker.

`ERR_INTERNAL_ASSERTION`

C'è stato un bug in Node.js o un uso errato dei componenti interni di Node.js. Per correggere l'errore, apri un problema all'indirizzo https://github.com/nodejs/node/issues.

`ERR_INVALID_ADDRESS`

L'indirizzo fornito non è riconosciuto dall'API di Node.js.

`ERR_INVALID_ADDRESS_FAMILY`

La famiglia di indirizzi fornita non è riconosciuta dall'API di Node.js.

`ERR_INVALID_ARG_TYPE`

Un argomento del tipo sbagliato è stato passato a un'API di Node.js.

`ERR_INVALID_ARG_VALUE`

Un valore non valido o non supportato è stato passato per un determinato argomento.

`ERR_INVALID_ASYNC_ID`

Un asyncId o triggerAsyncId non valido è stato passato usando AsyncHooks. Un id inferiore a -1 non dovrebbe mai accadere.

`ERR_INVALID_BUFFER_SIZE`

È stato eseguito uno swap su un Buffer, ma la sua dimensione non era compatibile con l'operazione.

`ERR_INVALID_CHAR`

Sono stati rilevati caratteri non validi negli header.

`ERR_INVALID_CURSOR_POS`

Un cursore su un determinato stream non può essere spostato in una riga specificata senza una colonna specificata.

`ERR_INVALID_FD`

Un descrittore di file ('fd') non era valido (ad esempio, era un valore negativo).

`ERR_INVALID_FD_TYPE`

Un tipo di descrittore di file ('fd') non era valido.

`ERR_INVALID_FILE_URL_HOST`

Un'API di Node.js che consuma URL file: (come alcune funzioni nel modulo fs) ha incontrato un URL file con un host incompatibile. Questa situazione può verificarsi solo su sistemi di tipo Unix in cui sono supportati solo localhost o un host vuoto.

`ERR_INVALID_FILE_URL_PATH`

Un'API di Node.js che consuma URL file: (come alcune funzioni nel modulo fs) ha incontrato un URL file con un percorso incompatibile. La semantica esatta per determinare se un percorso può essere utilizzato dipende dalla piattaforma.

`ERR_INVALID_HANDLE_TYPE`

È stato effettuato un tentativo di inviare un "handle" non supportato su un canale di comunicazione IPC a un processo figlio. Vedere subprocess.send() e process.send() per maggiori informazioni.

`ERR_INVALID_HTTP_TOKEN`

È stato fornito un token HTTP non valido.

`ERR_INVALID_IP_ADDRESS`

Un indirizzo IP non è valido.

`ERR_INVALID_MIME_SYNTAX`

La sintassi di un MIME non è valida.

`ERR_INVALID_MODULE`

Aggiunto in: v15.0.0, v14.18.0

È stato fatto un tentativo di caricare un modulo inesistente o non valido.

`ERR_INVALID_MODULE_SPECIFIER`

La stringa del modulo importato è un URL, un nome di pacchetto o uno specificatore di sottopercorso del pacchetto non valido.

`ERR_INVALID_OBJECT_DEFINE_PROPERTY`

Si è verificato un errore durante l'impostazione di un attributo non valido sulla proprietà di un oggetto.

`ERR_INVALID_PACKAGE_CONFIG`

Un file package.json non valido non è stato analizzato correttamente.

`ERR_INVALID_PACKAGE_TARGET`

Il campo "exports" di package.json contiene un valore di mappatura di destinazione non valido per la risoluzione del modulo tentata.

`ERR_INVALID_PROTOCOL`

Un options.protocol non valido è stato passato a http.request().

`ERR_INVALID_REPL_EVAL_CONFIG`

Sono state impostate sia l'opzione breakEvalOnSigint che l'opzione eval nella configurazione REPL, cosa non supportata.

`ERR_INVALID_REPL_INPUT`

L'input non può essere utilizzato in REPL. Le condizioni in cui viene utilizzato questo errore sono descritte nella documentazione REPL.

`ERR_INVALID_RETURN_PROPERTY`

Generato nel caso in cui un'opzione di funzione non fornisca un valore valido per una delle proprietà dell'oggetto restituito durante l'esecuzione.

`ERR_INVALID_RETURN_PROPERTY_VALUE`

Generato nel caso in cui un'opzione di funzione non fornisca un tipo di valore previsto per una delle proprietà dell'oggetto restituito durante l'esecuzione.

`ERR_INVALID_RETURN_VALUE`

Generato nel caso in cui un'opzione di funzione non restituisca un tipo di valore previsto durante l'esecuzione, ad esempio quando una funzione dovrebbe restituire una promise.

`ERR_INVALID_STATE`

Aggiunto in: v15.0.0

Indica che un'operazione non può essere completata a causa di uno stato non valido. Ad esempio, un oggetto potrebbe essere già stato distrutto o potrebbe essere in corso un'altra operazione.

`ERR_INVALID_SYNC_FORK_INPUT`

Un Buffer, TypedArray, DataView o string è stato fornito come input stdio a un fork asincrono. Vedere la documentazione del modulo child_process per maggiori informazioni.

`ERR_INVALID_THIS`

Una funzione API di Node.js è stata chiamata con un valore this incompatibile.

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

const buf = Buffer.alloc(1);
urlSearchParams.has.call(buf, 'foo');
// Lancia un TypeError con codice 'ERR_INVALID_THIS'

`ERR_INVALID_TUPLE`

Un elemento nell'iterable fornito al URLSearchParams constructor WHATWG non rappresentava una tupla [name, value] – ovvero, se un elemento non è iterabile, o non consiste esattamente di due elementi.

`ERR_INVALID_TYPESCRIPT_SYNTAX`

Aggiunto in: v23.0.0

La sintassi TypeScript fornita non è valida o non è supportata. Questo potrebbe accadere quando si utilizza una sintassi TypeScript che richiede la trasformazione con lo stripping del tipo.

`ERR_INVALID_URI`

È stato passato un URI non valido.

`ERR_INVALID_URL`

Un URL non valido è stato passato al URL constructor WHATWG o al legacy url.parse() per essere analizzato. L'oggetto errore generato ha in genere una proprietà aggiuntiva 'input' che contiene l'URL che non è stato analizzato.

`ERR_INVALID_URL_SCHEME`

È stato fatto un tentativo di utilizzare un URL con uno schema (protocollo) incompatibile per uno scopo specifico. Viene utilizzato solo nel supporto WHATWG URL API nel modulo fs (che accetta solo URL con schema 'file'), ma potrebbe essere utilizzato anche in altre API di Node.js in futuro.

`ERR_IPC_CHANNEL_CLOSED`

È stato fatto un tentativo di utilizzare un canale di comunicazione IPC che era già chiuso.

`ERR_IPC_DISCONNECTED`

È stato fatto un tentativo di disconnettere un canale di comunicazione IPC che era già disconnesso. Vedere la documentazione per il modulo child_process per maggiori informazioni.

`ERR_IPC_ONE_PIPE`

È stato fatto un tentativo di creare un processo figlio Node.js utilizzando più di un canale di comunicazione IPC. Vedere la documentazione per il modulo child_process per maggiori informazioni.

`ERR_IPC_SYNC_FORK`

È stato effettuato un tentativo di aprire un canale di comunicazione IPC con un processo Node.js forchettato sincronicamente. Per maggiori informazioni, consulta la documentazione del modulo child_process.

`ERR_IP_BLOCKED`

L'IP è bloccato da net.BlockList.

`ERR_LOADER_CHAIN_INCOMPLETE`

Aggiunto in: v18.6.0, v16.17.0

Un hook del caricatore ESM è tornato senza chiamare next() e senza segnalare esplicitamente un cortocircuito.

`ERR_LOAD_SQLITE_EXTENSION`

Aggiunto in: v23.5.0

Si è verificato un errore durante il caricamento di un'estensione SQLite.

`ERR_MEMORY_ALLOCATION_FAILED`

È stato effettuato un tentativo di allocare memoria (solitamente nel livello C++) ma non è riuscito.

`ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE`

Aggiunto in: v14.5.0, v12.19.0

Un messaggio inviato a una MessagePort non è stato deserializzato nel vm Context di destinazione. Non tutti gli oggetti Node.js possono essere istanziati con successo in qualsiasi contesto al momento, e tentare di trasferirli usando postMessage() può fallire sul lato ricevente in quel caso.

`ERR_METHOD_NOT_IMPLEMENTED`

Un metodo è richiesto ma non implementato.

`ERR_MISSING_ARGS`

Un argomento richiesto di un'API Node.js non è stato passato. Questo viene utilizzato solo per la stretta conformità con le specifiche dell'API (che in alcuni casi possono accettare func(undefined) ma non func()). Nella maggior parte delle API native di Node.js, func(undefined) e func() sono trattate in modo identico e al loro posto può essere utilizzato il codice di errore ERR_INVALID_ARG_TYPE.

`ERR_MISSING_OPTION`

Per le API che accettano oggetti di opzioni, alcune opzioni potrebbero essere obbligatorie. Questo codice viene generato se manca un'opzione obbligatoria.

`ERR_MISSING_PASSPHRASE`

È stato effettuato un tentativo di leggere una chiave crittografata senza specificare una passphrase.

`ERR_MISSING_PLATFORM_FOR_WORKER`

La piattaforma V8 utilizzata da questa istanza di Node.js non supporta la creazione di Worker. Ciò è causato dalla mancanza di supporto dell'embedder per i Worker. In particolare, questo errore non si verificherà con le build standard di Node.js.

`ERR_MODULE_NOT_FOUND`

Un file di modulo non è stato risolto dal caricatore di moduli ECMAScript durante un'operazione di import o durante il caricamento del punto di ingresso del programma.

`ERR_MULTIPLE_CALLBACK`

Una callback è stata chiamata più di una volta.

Una callback è quasi sempre intesa per essere chiamata una sola volta poiché la query può essere soddisfatta o rifiutata, ma non entrambe contemporaneamente. Quest'ultimo sarebbe possibile chiamando una callback più di una volta.

`ERR_NAPI_CONS_FUNCTION`

Durante l'utilizzo di Node-API, un costruttore passato non era una funzione.

`ERR_NAPI_INVALID_DATAVIEW_ARGS`

Durante la chiamata a napi_create_dataview(), un determinato offset era al di fuori dei limiti della dataview o offset + length era maggiore della lunghezza del buffer fornito.

`ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT`

Durante la chiamata a napi_create_typedarray(), l'offset fornito non era un multiplo della dimensione dell'elemento.

`ERR_NAPI_INVALID_TYPEDARRAY_LENGTH`

Durante la chiamata a napi_create_typedarray(), (length * size_of_element) + byte_offset era maggiore della lunghezza del buffer fornito.

`ERR_NAPI_TSFN_CALL_JS`

Si è verificato un errore durante l'invocazione della porzione JavaScript della funzione thread-safe.

`ERR_NAPI_TSFN_GET_UNDEFINED`

Si è verificato un errore durante il tentativo di recuperare il valore JavaScript undefined.

`ERR_NON_CONTEXT_AWARE_DISABLED`

Un addon nativo non context-aware è stato caricato in un processo che li vieta.

`ERR_NOT_BUILDING_SNAPSHOT`

È stato fatto un tentativo di utilizzare operazioni che possono essere utilizzate solo quando si sta costruendo uno snapshot di avvio V8, anche se Node.js non ne sta costruendo uno.

`ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION`

Aggiunto in: v21.7.0, v20.12.0

L'operazione non può essere eseguita quando non si trova in un'applicazione eseguibile singola.

`ERR_NOT_SUPPORTED_IN_SNAPSHOT`

È stato fatto un tentativo di eseguire operazioni non supportate durante la creazione di uno snapshot di avvio.

`ERR_NO_CRYPTO`

È stato fatto un tentativo di utilizzare le funzionalità di crittografia mentre Node.js non è stato compilato con il supporto della crittografia OpenSSL.

`ERR_NO_ICU`

È stato effettuato un tentativo di utilizzare funzionalità che richiedono ICU, ma Node.js non è stato compilato con il supporto ICU.

`ERR_NO_TYPESCRIPT`

Aggiunto in: v23.0.0

È stato effettuato un tentativo di utilizzare funzionalità che richiedono il supporto nativo di TypeScript, ma Node.js non è stato compilato con il supporto TypeScript.

`ERR_OPERATION_FAILED`

Aggiunto in: v15.0.0

Un'operazione non è riuscita. Questo viene tipicamente usato per segnalare il fallimento generale di un'operazione asincrona.

`ERR_OUT_OF_RANGE`

Un valore dato è fuori dall'intervallo accettato.

`ERR_PACKAGE_IMPORT_NOT_DEFINED`

Il campo "imports" del package.json non definisce la mappatura dello specificatore di pacchetto interno dato.

`ERR_PACKAGE_PATH_NOT_EXPORTED`

Il campo "exports" del package.json non esporta il sottopercorso richiesto. Poiché le esportazioni sono incapsulate, i moduli interni privati che non vengono esportati non possono essere importati tramite la risoluzione del pacchetto, a meno che non si utilizzi un URL assoluto.

`ERR_PARSE_ARGS_INVALID_OPTION_VALUE`

Aggiunto in: v18.3.0, v16.17.0

Quando strict è impostato su true, lanciato da util.parseArgs() se viene fornito un valore <boolean> per un'opzione di tipo <string>, o se viene fornito un valore <string> per un'opzione di tipo <boolean>.

`ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL`

Aggiunto in: v18.3.0, v16.17.0

Lanciato da util.parseArgs(), quando viene fornito un argomento posizionale e allowPositionals è impostato su false.

`ERR_PARSE_ARGS_UNKNOWN_OPTION`

Aggiunto in: v18.3.0, v16.17.0

Quando strict è impostato su true, lanciato da util.parseArgs() se un argomento non è configurato in options.

`ERR_PERFORMANCE_INVALID_TIMESTAMP`

È stato fornito un valore di timestamp non valido per un contrassegno o una misurazione delle prestazioni.

`ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS`

Stabile: 1 Stabilità: 1 - Sperimentale

Quando si tenta di require() un Modulo ES, un collegamento CommonJS a ESM o ESM a CommonJS partecipa a un ciclo immediato. Questo non è consentito perché i Moduli ES non possono essere valutati mentre sono già in fase di valutazione.

Per evitare il ciclo, la chiamata require() coinvolta in un ciclo non dovrebbe avvenire al livello superiore di un Modulo ES (tramite createRequire()) o di un modulo CommonJS, e dovrebbe essere eseguita in modo lazy in una funzione interna.

`ERR_REQUIRE_ESM`

[Cronologia]

Versione	Modifiche
v23.0.0	require() ora supporta il caricamento di moduli ES sincroni per impostazione predefinita.

[Stabile: 0 - Deprecato]

Stabile: 0 Stabilità: 0 - Deprecato

È stato fatto un tentativo di require() un Modulo ES.

Questo errore è stato deprecato poiché require() ora supporta il caricamento di moduli ES sincroni. Quando require() incontra un modulo ES che contiene await di livello superiore, genererà invece ERR_REQUIRE_ASYNC_MODULE.

`ERR_SCRIPT_EXECUTION_INTERRUPTED`

L'esecuzione dello script è stata interrotta da SIGINT (ad esempio, è stato premuto +).

`ERR_SCRIPT_EXECUTION_TIMEOUT`

L'esecuzione dello script è scaduta, probabilmente a causa di bug nello script in esecuzione.

`ERR_SERVER_ALREADY_LISTEN`

Il metodo server.listen() è stato chiamato mentre un net.Server era già in ascolto. Questo vale per tutte le istanze di net.Server, incluse le istanze Server HTTP, HTTPS e HTTP/2.

`ERR_SERVER_NOT_RUNNING`

Il metodo server.close() è stato chiamato quando un net.Server non era in esecuzione. Questo si applica a tutte le istanze di net.Server, incluse le istanze Server HTTP, HTTPS e HTTP/2.

`ERR_SINGLE_EXECUTABLE_APPLICATION_ASSET_NOT_FOUND`

Aggiunto in: v21.7.0, v20.12.0

È stata passata una chiave alle API dell'applicazione eseguibile singola per identificare una risorsa, ma non è stata trovata alcuna corrispondenza.

`ERR_SOCKET_ALREADY_BOUND`

È stato fatto un tentativo di associare un socket che è già stato associato.

`ERR_SOCKET_BAD_BUFFER_SIZE`

È stata passata una dimensione non valida (negativa) per le opzioni recvBufferSize o sendBufferSize in dgram.createSocket().

`ERR_SOCKET_BAD_PORT`

Una funzione API che prevede una porta >= 0 e < 65536 ha ricevuto un valore non valido.

`ERR_SOCKET_BAD_TYPE`

Una funzione API che prevede un tipo di socket (udp4 o udp6) ha ricevuto un valore non valido.

`ERR_SOCKET_BUFFER_SIZE`

Durante l'utilizzo di dgram.createSocket(), non è stato possibile determinare la dimensione del Buffer di ricezione o di invio.

`ERR_SOCKET_CLOSED`

È stato fatto un tentativo di operare su un socket già chiuso.

`ERR_SOCKET_CLOSED_BEFORE_CONNECTION`

Quando si chiama net.Socket.write() su un socket in fase di connessione e il socket è stato chiuso prima che la connessione fosse stabilita.

`ERR_SOCKET_CONNECTION_TIMEOUT`

Il socket non è stato in grado di connettersi a nessun indirizzo restituito dal DNS entro il timeout consentito quando si utilizza l'algoritmo di autoselezione della famiglia.

`ERR_SOCKET_DGRAM_IS_CONNECTED`

È stata effettuata una chiamata a dgram.connect() su un socket già connesso.

`ERR_SOCKET_DGRAM_NOT_CONNECTED`

È stata effettuata una chiamata a dgram.disconnect() o dgram.remoteAddress() su un socket disconnesso.

`ERR_SOCKET_DGRAM_NOT_RUNNING`

È stata effettuata una chiamata e il sottosistema UDP non era in esecuzione.

`ERR_SOURCE_MAP_CORRUPT`

La source map non è stata analizzata perché non esiste o è corrotta.

`ERR_SOURCE_MAP_MISSING_SOURCE`

Un file importato da una source map non è stato trovato.

`ERR_SQLITE_ERROR`

Aggiunto in: v22.5.0

È stato restituito un errore da SQLite.

`ERR_SRI_PARSE`

È stata fornita una stringa per un controllo di Subresource Integrity, ma non è stato possibile analizzarla. Controllare il formato degli attributi di integrità consultando la specifica Subresource Integrity.

`ERR_STREAM_ALREADY_FINISHED`

È stato chiamato un metodo di stream che non può essere completato perché lo stream è stato terminato.

`ERR_STREAM_CANNOT_PIPE`

È stato fatto un tentativo di chiamare stream.pipe() su uno stream Writable.

`ERR_STREAM_DESTROYED`

È stato chiamato un metodo di stream che non può essere completato perché lo stream è stato distrutto utilizzando stream.destroy().

`ERR_STREAM_NULL_VALUES`

È stato fatto un tentativo di chiamare stream.write() con un chunk null.

`ERR_STREAM_PREMATURE_CLOSE`

Un errore restituito da stream.finished() e stream.pipeline(), quando uno stream o una pipeline termina in modo non corretto senza un errore esplicito.

`ERR_STREAM_PUSH_AFTER_EOF`

È stato fatto un tentativo di chiamare stream.push() dopo che un null (EOF) era stato inviato allo stream.

`ERR_STREAM_UNABLE_TO_PIPE`

È stato fatto un tentativo di inviare tramite pipe a uno stream chiuso o distrutto in una pipeline.

`ERR_STREAM_UNSHIFT_AFTER_END_EVENT`

È stato fatto un tentativo di chiamare stream.unshift() dopo che è stato emesso l'evento 'end'.

`ERR_STREAM_WRAP`

Impedisce un'interruzione se un decodificatore di stringhe è stato impostato sul Socket o se il decodificatore è in objectMode.

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

instance.setEncoding('utf8');

`ERR_STREAM_WRITE_AFTER_END`

È stato fatto un tentativo di chiamare stream.write() dopo che è stato chiamato stream.end().

`ERR_STRING_TOO_LONG`

È stato fatto un tentativo di creare una stringa più lunga della lunghezza massima consentita.

`ERR_SYNTHETIC`

Un oggetto errore artificiale utilizzato per acquisire lo stack di chiamate per i report diagnostici.

`ERR_SYSTEM_ERROR`

Si è verificato un errore di sistema non specificato o non specifico all'interno del processo Node.js. L'oggetto errore avrà una proprietà dell'oggetto err.info con dettagli aggiuntivi.

`ERR_TAP_LEXER_ERROR`

Un errore che rappresenta uno stato di lexer fallito.

`ERR_TAP_PARSER_ERROR`

Un errore che rappresenta uno stato di parser fallito. Ulteriori informazioni sul token che ha causato l'errore sono disponibili tramite la proprietà cause.

`ERR_TAP_VALIDATION_ERROR`

Questo errore rappresenta una convalida TAP fallita.

`ERR_TEST_FAILURE`

Questo errore rappresenta un test fallito. Ulteriori informazioni sul fallimento sono disponibili tramite la proprietà cause. La proprietà failureType specifica cosa stava facendo il test quando si è verificato il fallimento.

`ERR_TLS_ALPN_CALLBACK_INVALID_RESULT`

Questo errore viene generato quando un ALPNCallback restituisce un valore che non è nell'elenco dei protocolli ALPN offerti dal client.

`ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS`

Questo errore viene generato quando si crea un TLSServer se le opzioni TLS includono sia ALPNProtocols che ALPNCallback. Queste opzioni si escludono a vicenda.

`ERR_TLS_CERT_ALTNAME_FORMAT`

Questo errore viene generato da checkServerIdentity se una proprietà subjectaltname fornita dall'utente viola le regole di codifica. Gli oggetti certificato prodotti da Node.js stesso sono sempre conformi alle regole di codifica e non causano mai questo errore.

`ERR_TLS_CERT_ALTNAME_INVALID`

Durante l'utilizzo di TLS, il nome host/IP del peer non corrisponde a nessuno dei subjectAltNames nel suo certificato.

`ERR_TLS_DH_PARAM_SIZE`

Durante l'utilizzo di TLS, il parametro offerto per il protocollo di key-agreement Diffie-Hellman (DH) è troppo piccolo. Per impostazione predefinita, la lunghezza della chiave deve essere maggiore o uguale a 1024 bit per evitare vulnerabilità, anche se è fortemente consigliato utilizzare 2048 bit o più per una maggiore sicurezza.

`ERR_TLS_HANDSHAKE_TIMEOUT`

Un handshake TLS/SSL è scaduto. In questo caso, anche il server deve interrompere la connessione.

`ERR_TLS_INVALID_CONTEXT`

Aggiunto in: v13.3.0

Il contesto deve essere un SecureContext.

`ERR_TLS_INVALID_PROTOCOL_METHOD`

Il metodo secureProtocol specificato non è valido. O è sconosciuto o è disabilitato perché non è sicuro.

`ERR_TLS_INVALID_PROTOCOL_VERSION`

Le versioni del protocollo TLS valide sono 'TLSv1', 'TLSv1.1' o 'TLSv1.2'.

`ERR_TLS_INVALID_STATE`

Aggiunto in: v13.10.0, v12.17.0

Il socket TLS deve essere connesso e stabilito in modo sicuro. Assicurati che l'evento 'secure' venga emesso prima di continuare.

`ERR_TLS_PROTOCOL_VERSION_CONFLICT`

Il tentativo di impostare una versione TLS minVersion o maxVersion è in conflitto con un tentativo di impostare esplicitamente secureProtocol. Utilizzare un meccanismo o l'altro.

`ERR_TLS_PSK_SET_IDENTITY_HINT_FAILED`

Impossibile impostare il suggerimento per l'identità PSK. Il suggerimento potrebbe essere troppo lungo.

`ERR_TLS_RENEGOTIATION_DISABLED`

È stato effettuato un tentativo di rinegoziare TLS su un'istanza socket con la rinegoziazione disabilitata.

`ERR_TLS_REQUIRED_SERVER_NAME`

Durante l'utilizzo di TLS, il metodo server.addContext() è stato chiamato senza fornire un nome host nel primo parametro.

`ERR_TLS_SESSION_ATTACK`

Viene rilevata una quantità eccessiva di rinegoziazioni TLS, che è un potenziale vettore per attacchi denial-of-service.

`ERR_TLS_SNI_FROM_SERVER`

È stato effettuato un tentativo di emettere Server Name Indication da un socket TLS lato server, il che è valido solo da un client.

`ERR_TRACE_EVENTS_CATEGORY_REQUIRED`

Il metodo trace_events.createTracing() richiede almeno una categoria di eventi di traccia.

`ERR_TRACE_EVENTS_UNAVAILABLE`

Il modulo node:trace_events non è stato caricato perché Node.js è stato compilato con il flag --without-v8-platform.

`ERR_TRANSFORM_ALREADY_TRANSFORMING`

Uno stream Transform è terminato mentre era ancora in trasformazione.

`ERR_TRANSFORM_WITH_LENGTH_0`

Uno stream Transform è terminato con dati ancora nel buffer di scrittura.

`ERR_TTY_INIT_FAILED`

L'inizializzazione di un TTY è fallita a causa di un errore di sistema.

`ERR_UNAVAILABLE_DURING_EXIT`

La funzione è stata chiamata all'interno di un gestore process.on('exit') che non dovrebbe essere chiamato all'interno del gestore process.on('exit').

`ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET`

process.setUncaughtExceptionCaptureCallback() è stato chiamato due volte, senza prima reimpostare il callback a null.

Questo errore è progettato per impedire la sovrascrittura accidentale di un callback registrato da un altro modulo.

`ERR_UNESCAPED_CHARACTERS`

È stata ricevuta una stringa contenente caratteri non sottoposti a escape.

`ERR_UNHANDLED_ERROR`

Si è verificato un errore non gestito (ad esempio, quando un evento 'error' viene emesso da un EventEmitter ma un gestore 'error' non è registrato).

`ERR_UNKNOWN_BUILTIN_MODULE`

Utilizzato per identificare un tipo specifico di errore interno di Node.js che non dovrebbe essere normalmente attivato dal codice utente. Le istanze di questo errore puntano a un bug interno all'interno dello stesso binario di Node.js.

`ERR_UNKNOWN_CREDENTIAL`

È stato passato un identificatore di gruppo o utente Unix inesistente.

`ERR_UNKNOWN_ENCODING`

Un'opzione di codifica non valida o sconosciuta è stata passata a un'API.

`ERR_UNKNOWN_FILE_EXTENSION`

[Stable: 1 - Sperimentale]

Stable: 1 Stabilità: 1 - Sperimentale

È stato fatto un tentativo di caricare un modulo con un'estensione di file sconosciuta o non supportata.

`ERR_UNKNOWN_MODULE_FORMAT`

[Stable: 1 - Sperimentale]

Stable: 1 Stabilità: 1 - Sperimentale

È stato fatto un tentativo di caricare un modulo con un formato sconosciuto o non supportato.

`ERR_UNKNOWN_SIGNAL`

Un segnale di processo non valido o sconosciuto è stato passato a un'API che si aspetta un segnale valido (come subprocess.kill()).

`ERR_UNSUPPORTED_DIR_IMPORT`

L'istruzione import di un URL di directory non è supportata. Invece, fai riferimento a un pacchetto utilizzando il suo nome e definisci un subpath personalizzato nel campo "exports" del file package.json.

import './'; // non supportato
import './index.js'; // supportato
import 'package-name'; // supportato

`ERR_UNSUPPORTED_ESM_URL_SCHEME`

L'istruzione import con schemi URL diversi da file e data non è supportata.

`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`

Aggiunto in: v22.6.0

La rimozione del tipo non è supportata per i file discendenti da una directory node_modules.

`ERR_UNSUPPORTED_RESOLVE_REQUEST`

È stato fatto un tentativo di risolvere un riferimento a un modulo non valido. Ciò può accadere quando si importa o si chiama import.meta.resolve() con:

uno specificatore nudo che non è un modulo integrato da un modulo il cui schema URL non è file.
un URL relativo da un modulo il cui schema URL non è uno schema speciale.

try {
  // Tentativo di importare il pacchetto 'bare-specifier' da un modulo URL `data:`:
  await import('data:text/javascript,import "bare-specifier"');
} catch (e) {
  console.log(e.code); // ERR_UNSUPPORTED_RESOLVE_REQUEST
}

`ERR_USE_AFTER_CLOSE`

[Stabile: 1 - Sperimentale]

Stabile: 1 Stabilità: 1 - Sperimentale

È stato fatto un tentativo di utilizzare qualcosa che era già stato chiuso.

`ERR_VALID_PERFORMANCE_ENTRY_TYPE`

Durante l'utilizzo dell'API Performance Timing (perf_hooks), non vengono trovati tipi di voci di performance validi.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`

Non è stata specificata una callback di importazione dinamica.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG`

È stata invocata una callback di importazione dinamica senza --experimental-vm-modules.

`ERR_VM_MODULE_ALREADY_LINKED`

Il modulo che si è tentato di collegare non è idoneo al collegamento, per uno dei seguenti motivi:

È già stato collegato (linkingStatus è 'linked')
È in fase di collegamento (linkingStatus è 'linking')
Il collegamento non è riuscito per questo modulo (linkingStatus è 'errored')

`ERR_VM_MODULE_CACHED_DATA_REJECTED`

L'opzione cachedData passata a un costruttore di modulo non è valida.

`ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA`

Non è possibile creare dati memorizzati nella cache per i moduli che sono già stati valutati.

`ERR_VM_MODULE_DIFFERENT_CONTEXT`

Il modulo restituito dalla funzione di collegamento proviene da un contesto diverso rispetto al modulo padre. I moduli collegati devono condividere lo stesso contesto.

`ERR_VM_MODULE_LINK_FAILURE`

Il modulo non è stato collegato a causa di un errore.

`ERR_VM_MODULE_NOT_MODULE`

Il valore soddisfatto di una promessa di collegamento non è un oggetto vm.Module.

`ERR_VM_MODULE_STATUS`

Lo stato attuale del modulo non consente questa operazione. Il significato specifico dell'errore dipende dalla funzione specifica.

`ERR_WASI_ALREADY_STARTED`

L'istanza WASI è già stata avviata.

`ERR_WASI_NOT_STARTED`

L'istanza WASI non è stata avviata.

`ERR_WEBASSEMBLY_RESPONSE`

Aggiunto in: v18.1.0

La Response che è stata passata a WebAssembly.compileStreaming o a WebAssembly.instantiateStreaming non è una risposta WebAssembly valida.

`ERR_WORKER_INIT_FAILED`

`ERR_WORKER_OUT_OF_MEMORY`

L'istanza Worker è terminata perché ha raggiunto il suo limite di memoria.

`ERR_WORKER_PATH`

Il percorso per lo script principale di un worker non è né un percorso assoluto né un percorso relativo che inizia con ./ o ../.

`ERR_WORKER_UNSERIALIZABLE_ERROR`

Tutti i tentativi di serializzare un'eccezione non catturata da un thread worker sono falliti.

`ERR_WORKER_UNSUPPORTED_OPERATION`

La funzionalità richiesta non è supportata nei thread worker.

`ERR_ZLIB_INITIALIZATION_FAILED`

La creazione di un oggetto zlib non è riuscita a causa di una configurazione errata.

`HPE_CHUNK_EXTENSIONS_OVERFLOW`

Aggiunto in: v21.6.2, v20.11.1, v18.19.1

Sono stati ricevuti troppi dati per un'estensione di chunk. Al fine di proteggere da client dannosi o mal configurati, se vengono ricevuti più di 16 KiB di dati, verrà emesso un Error con questo codice.

`HPE_HEADER_OVERFLOW`

[Cronologia]

Versione	Modifiche
v11.4.0, v10.15.0	La dimensione massima dell'header in `http_parser` è stata impostata a 8 KiB.

Sono stati ricevuti troppi dati nell'header HTTP. Per proteggersi da client malevoli o mal configurati, se viene ricevuta una quantità di dati nell'header HTTP superiore a maxHeaderSize, l'analisi HTTP verrà interrotta senza che venga creato un oggetto di richiesta o risposta, e verrà emesso un Error con questo codice.

`HPE_UNEXPECTED_CONTENT_LENGTH`

Il server sta inviando sia un header Content-Length che Transfer-Encoding: chunked.

Transfer-Encoding: chunked consente al server di mantenere una connessione HTTP persistente per contenuti generati dinamicamente. In questo caso, l'header HTTP Content-Length non può essere utilizzato.

Utilizzare Content-Length o Transfer-Encoding: chunked.

`MODULE_NOT_FOUND`

[Cronologia]

Versione	Modifiche
v12.0.0	Aggiunta la proprietà `requireStack`.

Un file modulo non è stato risolto dal loader dei moduli CommonJS durante un'operazione require() o durante il caricamento del punto di ingresso del programma.

Codici di errore legacy di Node.js

[Stabile: 0 - Obsoleto]

Stabile: 0 Stabilità: 0 - Obsoleto. Questi codici di errore sono incoerenti o sono stati rimossi.

`ERR_CANNOT_TRANSFER_OBJECT`

Aggiunto in: v10.5.0

Rimosso in: v12.5.0

Il valore passato a postMessage() conteneva un oggetto che non è supportato per il trasferimento.

`ERR_CPU_USAGE`

Rimosso in: v15.0.0

La chiamata nativa da process.cpuUsage non poteva essere elaborata.

`ERR_CRYPTO_HASH_DIGEST_NO_UTF16`

Aggiunto in: v9.0.0

Rimosso in: v12.12.0

La codifica UTF-16 è stata utilizzata con hash.digest(). Mentre il metodo hash.digest() consente di passare un argomento encoding, facendo sì che il metodo restituisca una stringa anziché un Buffer, la codifica UTF-16 (ad esempio ucs o utf16le) non è supportata.

`ERR_CRYPTO_SCRYPT_INVALID_PARAMETER`

Rimossa in: v23.0.0

Una combinazione incompatibile di opzioni è stata passata a crypto.scrypt() o crypto.scryptSync(). Le nuove versioni di Node.js utilizzano invece il codice di errore ERR_INCOMPATIBLE_OPTION_PAIR, che è coerente con altre API.

Versione	Modifiche
v21.0.0	Viene lanciata una `DOMException`.
v21.0.0	Rimossa in: v21.0.0
v15.0.0	Aggiunta in: v15.0.0

Un oggetto che deve essere esplicitamente elencato nell'argomento transferList si trova nell'oggetto passato a una chiamata postMessage(), ma non è fornito nel transferList per quella chiamata. Di solito, questo è un MessagePort.

Nelle versioni di Node.js precedenti alla v15.0.0, il codice di errore utilizzato qui era ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST. Tuttavia, l'insieme dei tipi di oggetti trasferibili è stato ampliato per coprire più tipi di MessagePort.

`ERR_NAPI_CONS_PROTOTYPE_OBJECT`

Aggiunta in: v9.0.0

Rimossa in: v10.0.0

Utilizzato da Node-API quando Constructor.prototype non è un oggetto.

`ERR_NAPI_TSFN_START_IDLE_LOOP`

Aggiunto in: v10.6.0, v8.16.0

Rimosso in: v14.2.0, v12.17.0

Sul thread principale, i valori vengono rimossi dalla coda associata alla funzione thread-safe in un ciclo inattivo. Questo errore indica che si è verificato un errore durante il tentativo di avviare il ciclo.

`ERR_NAPI_TSFN_STOP_IDLE_LOOP`

Aggiunto in: v10.6.0, v8.16.0

Rimosso in: v14.2.0, v12.17.0

Una volta che non ci sono più elementi nella coda, il ciclo inattivo deve essere sospeso. Questo errore indica che il ciclo inattivo non è riuscito a fermarsi.

`ERR_NO_LONGER_SUPPORTED`

Un SharedArrayBuffer la cui memoria non è gestita dal motore JavaScript o da Node.js è stato incontrato durante la serializzazione. Un tale SharedArrayBuffer non può essere serializzato.

Questo può accadere solo quando gli addon nativi creano SharedArrayBuffer in modalità "esterna", o mettono SharedArrayBuffer esistenti in modalità esterna.

`ERR_UNKNOWN_STDIN_TYPE`

Aggiunto in: v8.0.0

Rimosso in: v11.7.0

È stato fatto un tentativo di avviare un processo Node.js con un tipo di file stdin sconosciuto. Questo errore è solitamente un'indicazione di un bug all'interno di Node.js stesso, sebbene sia possibile che il codice utente lo attivi.

`ERR_UNKNOWN_STREAM_TYPE`

Aggiunto in: v8.0.0

Rimosso in: v11.7.0

È stato fatto un tentativo di avviare un processo Node.js con un tipo di file stdout o stderr sconosciuto. Questo errore è solitamente un'indicazione di un bug all'interno di Node.js stesso, sebbene sia possibile che il codice utente lo attivi.

`ERR_V8BREAKITERATOR`

L'API V8 BreakIterator è stata utilizzata ma il set di dati ICU completo non è installato.

`ERR_VALUE_OUT_OF_RANGE`

Aggiunto in: v9.0.0

Rimosso in: v10.0.0

Usato quando un determinato valore è al di fuori dell'intervallo accettato.

`ERR_VM_MODULE_LINKING_ERRORED`

Aggiunto in: v10.0.0

Rimosso in: v18.1.0, v16.17.0

La funzione linker ha restituito un modulo per il quale il collegamento è fallito.

`ERR_VM_MODULE_NOT_LINKED`

Il modulo deve essere collegato correttamente prima dell'istanza.

`ERR_WORKER_UNSUPPORTED_EXTENSION`

Aggiunto in: v11.0.0

Rimosso in: v16.9.0

Il percorso utilizzato per lo script principale di un worker ha un'estensione di file sconosciuta.

`ERR_ZLIB_BINDING_CLOSED`

Aggiunto in: v9.0.0

Rimosso in: v10.0.0

Usato quando si tenta di utilizzare un oggetto zlib dopo che è già stato chiuso.

Codici di Errore OpenSSL

Errori di Validità Temporale

`CERT_NOT_YET_VALID`

Il certificato non è ancora valido: la data notBefore è successiva all'ora corrente.

`CERT_HAS_EXPIRED`

Il certificato è scaduto: la data notAfter è precedente all'ora corrente.

`CRL_NOT_YET_VALID`

La lista di revoca dei certificati (CRL) ha una data di emissione futura.

`CRL_HAS_EXPIRED`

La lista di revoca dei certificati (CRL) è scaduta.

`CERT_REVOKED`

Il certificato è stato revocato; si trova in una lista di revoca dei certificati (CRL).

`UNABLE_TO_GET_ISSUER_CERT`

Non è stato possibile trovare il certificato dell'emittente di un certificato ricercato. Normalmente questo significa che l'elenco dei certificati attendibili non è completo.

`UNABLE_TO_GET_ISSUER_CERT_LOCALLY`

L'emittente del certificato non è noto. Questo è il caso se l'emittente non è incluso nell'elenco dei certificati attendibili.

`DEPTH_ZERO_SELF_SIGNED_CERT`

Il certificato passato è autofirmato e lo stesso certificato non può essere trovato nell'elenco dei certificati attendibili.

`SELF_SIGNED_CERT_IN_CHAIN`

L'emittente del certificato non è noto. Questo è il caso se l'emittente non è incluso nell'elenco dei certificati attendibili.

`CERT_CHAIN_TOO_LONG`

La lunghezza della catena di certificati è maggiore della profondità massima.

`UNABLE_TO_GET_CRL`

Non è stato possibile trovare il riferimento CRL fornito dal certificato.

`UNABLE_TO_VERIFY_LEAF_SIGNATURE`

Nessuna firma può essere verificata perché la catena contiene un solo certificato e non è autofirmato.

`CERT_UNTRUSTED`

L'autorità di certificazione (CA) radice non è contrassegnata come attendibile per lo scopo specificato.

Errori di Estensione di Base

`INVALID_CA`

Un certificato CA non è valido. O non è una CA oppure le sue estensioni non sono coerenti con lo scopo fornito.

`PATH_LENGTH_EXCEEDED`

Il parametro pathlength basicConstraints è stato superato.

`HOSTNAME_MISMATCH`

Il certificato non corrisponde al nome fornito.

Errori Relativi all'Utilizzo e alle Politiche

`INVALID_PURPOSE`

Il certificato fornito non può essere utilizzato per lo scopo specificato.

`CERT_REJECTED`

La CA radice è contrassegnata per rifiutare lo scopo specificato.

Errori di Formattazione

`CERT_SIGNATURE_FAILURE`

La firma del certificato non è valida.

`CRL_SIGNATURE_FAILURE`

La firma della lista di revoca dei certificati (CRL) non è valida.

`ERROR_IN_CERT_NOT_BEFORE_FIELD`

Il campo notBefore del certificato contiene un orario non valido.

`ERROR_IN_CERT_NOT_AFTER_FIELD`

Il campo notAfter del certificato contiene un orario non valido.

`ERROR_IN_CRL_LAST_UPDATE_FIELD`

Il campo lastUpdate della CRL contiene un orario non valido.

`ERROR_IN_CRL_NEXT_UPDATE_FIELD`

Il campo nextUpdate della CRL contiene un orario non valido.

`UNABLE_TO_DECRYPT_CERT_SIGNATURE`

La firma del certificato non può essere decrittografata. Ciò significa che il valore effettivo della firma non può essere determinato piuttosto che non corrisponda al valore previsto, questo è significativo solo per le chiavi RSA.

`UNABLE_TO_DECRYPT_CRL_SIGNATURE`

La firma della lista di revoca dei certificati (CRL) non può essere decrittografata: ciò significa che il valore effettivo della firma non può essere determinato piuttosto che non corrisponda al valore previsto.

`UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY`

La chiave pubblica in SubjectPublicKeyInfo del certificato non può essere letta.

Altri Errori OpenSSL

`OUT_OF_MEM`

Si è verificato un errore durante il tentativo di allocare memoria. Questo non dovrebbe mai accadere.

Errori ​

Propagazione e intercettazione degli errori ​

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 ​

Errori di sistema comuni ​

Classe: TypeError ​

Eccezioni vs. errori ​

Errori OpenSSL ​

error.opensslErrorStack ​

error.function ​

error.library ​

error.reason ​

Codici di errore 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 ​

Errori

Propagazione e intercettazione degli errori

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`

Errori di sistema comuni

Classe: `TypeError`

Eccezioni vs. errori

Errori OpenSSL

`error.opensslErrorStack`

`error.function`

`error.library`

`error.reason`

Codici di errore 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`