Errori

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

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

Tutti gli errori JavaScript e di sistema generati da Node.js ereditano da o sono istanze della classe JavaScript standard <Error> ed è garantito che forniscano 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. La modalità con cui questi errori vengono segnalati e gestiti dipende interamente dal tipo di Error e dallo stile dell'API chiamata.

Tutti gli errori JavaScript vengono gestiti come eccezioni che generano e lanciano immediatamente un errore utilizzando il meccanismo standard JavaScript throw. 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 genererà un'eccezione che deve essere gestita o il processo Node.js terminerà immediatamente.

Con poche eccezioni, le API sincrone (qualsiasi metodo bloccante che non restituisce un <Promise> né accetta una funzione callback, come fs.readFileSync), utilizzeranno 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 presente che potrebbe essere rifiutata. Vedi il flag --unhandled-rejections per capire come il processo reagirà a un rifiuto di promessa non gestito.
La maggior parte dei metodi asincroni che accettano una funzione callback accetteranno un oggetto Error passato come primo argomento a tale funzione. Se il primo argomento non è null ed è un'istanza di Error, allora si è verificato un errore che deve essere gestito.
Quando un metodo asincrono viene chiamato su un oggetto che è un EventEmitter, gli errori possono essere indirizzati all'evento 'error' di tale oggetto.
Alcuni metodi tipicamente asincroni nell'API Node.js potrebbero ancora utilizzare il meccanismo throw per generare eccezioni che devono essere gestite utilizzando try…catch. Non esiste un elenco esaustivo di tali metodi; fare riferimento alla documentazione di ciascun metodo per determinare il meccanismo di gestione degli errori appropriato richiesto.

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

Per tutti gli oggetti EventEmitter, se non viene fornito un gestore di eventi 'error', l'errore verrà generato, causando la segnalazione di un'eccezione non intercettata e l'arresto anomalo del processo Node.js a meno che: un gestore non sia stato registrato per l'evento 'uncaughtException', o venga utilizzato il modulo deprecato node:domain.

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

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

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

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

Classe: `Error`

Un oggetto JavaScript <Error> generico che non indica alcuna circostanza specifica del perché si è verificato l'errore. Gli oggetti Error catturano uno "stack trace" che dettaglia il punto nel codice in cui Error è stato istanziato 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 <string>
options <Object>
- cause <any> 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(). Gli stack trace dipendono dalla API stack trace di V8. Gli stack trace si estendono solo fino a (a) l'inizio dell' esecuzione del codice sincrono, o (b) il numero di frame forniti dalla proprietà Error.stackTraceLimit, a seconda di quale è minore.

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

targetObject <Object>
constructorOpt <Function>

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 al di sopra di constructorOpt, incluso constructorOpt, verranno omessi dallo stack trace generato.

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

function a() {
  b()
}

function b() {
  c()
}

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

  // Cattura lo stack trace sopra la funzione b
  Error.captureStackTrace(error, b) // Né la funzione c, né b sono incluse nello 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 generata da new Error().stack che da Error.captureStackTrace(obj)).

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

Se impostato su un valore non numerico, o impostato 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 genera uno nuovo con un messaggio o un codice diverso per avere comunque accesso all'errore originale.

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

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

const cause = new Error('Il server HTTP remoto ha risposto con uno stato 500')
const symptom = new Error('Il messaggio non è stato inviato', { cause })

console.log(symptom)
// Stampa:
//   Error: Il messaggio non è stato inviato
//       at REPL2:1:17
//       at Script.runInThisContext (node:vm:130:12)
//       ... 7 righe corrispondenti alla traccia dello stack della causa ...
//       at [_line] [as _line] (node:internal/readline/interface:886:18) {
//     [cause]: Error: Il server HTTP remoto ha risposto con uno stato 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 proprietà error.code è un'etichetta di tipo 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 di error.message potrebbero cambiare tra qualsiasi versione di Node.js. Vedi Codici di errore di Node.js per i dettagli sui codici specifici.

`error.message`

<string>

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

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

`error.stack`

<string>

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

bash

Error: Continuano a succedere cose!
   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 classe errore\>: \<messaggio errore\>, ed è seguita da una serie di frame dello stack (ogni riga che inizia con "at "). Ogni frame descrive un punto di chiamata nel codice che ha portato alla generazione dell'errore. V8 tenta di visualizzare un nome per ciascuna funzione (tramite nome di variabile, nome di funzione o nome di metodo dell'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 di add-on 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 *in modo sincrono* 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).
nome-file-semplice.js:linea:colonna, se il frame rappresenta una chiamata interna a Node.js.
/percorso/assoluto/al/file.js:linea: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:linea: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 in modo lazy quando si accede alla proprietà error.stack.

Il numero di frame catturati dallo stack trace è limitato al minore tra Error.stackTraceLimit o il numero di frame disponibili nel tick corrente del ciclo di eventi.

Classe: `AssertionError`

Estende: <errors.Error>

Indica il fallimento di un'asserzione. Per maggiori dettagli, vedere 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 dato parametro di funzione.

require('node:net').connect(-1)
// Lancia "RangeError: l'opzione "port" deve essere >= 0 e < 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 non definita. Tali errori indicano comunemente errori di battitura nel codice o un programma altrimenti interrotto.

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 codice dinamicamente, le istanze di ReferenceError indicano un bug nel codice o nelle sue dipendenze.

Classe: `SyntaxError`

Estende: <errors.Error>

Indica che un programma non è un 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 interrotto.

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 <string> Se presente, l'indirizzo a cui non è riuscita una connessione di rete
code <string> Il codice di errore stringa
dest <string> Se presente, il percorso del file di destinazione quando viene segnalato un errore del file system
errno <number> Il numero di errore fornito dal sistema
info <Object> Se presente, dettagli aggiuntivi sulla condizione di errore
message <string> Una descrizione dell'errore leggibile dall'uomo fornita dal sistema
path <string> Se presente, il percorso del file quando viene segnalato un errore del file system
port <number> Se presente, la porta di connessione di rete non disponibile
syscall <string> Il nome della chiamata di sistema che ha attivato l'errore

`error.address`

<string>

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

`error.code`

<string>

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

`error.dest`

<string>

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

`error.errno`

<number>

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

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

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

`error.info`

<Object>

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

`error.message`

<string>

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

`error.path`

<string>

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

`error.port`

<number>

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

`error.syscall`

<string>

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

Error di sistema comuni

Questo è un elenco di errori di sistema comunemente riscontrati durante la scrittura di un programma Node.js. Per un elenco completo, vedere la errno(3) man page.

EACCES (Permesso negato): È stato effettuato un tentativo di accesso a un file in modo proibito dalle sue autorizzazioni di accesso al file.
EADDRINUSE (Indirizzo già in uso): Un tentativo di legare un server (net, http o https) a un indirizzo locale è fallito a causa di un altro server sul sistema locale che già occupa quell'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 esterno.
ECONNRESET (Connessione resettata dal peer): Una connessione è stata chiusa forzatamente da un peer. Ciò deriva normalmente da una perdita di connessione sul socket remoto a causa di un timeout o di un riavvio. Comunemente riscontrato 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 non ne è stato chiuso almeno uno. Questo si verifica quando si aprono molti file contemporaneamente in parallelo, in particolare su 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 fallita): Indica un errore DNS di EAI_NODATA o EAI_NONAME. Questo non è un errore POSIX standard.
EPERM (Operazione non consentita): È stato effettuato un tentativo di eseguire un'operazione che richiede privilegi elevati.
EPIPE (Pipe interrotta): Una scrittura su una pipe, socket o FIFO per la quale non esiste un processo per leggere i dati. Comunemente riscontrato ai livelli net e http, indicativo che il lato remoto dello stream su cui si sta scrivendo è stato chiuso.
ETIMEDOUT (Operazione scaduta): Una richiesta di connessione o di invio è fallita perché la parte connessa non ha risposto correttamente dopo un periodo di tempo. Di solito riscontrato da http o net. Spesso è un segno che un 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 sarebbe un TypeError.

require('node:url').parse(() => {})
// Genera TypeError, poiché si aspettava una stringa.

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

Eccezioni vs. errori

Un'eccezione JavaScript è un valore che viene lanciato a seguito di un'operazione non valida o come target di un'istruzione throw. Sebbene non sia necessario 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 controlli assert() o chiamate abort() nel livello C++.

Errori OpenSSL

Gli errori originati in crypto o tls sono della 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 può fornire contesto sul punto in cui la libreria OpenSSL ha avuto origine.

`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 la ragione dell'errore.

Codici di errore Node.js

`ABORT_ERR`

Aggiunto in: v15.0.0

Usato quando un'operazione è stata interrotta (in genere utilizzando 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 Node.js utilizzano 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 accedere a una risorsa limitata dal Modello di autorizzazioni.

`ERR_AMBIGUOUS_ARGUMENT`

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

`ERR_ARG_NOT_ITERABLE`

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

`ERR_ASSERTION`

Un tipo speciale di errore che può essere attivato ogni volta che Node.js rileva una violazione logica eccezionale che non dovrebbe mai verificarsi. Questi errori vengono generati in genere 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 possono anche definire i propri tipi se utilizzano l'API embedder pubblica.

`ERR_BROTLI_COMPRESSION_FAILED`

I dati passati a un flusso Brotli non sono stati compressi correttamente.

`ERR_BROTLI_INVALID_PARAM`

Una chiave di parametro non valida è stata passata durante la costruzione di un flusso Brotli.

`ERR_BUFFER_CONTEXT_NOT_AVAILABLE`

È stato fatto un tentativo di creare un'istanza di Buffer Node.js dal codice dell'addon o dell'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 nel momento in cui il metodo restituisce.

Quando si incontra questo errore, un'alternativa possibile alla creazione di un'istanza di Buffer è la creazione di un normale Uint8Array, che differisce solo nel prototipo dell'oggetto risultante. Gli Uint8Array sono generalmente accettati in tutte le API core di Node.js in cui si trovano 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 è riuscito a monitorare il segnale SIGINT.

`ERR_CHILD_CLOSED_BEFORE_REPLY`

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

`ERR_CHILD_PROCESS_IPC_REQUIRED`

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

`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`

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

`ERR_CLOSED_MESSAGE_PORT`

[Cronologia]

Versione	Cambiamenti
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

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

`ERR_CONSOLE_WRITABLE_STREAM`

Console è stato istanziato senza lo stream stdout, oppure Console ha uno stream stdout o stderr non scrivibile.

`ERR_CONSTRUCT_CALL_INVALID`

Aggiunto in: v12.5.0

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

`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ò potrebbe accadere quando si verifica un errore (e viene intercettato) durante la creazione del contesto, ad esempio, quando l'allocazione fallisce o viene raggiunta la dimensione massima dello stack di chiamate quando il contesto viene creato.

`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 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(). Ciò significa che la chiave pubblica si trova al di fuori della curva ellittica.

`ERR_CRYPTO_ENGINE_UNKNOWN`

Un identificatore del motore crittografico 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 effettuato 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 raramente, se non mai, accadere.

`ERR_CRYPTO_INCOMPATIBLE_KEY`

Le chiavi crittografiche fornite non sono compatibili con l'operazione tentata.

`ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS`

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

`ERR_CRYPTO_INITIALIZATION_FAILED`

Aggiunto in: v15.0.0

L'inizializzazione del sottosistema crittografico 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 cifratura 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 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`

Non è stata fornita una key di firma 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. Consulta crypto.getDiffieHellman() per un elenco dei nomi di gruppo validi.

`ERR_CRYPTO_UNSUPPORTED_OPERATION`

Aggiunto in: v15.0.0, v14.18.0

È stato effettuato un tentativo di invocare un'operazione di crittografia 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 durante l'attesa che l'host/porta richiesto fosse libero.

`ERR_DIR_CLOSED`

fs.Dir è stato chiuso precedentemente.

`ERR_DIR_CONCURRENT_OPERATION`

Aggiunto in: v14.3.0

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

`ERR_DLOPEN_DISABLED`

Aggiunto in: v16.10.0, v14.19.0

Il caricamento di componenti aggiuntivi nativi è stato disabilitato utilizzando --no-addons.

`ERR_DLOPEN_FAILED`

Aggiunto in: v15.0.0

Una chiamata a process.dlopen() non è riuscita.

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

`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`

process.setUncaughtExceptionCaptureCallback() non poteva essere chiamato perché il modulo node:domain era stato caricato in precedenza.

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

`ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION`

v8.startupSnapshot.setDeserializeMainFunction() non poteva essere chiamato 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 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. Questo può verificarsi quando Node.js viene utilizzato come libreria incorporata e alcuni hook per il motore JS non sono impostati correttamente.

`ERR_FALSY_VALUE_REJECTION`

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

`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`

Aggiunto in: v14.0.0

È stato effettuato un tentativo di copia verso 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 usano il metodo CONNECT, è richiesto lo pseudo-header :authority.

`ERR_HTTP2_CONNECT_PATH`

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

`ERR_HTTP2_CONNECT_SCHEME`

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

`ERR_HTTP2_ERROR`

Si è verificato un errore HTTP/2 non specifico.

`ERR_HTTP2_GOAWAY_SESSION`

Non è possibile aprire nuovi Stream HTTP/2 dopo che la Http2Session ha ricevuto un frame GOAWAY dal peer connesso.

`ERR_HTTP2_HEADERS_AFTER_RESPOND`

È stato specificato un header aggiuntivo dopo l'avvio di 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 nelle 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 di input passate all'API http2.getUnpackedSettings() devono avere una lunghezza multipla di sei.

`ERR_HTTP2_INVALID_PSEUDOHEADER`

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

`ERR_HTTP2_INVALID_SESSION`

Un'azione è stata eseguita 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`

Un'operazione è stata eseguita su uno stream che era già stato distrutto.

`ERR_HTTP2_MAX_PENDING_SETTINGS_ACK`

Ogni volta che un frame SETTINGS HTTP/2 viene inviato a un peer connesso, il peer è tenuto a inviare un acknowledgment che ha ricevuto e applicato le nuove SETTINGS. Per impostazione predefinita, è possibile inviare un numero massimo di frame SETTINGS non confermati 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 push stream dall'interno di uno push stream. 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 (lettura, scrittura, pausa, ripresa, 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 di messaggio per un codice di risposta HTTP per il quale un payload è proibito.

`ERR_HTTP2_PING_CANCEL`

Un ping HTTP/2 è stato annullato.

`ERR_HTTP2_PING_LENGTH`

I payload di ping HTTP/2 devono avere una lunghezza di esattamente 8 byte.

`ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED`

Uno pseudo-header HTTP/2 è stato usato in modo inappropriato. Gli pseudo-header sono nomi di chiavi di intestazione che iniziano con il prefisso :.

`ERR_HTTP2_PUSH_DISABLED`

È stato effettuato un tentativo di creare un flusso 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 normale, 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 della Http2Session sono state annullate.

`ERR_HTTP2_SOCKET_BOUND`

È stato effettuato un tentativo di collegare 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 numero intero compreso tra 100 e 599 (inclusi).

`ERR_HTTP2_STREAM_CANCEL`

Una Http2Stream è stata distrutta prima che venissero trasmessi dati 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 come dipendente da sé stesso.

`ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS`

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

`ERR_HTTP2_TOO_MANY_INVALID_FRAMES`

Aggiunto in: v15.14.0

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

`ERR_HTTP2_TRAILERS_ALREADY_SENT`

Le intestazioni di chiusura sono già state inviate su 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 Http2Stream.

`ERR_HTTP2_UNSUPPORTED_PROTOCOL`

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

`ERR_HTTP_BODY_NOT_ALLOWED`

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

`ERR_HTTP_CONTENT_LENGTH_MISMATCH`

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

`ERR_HTTP_HEADERS_SENT`

È stato effettuato un tentativo di aggiungere altre intestazioni dopo che le intestazioni erano già state inviate.

`ERR_HTTP_INVALID_HEADER_VALUE`

È stato specificato un valore di intestazione HTTP non valido.

`ERR_HTTP_INVALID_STATUS_CODE`

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

`ERR_HTTP_REQUEST_TIMEOUT`

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

`ERR_HTTP_SOCKET_ASSIGNED`

Alla ServerResponse specificata era già stato assegnato un socket.

`ERR_HTTP_SOCKET_ENCODING`

La modifica della codifica del socket non è consentita in base alla RFC 7230 Sezione 3.

`ERR_HTTP_TRAILER_INVALID`

L'intestazione Trailer è stata impostata 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`

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

[Stabile: 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 effettuato un tentativo di attivare l'inspector quando aveva già iniziato ad ascoltare su una porta. Utilizzare inspector.close() prima di attivarlo su un indirizzo diverso.

`ERR_INSPECTOR_ALREADY_CONNECTED`

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

`ERR_INSPECTOR_CLOSED`

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

`ERR_INSPECTOR_COMMAND`

Si è verificato un errore durante l'emissione 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 effettuato un tentativo di utilizzare l'inspector prima che fosse connesso.

`ERR_INSPECTOR_NOT_WORKER`

Un'API è stata chiamata sul thread principale che può essere utilizzata solo dal thread worker.

`ERR_INTERNAL_ASSERTION`

Si è verificato un bug in Node.js o un utilizzo errato dei componenti interni di Node.js. Per correggere l'errore, apri un problema su https://github.com/nodejs/node/issues.

`ERR_INVALID_ADDRESS`

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

`ERR_INVALID_ADDRESS_FAMILY`

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

`ERR_INVALID_ARG_TYPE`

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

`ERR_INVALID_ARG_VALUE`

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

`ERR_INVALID_ASYNC_ID`

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

`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 nelle intestazioni.

`ERR_INVALID_CURSOR_POS`

Un cursore su un dato 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 utilizza URL file: (come alcune funzioni nel modulo fs) ha incontrato un URL file con un host incompatibile. Questa situazione può verificarsi solo su sistemi Unix-like dove sono supportati solo localhost o un host vuoto.

`ERR_INVALID_FILE_URL_PATH`

Un'API di Node.js che utilizza 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 fatto 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

Si è tentato di caricare un modulo che non esiste o non è valido.

`ERR_INVALID_MODULE_SPECIFIER`

La stringa del modulo importato è un URL, un nome di pacchetto o uno specificatore di sottopercorso di 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.

`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 entrambe le opzioni breakEvalOnSigint ed eval nella configurazione REPL, il che non è supportato.

`ERR_INVALID_REPL_INPUT`

L'input potrebbe non essere utilizzato nel REPL. Le condizioni in cui viene utilizzato questo errore sono descritte nella documentazione di 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 si prevede che una funzione restituisca 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 eseguire un'altra operazione.

`ERR_INVALID_SYNC_FORK_INPUT`

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

`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 WHATWG costruttore URLSearchParams 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 la sintassi TypeScript che richiede la trasformazione con rimozione del tipo.

`ERR_INVALID_URI`

È stata passata un'URI non valida.

`ERR_INVALID_URL`

È stata passata un URL non valida al WHATWG costruttore URL o al legacy url.parse() per essere analizzata. L'oggetto errore lanciato di solito ha una proprietà aggiuntiva 'input' che contiene l'URL che non è riuscita ad essere analizzata.

`ERR_INVALID_URL_SCHEME`

È stato effettuato un tentativo di utilizzare un URL con uno schema (protocollo) incompatibile per uno scopo specifico. Viene utilizzato solo nel supporto API URL WHATWG 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 effettuato un tentativo di utilizzare un canale di comunicazione IPC che era già stato chiuso.

`ERR_IPC_DISCONNECTED`

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

`ERR_IPC_ONE_PIPE`

È stato effettuato 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 forkato in modo sincrono. Per maggiori informazioni, consultare 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 loader ESM è tornato senza chiamare next() e senza segnalare esplicitamente un corto circuito.

`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 possibile deserializzarlo nel Context vm di destinazione. Non tutti gli oggetti Node.js possono essere istanziati correttamente in qualsiasi contesto in questo momento e il tentativo di trasferirli usando postMessage() può fallire sul lato ricevente in tal caso.

`ERR_METHOD_NOT_IMPLEMENTED`

Un metodo è richiesto ma non implementato.

`ERR_MISSING_ARGS`

Non è stato passato un argomento obbligatorio di una API Node.js. Questo viene usato solo per la stretta conformità con la specifica API (che in alcuni casi può accettare func(undefined) ma non func()). Nella maggior parte delle API native di Node.js, func(undefined) e func() vengono trattati in modo identico e il codice di errore ERR_INVALID_ARG_TYPE può essere usato al suo posto.

`ERR_MISSING_OPTION`

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

`ERR_MISSING_PASSPHRASE`

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

`ERR_MISSING_PLATFORM_FOR_WORKER`

La piattaforma V8 usata da questa istanza di Node.js non supporta la creazione di Worker. Questo è 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 modulo non è stato risolto dal caricatore di moduli ECMAScript durante un tentativo di operazione 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 destinata a essere chiamata una sola volta poiché la query può essere soddisfatta o rifiutata, ma non entrambe contemporaneamente. Quest'ultima 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 offset specificato era al di fuori dei limiti della dataview oppure offset + length era maggiore della lunghezza di un buffer specificato.

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

`ERR_NAPI_TSFN_CALL_JS`

Si è verificato un errore durante l'invocazione della parte 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 effettuato un tentativo di utilizzare operazioni che possono essere utilizzate solo durante la creazione di uno snapshot di avvio di V8, anche se Node.js non ne sta creando 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 effettuato un tentativo di eseguire operazioni non supportate durante la creazione di uno snapshot di avvio.

`ERR_NO_CRYPTO`

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

`ERR_NO_ICU`

Si è tentato di utilizzare funzionalità che richiedono ICU, ma Node.js non è stato compilato con il supporto ICU.

`ERR_NO_TYPESCRIPT`

Aggiunto in: v23.0.0

Si è tentato di utilizzare funzionalità che richiedono il supporto Native 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 utilizzato per segnalare il fallimento generale di un'operazione asincrona.

`ERR_OUT_OF_RANGE`

Un valore specificato è al di fuori dell'intervallo accettato.

`ERR_PACKAGE_IMPORT_NOT_DEFINED`

Il campo "imports" di package.json non definisce la mappatura del nome del pacchetto interno specificato.

`ERR_PACKAGE_PATH_NOT_EXPORTED`

Il campo "exports" di package.json non esporta il sottopath richiesto. Poiché le esportazioni sono incapsulate, i moduli interni privati che non sono 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, viene generato da util.parseArgs() se un valore <boolean> viene fornito per un'opzione di tipo <string>, o se un valore <string> viene fornito per un'opzione di tipo <boolean>.

`ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL`

Aggiunto in: v18.3.0, v16.17.0

Generato 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, viene generato da util.parseArgs() se un argomento non è configurato in options.

`ERR_PERFORMANCE_INVALID_TIMESTAMP`

È stato fornito un valore 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 usare require() su un Modulo ES, un'interfaccia CommonJS a ESM o ESM a CommonJS partecipa a un ciclo immediato. Ciò 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 effettuato un tentativo di utilizzare require() su 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. Ciò si applica a 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. Ciò si applica a tutte le istanze di net.Server, comprese 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 effettuato 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 si aspetta una porta >= 0 e < 65536 ha ricevuto un valore non valido.

`ERR_SOCKET_BAD_TYPE`

Una funzione API che si aspetta 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 invio.

`ERR_SOCKET_CLOSED`

È stato effettuato 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 utilizzava l'algoritmo di selezione automatica della famiglia.

`ERR_SOCKET_DGRAM_IS_CONNECTED`

Una chiamata a dgram.connect() è stata effettuata su un socket già connesso.

`ERR_SOCKET_DGRAM_NOT_CONNECTED`

Una chiamata a dgram.disconnect() o dgram.remoteAddress() è stata effettuata 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 è danneggiata.

`ERR_SOURCE_MAP_MISSING_SOURCE`

Non è stato trovato un file importato da una source map.

`ERR_SQLITE_ERROR`

Aggiunto in: v22.5.0

È stato restituito un errore da SQLite.

`ERR_SRI_PARSE`

È stata fornita una stringa per un controllo Subresource Integrity, ma non è stato possibile analizzarla. Controlla 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 è terminato.

`ERR_STREAM_CANNOT_PIPE`

È stato effettuato 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 effettuato 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 effettuato un tentativo di chiamare stream.push() dopo che un null(EOF) era stato inviato allo stream.

`ERR_STREAM_UNABLE_TO_PIPE`

È stato effettuato un tentativo di eseguire il pipe verso uno stream chiuso o distrutto in una pipeline.

`ERR_STREAM_UNSHIFT_AFTER_END_EVENT`

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

`ERR_STREAM_WRAP`

Impedisce un abort 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`

Si è tentato di chiamare stream.write() dopo che è stato chiamato stream.end().

`ERR_STRING_TOO_LONG`

Si è tentato di creare una stringa più lunga della lunghezza massima consentita.

`ERR_SYNTHETIC`

Un oggetto di 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à oggetto err.info con dettagli aggiuntivi.

`ERR_TAP_LEXER_ERROR`

Un errore che rappresenta uno stato del lexer non riuscito.

`ERR_TAP_PARSER_ERROR`

Un errore che rappresenta uno stato del parser non riuscito. Ulteriori informazioni sul token che causa l'errore sono disponibili tramite la proprietà cause.

`ERR_TAP_VALIDATION_ERROR`

Questo errore rappresenta una validazione TAP non riuscita.

`ERR_TEST_FAILURE`

Questo errore rappresenta un test non riuscito. Ulteriori informazioni sull'errore sono disponibili tramite la proprietà cause. La proprietà failureType specifica cosa stava facendo il test quando si è verificato l'errore.

`ERR_TLS_ALPN_CALLBACK_INVALID_RESULT`

Questo errore viene generato quando una 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 causeranno mai questo errore.

`ERR_TLS_CERT_ALTNAME_INVALID`

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

`ERR_TLS_DH_PARAM_SIZE`

Durante l'utilizzo di TLS, il parametro offerto per il protocollo di accordo della chiave 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 raccomandato l'uso di 2048 bit o più per una maggiore sicurezza.

`ERR_TLS_HANDSHAKE_TIMEOUT`

Un handshake TLS/SSL è andato in timeout. 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. È sconosciuto o disabilitato perché non sicuro.

`ERR_TLS_INVALID_PROTOCOL_VERSION`

Le versioni valide del protocollo TLS 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. Assicurarsi che l'evento 'secure' venga emesso prima di continuare.

`ERR_TLS_PROTOCOL_VERSION_CONFLICT`

Il tentativo di impostare un protocollo TLS minVersion o maxVersion è in conflitto con un tentativo di impostare secureProtocol esplicitamente. 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 di socket con 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 l'indicazione del nome del server da un socket lato server TLS, 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 può essere caricato perché Node.js è stato compilato con il flag --without-v8-platform.

`ERR_TRANSFORM_ALREADY_TRANSFORMING`

Uno stream Transform è terminato mentre era ancora in fase di trasformazione.

`ERR_TRANSFORM_WITH_LENGTH_0`

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

`ERR_TTY_INIT_FAILED`

L'inizializzazione di una TTY non è riuscita 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 di un gestore process.on('exit').

`ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET`

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

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

`ERR_UNESCAPED_CHARACTERS`

È stata ricevuta una stringa contenente caratteri non con escape.

`ERR_UNHANDLED_ERROR`

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

`ERR_UNKNOWN_BUILTIN_MODULE`

Utilizzato per identificare un tipo specifico di errore interno di Node.js che in genere non dovrebbe essere attivato dal codice utente. Le istanze di questo errore indicano un bug interno all'interno del binario stesso di Node.js.

`ERR_UNKNOWN_CREDENTIAL`

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

`ERR_UNKNOWN_ENCODING`

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

`ERR_UNKNOWN_FILE_EXTENSION`

[Stabile: 1 - Sperimentale]

Stabile: 1 Stabilità: 1 - Sperimentale

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

`ERR_UNKNOWN_MODULE_FORMAT`

[Stabile: 1 - Sperimentale]

Stabile: 1 Stabilità: 1 - Sperimentale

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

`ERR_UNKNOWN_SIGNAL`

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

`ERR_UNSUPPORTED_DIR_IMPORT`

L' import di un URL di directory non è supportato. Invece, fai riferimento a un pacchetto usando il suo nome e definisci un sottopercorso 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' import con schemi URL diversi da file e data non è supportato.

`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`

Aggiunto in: v22.6.0

La rimozione dei tipi non è supportata per i file discendenti da una directory node_modules.

`ERR_UNSUPPORTED_RESOLVE_REQUEST`

È stato fatto un tentativo di risolvere un referrer di 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 usare qualcosa che era già stato chiuso.

`ERR_VALID_PERFORMANCE_ENTRY_TYPE`

Durante l'uso dell'API Performance Timing (perf_hooks), non sono stati 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`

I dati memorizzati nella cache non possono essere creati per i moduli che sono già stati valutati.

`ERR_VM_MODULE_DIFFERENT_CONTEXT`

Il modulo restituito dalla funzione linker proviene da un contesto diverso da quello del 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 corrente 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 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 rilevata da un thread worker non sono riusciti.

`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 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	Cambiamenti
v11.4.0, v10.15.0	La dimensione massima dell'intestazione in `http_parser` era impostata a 8 KiB.

Sono stati ricevuti troppi dati di intestazione HTTP. Per proteggersi da client malevoli o mal configurati, se vengono ricevuti più di maxHeaderSize di dati di intestazione HTTP, 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'intestazione Content-Length sia Transfer-Encoding: chunked.

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

Utilizzare Content-Length o Transfer-Encoding: chunked.

`MODULE_NOT_FOUND`

[Cronologia]

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

Un file di modulo non è stato risolto dal caricatore di moduli CommonJS durante un tentativo di 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 es. ucs o utf16le) non è supportata.

`ERR_CRYPTO_SCRYPT_INVALID_PARAMETER`

Rimosso 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.

Questo codice di errore è stato sostituito da ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST in Node.js v15.0.0, perché non è più accurato poiché ora esistono anche altri tipi di oggetti trasferibili.

`ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST`

[Cronologia]

Versione	Modifiche
v21.0.0	Invece viene generata una `DOMException`.
v21.0.0	Rimosso in: v21.0.0
v15.0.0	Aggiunto 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 viene fornito nella transferList per tale chiamata. Solitamente, si tratta di 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 di tipi di oggetti trasferibili è stato ampliato per includere più tipi di MessagePort.

`ERR_NAPI_CONS_PROTOTYPE_OBJECT`

Aggiunto in: v9.0.0

Rimosso in: v10.0.0

Utilizzato dalla 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

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

Durante la serializzazione è stato rilevato un SharedArrayBuffer la cui memoria non è gestita dal motore JavaScript o da Node.js. Tale SharedArrayBuffer non può essere serializzato.

Ciò può accadere solo quando gli addon nativi creano SharedArrayBuffer in modalità "esternalizzata" o mettono un SharedArrayBuffer esistente in modalità esternalizzata.

`ERR_UNKNOWN_STDIN_TYPE`

Aggiunto in: v8.0.0

Rimosso in: v11.7.0

È stato effettuato un tentativo di avviare un processo Node.js con un tipo di file stdin sconosciuto. Questo errore di solito indica 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 effettuato un tentativo di avviare un processo Node.js con un tipo di file stdout o stderr sconosciuto. Questo errore di solito indica un bug all'interno di Node.js stesso, sebbene sia possibile che il codice utente lo attivi.

`ERR_V8BREAKITERATOR`

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

`ERR_VALUE_OUT_OF_RANGE`

Aggiunto in: v9.0.0

Rimosso in: v10.0.0

Utilizzato quando un valore specificato è 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 non è riuscito.

`ERR_VM_MODULE_NOT_LINKED`

Il modulo deve essere collegato correttamente prima dell'istanziamento.

`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

Utilizzato 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 cercato. Ciò significa normalmente 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 del certificato.

`UNABLE_TO_VERIFY_LEAF_SIGNATURE`

Non è stato possibile verificare alcuna firma perché la catena contiene solo un 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 o le sue estensioni non sono coerenti con lo scopo fornito.

`PATH_LENGTH_EXCEEDED`

Il parametro pathlength di basicConstraints è stato superato.

`HOSTNAME_MISMATCH`

Il certificato non corrisponde al nome fornito.

Errori di utilizzo e policy

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

Non è stato possibile decifrare la firma del certificato. Ciò significa che il valore effettivo della firma non ha potuto essere determinato anziché non corrispondere al valore previsto, questo ha significato solo per le chiavi RSA.

`UNABLE_TO_DECRYPT_CRL_SIGNATURE`

Non è stato possibile decifrare la firma della lista di revoca dei certificati (CRL): ciò significa che il valore effettivo della firma non ha potuto essere determinato anziché non corrispondere al valore previsto.

`UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY`

Non è stato possibile leggere la chiave pubblica in SubjectPublicKeyInfo del certificato.

Altri errori OpenSSL

`OUT_OF_MEM`

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

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 ​

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

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