Node.js v21.7.2 文档

错误传播和拦截#

Node.js 支持多种机制来传播和处理应用程序运行期间发生的错误。这些错误的报告和处理方式完全取决于 Error 的类型和所调用 API 的样式。

所有 JavaScript 错误都作为异常处理，这些异常会立即生成并使用标准 JavaScript throw 机制抛出错误。这些错误使用 JavaScript 语言提供的 try…catch 结构 进行处理。

// Throws with a ReferenceError because z is not defined.
try {
  const m = 1;
  const n = m + z;
} catch (err) {
  // Handle the error here.
} copy

任何使用 JavaScript throw 机制的情况都会引发一个必须处理的异常，否则 Node.js 进程将立即退出。

除了少数例外，同步 API（任何不返回 <Promise> 也不接受 callback 函数的阻塞方法，例如 fs.readFileSync）将使用 throw 来报告错误。

异步 API 中发生的错误可能会通过多种方式报告

• 一些异步方法返回 <Promise>，你应始终考虑它可能会被拒绝。请参阅 --unhandled-rejections 标志，了解进程将如何对未处理的 promise 拒绝做出反应。

  const fs = require('fs/promises');
  
  (async () => {
    let data;
    try {
      data = await fs.readFile('a file that does not exist');
    } catch (err) {
      console.error('There was an error reading the file!', err);
      return;
    }
    // Otherwise handle the data
  })(); copy

• 大多数接受 callback 函数的异步方法将接受一个作为该函数第一个参数传递的 Error 对象。如果该第一个参数不为 null 并且是 Error 的实例，则发生了应处理的错误。

  const fs = require('node:fs');
  fs.readFile('a file that does not exist', (err, data) => {
    if (err) {
      console.error('There was an error reading the file!', err);
      return;
    }
    // Otherwise handle the data
  }); copy

• 当对 EventEmitter 对象调用异步方法时，错误可以路由到该对象的 'error' 事件。

  const net = require('node:net');
  const connection = net.connect('localhost');
  
  // Adding an 'error' event handler to a stream:
  connection.on('error', (err) => {
    // If the connection is reset by the server, or if it can't
    // connect at all, or on any sort of error encountered by
    // the connection, the error will be sent here.
    console.error(err);
  });
  
  connection.pipe(process.stdout); copy

• Node.js API 中少数通常为异步的方法仍可能使用 throw 机制来引发必须使用 try…catch 处理的异常。没有此类方法的综合列表；请参阅每个方法的文档以确定所需的适当错误处理机制。

'error' 事件机制的使用最常见于 基于流 和 基于事件发射器 的 API，它们本身表示一系列异步操作（相对于可能通过或失败的单个操作）。

对于所有 EventEmitter 对象，如果未提供 'error' 事件处理程序，则将抛出错误，导致 Node.js 进程报告未捕获的异常并崩溃，除非：已为 'uncaughtException' 事件注册了处理程序，或使用了已弃用的 node:domain 模块。

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

setImmediate(() => {
  // This will crash the process because no 'error' event
  // handler has been added.
  ee.emit('error', new Error('This will crash'));
}); copy

以这种方式生成的错误不能使用 try…catch 拦截，因为它们是在调用代码已经退出之后抛出的。

开发人员必须参考每个方法的文档，以准确确定这些方法引发的错误是如何传播的。

类：Error#

一个通用的 JavaScript <Error> 对象，它不表示错误发生的原因的任何具体情况。Error 对象捕获一个“堆栈跟踪”，详细说明在代码中实例化 Error 的点，并可能提供错误的文本描述。

Node.js 生成的所有错误，包括所有系统和 JavaScript 错误，都将是 Error 类的实例或从 Error 类继承。

new Error(message[, options])#

• message <string>
• options <Object>
  • cause <any> 导致新创建的错误的错误。

创建一个新的 Error 对象，并将 error.message 属性设置为提供的文本消息。如果将对象作为 message 传递，则通过调用 String(message) 生成文本消息。如果提供了 cause 选项，则将其分配给 error.cause 属性。error.stack 属性将表示调用 new Error() 的代码中的点。堆栈跟踪依赖于 V8 的堆栈跟踪 API。堆栈跟踪仅扩展到 (a) 同步代码执行 的开始，或 (b) 由属性 Error.stackTraceLimit 给出的帧数，以较小者为准。

Error.captureStackTrace(targetObject[, constructorOpt])#

• targetObject <Object>
• constructorOpt <Function>

在 targetObject 上创建一个 .stack 属性，当访问该属性时，它将返回一个字符串，表示调用 Error.captureStackTrace() 的代码中的位置。

const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar to `new Error().stack` copy

跟踪的第一行将以 ${myObject.name}: ${myObject.message} 为前缀。

可选的 constructorOpt 参数接受一个函数。如果给定，则所有高于 constructorOpt（包括 constructorOpt）的帧将从生成的堆栈跟踪中省略。

constructorOpt 参数可用于向用户隐藏错误生成实现的详细信息。例如

function a() {
  b();
}

function b() {
  c();
}

function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;

  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}

a(); copy

Error.stackTraceLimit#

• <number>

Error.stackTraceLimit 属性指定堆栈跟踪收集的堆栈帧数（无论是由 new Error().stack 还是 Error.captureStackTrace(obj) 生成的）。

默认值为 10，但可以设置为任何有效的 JavaScript 数字。更改将在值更改之后捕获的任何堆栈跟踪中生效。

如果设置为非数字值或负数，则堆栈跟踪将不会捕获任何帧。

error.cause#

• <any>

如果存在，则 error.cause 属性是 Error 的根本原因。在捕获错误并使用不同的消息或代码抛出新错误时使用它，以便仍然可以访问原始错误。

error.cause 属性通常通过调用 new Error(message, { cause }) 设置。如果未提供 cause 选项，则构造函数不会设置它。

此属性允许链接错误。在序列化 Error 对象时，util.inspect() 如果设置了 error.cause，则会递归序列化 error.cause。

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) copy

error.code#

• <string>

error.code 属性是一个字符串标签，用于标识错误的类型。error.code 是识别错误的最稳定方法。它只会更改 Node.js 的主要版本之间。相比之下，error.message 字符串可能会在 Node.js 的任何版本之间更改。有关特定代码的详细信息，请参见Node.js 错误代码。

error.message#

• <string>

error.message 属性是通过调用 new Error(message) 设置的错误字符串描述。传递给构造函数的 message 也会出现在 Error 的堆栈跟踪的第一行中，但是，在创建 Error 对象后更改此属性可能不会更改堆栈跟踪的第一行（例如，当在更改此属性之前读取 error.stack 时）。

const err = new Error('The message');
console.error(err.message);
// Prints: The message copy

error.stack#

• <string>

error.stack 属性是一个字符串，描述了实例化 Error 时代码中的点。

Error: Things keep happening!
   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) copy

第一行格式化为 <error class name>: <error message>，后面跟着一系列堆栈帧（每行以“at”开头）。每个帧都描述了导致生成错误的代码中的调用站点。V8 尝试为每个函数显示一个名称（按变量名、函数名或对象方法名），但有时它无法找到合适的名称。如果 V8 无法确定函数的名称，则只为该帧显示位置信息。否则，确定的函数名称将显示在括号中附加的位置信息。

帧仅为 JavaScript 函数生成。例如，如果执行同步通过一个名为 cheetahify 的 C++ 附加函数，该函数本身调用一个 JavaScript 函数，则表示 cheetahify 调用的帧将不会出现在堆栈跟踪中

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

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

makeFaster();
// will throw:
//   /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 copy

位置信息将是

• native，如果帧表示 V8 内部调用（如 [].forEach）。
• plain-filename.js:line:column，如果帧表示 Node.js 内部调用。
• /absolute/path/to/file.js:line:column，如果帧表示用户程序（使用 CommonJS 模块系统）或其依赖项中的调用。
• <transport-protocol>:///url/to/module/file.mjs:line:column，如果帧表示用户程序（使用 ES 模块系统）或其依赖项中的调用。

表示堆栈跟踪的字符串在访问error.stack 属性时会延迟生成。

堆栈跟踪捕获的帧数受以下较小值限制：Error.stackTraceLimit 或当前事件循环刻度的可用帧数。

类：AssertionError#

• 扩展：<errors.Error>

指示断言失败。有关详细信息，请参阅类：assert.AssertionError。

类：RangeError#

• 扩展：<errors.Error>

表示提供的参数不在函数可接受值的集合或范围内；无论是数字范围，还是给定函数参数的选项集之外。

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

Node.js 将生成并抛出 RangeError 实例，立即作为参数验证的一种形式。

类：ReferenceError#

• 扩展：<errors.Error>

表示尝试访问未定义的变量。此类错误通常表示代码中的错别字，或程序已损坏。

虽然客户端代码可能会生成并传播这些错误，但实际上，只有 V8 会这样做。

doesNotExist;
// Throws ReferenceError, doesNotExist is not a variable in this program. copy

除非应用程序动态生成并运行代码，否则 ReferenceError 实例表示代码或其依赖项中的错误。

类：SyntaxError#

• 扩展：<errors.Error>

表示程序不是有效的 JavaScript。这些错误可能仅因代码评估而生成并传播。代码评估可能是由于 eval、Function、require 或 vm 导致的。这些错误几乎总是表示程序已损坏。

try {
  require('node:vm').runInThisContext('binary ! isNotOk');
} catch (err) {
  // 'err' will be a SyntaxError.
} copy

SyntaxError 实例在创建它们的上下文中不可恢复 - 它们只能被其他上下文捕获。

类：SystemError#

• 扩展：<errors.Error>

当异常发生在 Node.js 的运行时环境中时，Node.js 会生成系统错误。这些通常发生在应用程序违反操作系统约束时。例如，如果应用程序尝试读取不存在的文件，则会发生系统错误。

• address <string> 如果存在，则表示网络连接失败的地址
• code <string> 字符串错误代码
• dest <string> 如果存在，则在报告文件系统错误时为文件路径目标
• errno <number> 系统提供的错误号
• info <Object> 如果存在，则为有关错误条件的额外详细信息
• message <string> 系统提供的错误的人类可读描述
• path <string> 如果存在，则在报告文件系统错误时为文件路径
• port <number> 如果存在，则为不可用的网络连接端口
• syscall <string> 触发错误的系统调用的名称

error.address#

• <string>

如果存在，则 error.address 是描述网络连接失败的地址的字符串。

error.code#

• <string>

error.code 属性是表示错误代码的字符串。

error.dest#

• <string>

如果存在，则 error.dest 是在报告文件系统错误时的文件路径目标。

error.errno#

• <number>

error.errno 属性是负数，对应于 libuv 错误处理 中定义的错误代码。

在 Windows 上，系统提供的错误号将由 libuv 规范化。

要获取错误代码的字符串表示形式，请使用 util.getSystemErrorName(error.errno)。

error.info#

• <Object>

如果存在，则 error.info 是一个包含有关错误条件的详细信息的对象。

error.message#

• <string>

error.message 是系统提供的错误的人类可读描述。

error.path#

• <string>

如果存在，则 error.path 是包含相关无效路径名的字符串。

error.port#

• <number>

如果存在，则 error.port 是不可用的网络连接端口。

error.syscall#

• <string>

error.syscall 属性是描述失败的 syscall 的字符串。

常见系统错误#

在编写 Node.js 程序时，这是一个常见的系统错误列表。有关完整列表，请参阅 errno(3) 手册页。

• EACCES（权限拒绝）：尝试以其文件访问权限禁止的方式访问文件。

• EADDRINUSE（地址已在使用中）：由于本地系统上的另一台服务器已占用该地址，因此尝试将服务器（net、http 或 https）绑定到本地地址失败。

• ECONNREFUSED（连接被拒绝）：由于目标计算机主动拒绝，因此无法建立连接。这通常是由于尝试连接到外来主机上处于非活动状态的服务所致。

• ECONNRESET（连接被对等方重置）：连接被对等方强制关闭。这通常是由于远程套接字上的连接因超时或重新启动而丢失所致。通常通过 http 和 net 模块遇到。

• EEXIST（文件已存在）：现有文件是操作的目标，而该操作要求目标不存在。

• EISDIR（是目录）：操作预期为文件，但给定的路径名是目录。

• EMFILE（系统中打开的文件过多）：系统允许的最大 文件描述符 数已达到，并且在至少关闭一个文件描述符之前，无法满足另一个描述符的请求。这在一次并行打开多个文件时遇到，尤其是在文件描述符进程限制较低的系统（特别是 macOS）上。要解决限制较低的问题，请在将运行 Node.js 进程的同一 shell 中运行 ulimit -n 2048。

• ENOENT（没有此类文件或目录）：通常由 fs 操作引发，以指示指定路径名的组件不存在。通过给定的路径找不到任何实体（文件或目录）。

• ENOTDIR（不是目录）：给定路径名的组件存在，但不是预期的目录。通常由 fs.readdir 触发。

• ENOTEMPTY（目录不为空）：带有条目的目录是操作的目标，而该操作需要一个空目录，通常是 fs.unlink。

• ENOTFOUND（DNS 查找失败）：指示 DNS 失败，可能是 EAI_NODATA 或 EAI_NONAME。这不是标准 POSIX 错误。

• EPERM（操作不被允许）：尝试执行需要提升权限的操作。

• EPIPE（管道已断开）：对管道、套接字或 FIFO 执行写操作，但没有进程读取数据。通常在 net 和 http 层中遇到，表示正在写入的流的远程端已关闭。

• ETIMEDOUT（操作超时）：连接或发送请求失败，因为连接方在一段时间后没有正确响应。通常由 http 或 net 遇到。通常表示未正确调用 socket.end()。

类：TypeError#

• 扩展 <errors.Error>

表示提供的参数不是允许的类型。例如，将函数传递给期望字符串的参数将是一个 TypeError。

require('node:url').parse(() => { });
// Throws TypeError, since it expected a string. copy

Node.js 将生成并抛出 TypeError 实例立即作为参数验证的一种形式。

异常与错误#

JavaScript 异常是一个值，它作为无效操作的结果或 throw 语句的目标而抛出。虽然不要求这些值是 Error 的实例或继承自 Error 的类，但 Node.js 或 JavaScript 运行时抛出的所有异常将是 Error 的实例。

有些异常在 JavaScript 层是不可恢复的。此类异常总是会导致 Node.js 进程崩溃。示例包括 C++ 层中的 assert() 检查或 abort() 调用。

OpenSSL 错误#

源自 crypto 或 tls 的错误属于 Error 类，除了标准的 .code 和 .message 属性之外，还可能有一些其他特定于 OpenSSL 的属性。

error.opensslErrorStack#

一个错误数组，可以提供有关错误在 OpenSSL 库中的哪个位置发生的上下文。

error.function#

错误源自的 OpenSSL 函数。

error.library#

错误源自的 OpenSSL 库。

error.reason#

描述错误原因的人类可读字符串。

Node.js 错误代码#

ABORT_ERR#

当操作被中止时使用（通常使用 AbortController）。

通常不使用 AbortSignal 的 API 不会引发带有此代码的错误。

此代码不使用常规的 ERR_* 约定，Node.js 错误使用该约定是为了与 Web 平台的 AbortError 兼容。

ERR_ACCESS_DENIED#

一种特殊类型的错误，每当 Node.js 尝试访问受 权限模型 限制的资源时都会触发。

ERR_AMBIGUOUS_ARGUMENT#

函数参数的使用方式表明可能误解了函数签名。当 assert.throws(block, message) 中的 message 参数与 block 抛出的错误消息匹配时，node:assert 模块会引发此错误，因为该用法表明用户认为 message 是预期的消息，而不是 AssertionError 在 block 不抛出时显示的消息。

ERR_ARG_NOT_ITERABLE#

需要一个可迭代参数（即与 for...of 循环一起使用的值），但未提供给 Node.js API。

ERR_ASSERTION#

一种特殊类型的错误，每当 Node.js 检测到永远不应该发生的异常逻辑违规时都会触发。这些通常由 node:assert 模块引发。

ERR_ASYNC_CALLBACK#

尝试将不是函数的内容注册为 AsyncHooks 回调。

ERR_ASYNC_TYPE#

异步资源的类型无效。如果使用公共嵌入器 API，用户还可以定义自己的类型。

ERR_BROTLI_COMPRESSION_FAILED#

传递给 Brotli 流的数据未成功压缩。

ERR_BROTLI_INVALID_PARAM#

在构建 Brotli 流期间传递了无效的参数键。

ERR_BUFFER_CONTEXT_NOT_AVAILABLE#

尝试在未与 Node.js 实例关联的 JS 引擎上下文中，从附加组件或嵌入器代码创建 Node.js Buffer 实例。传递给 Buffer 方法的数据将在方法返回时释放。

遇到此错误时，创建 Buffer 实例的一种可能的替代方法是创建常规的 Uint8Array，它仅在结果对象的原型中有所不同。Uint8Array 通常在 Buffer 所在的所有 Node.js 核心 API 中被接受；它们在所有上下文中都可用。

ERR_BUFFER_OUT_OF_BOUNDS#

尝试对 Buffer 的边界之外进行操作。

ERR_BUFFER_TOO_LARGE#

尝试创建大于最大允许大小的 Buffer。

ERR_CANNOT_WATCH_SIGINT#

Node.js 无法监视 SIGINT 信号。

ERR_CHILD_CLOSED_BEFORE_REPLY#

子进程在父进程收到回复之前关闭。

ERR_CHILD_PROCESS_IPC_REQUIRED#

在未指定 IPC 通道的情况下派生子进程时使用。

ERR_CHILD_PROCESS_STDIO_MAXBUFFER#

当主进程尝试从子进程的 STDERR/STDOUT 读取数据，并且数据的长度大于 maxBuffer 选项时使用。

ERR_CLOSED_MESSAGE_PORT#

尝试在已关闭状态下使用 MessagePort 实例，通常是在调用 .close() 之后。

ERR_CONSOLE_WRITABLE_STREAM#

Console 在没有 stdout 流的情况下被实例化，或者 Console 具有不可写的 stdout 或 stderr 流。

ERR_CONSTRUCT_CALL_INVALID#

调用了不可调用的类构造函数。

ERR_CONSTRUCT_CALL_REQUIRED#

在没有 new 的情况下调用了类的构造函数。

ERR_CONTEXT_NOT_INITIALIZED#

传递到 API 中的 vm 上下文尚未初始化。这可能发生在创建上下文期间发生错误（并被捕获）时，例如，在创建上下文时分配失败或达到最大调用堆栈大小时。

ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED#

请求了 OpenSSL 引擎（例如，通过 clientCertEngine 或 privateKeyEngine TLS 选项），而所使用的 OpenSSL 版本不支持该引擎，可能是由于编译时标志 OPENSSL_NO_ENGINE。

ERR_CRYPTO_ECDH_INVALID_FORMAT#

将 format 参数的无效值传递给了 crypto.ECDH() 类 getPublicKey() 方法。

ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY#

将 key 参数的无效值传递给了 crypto.ECDH() 类 computeSecret() 方法。这意味着公钥位于椭圆曲线之外。

ERR_CRYPTO_ENGINE_UNKNOWN#

传递给 require('node:crypto').setEngine() 的加密引擎标识符无效。

ERR_CRYPTO_FIPS_FORCED#

使用了 --force-fips 命令行参数，但尝试在 node:crypto 模块中启用或禁用 FIPS 模式。

ERR_CRYPTO_FIPS_UNAVAILABLE#

尝试启用或禁用 FIPS 模式，但 FIPS 模式不可用。

ERR_CRYPTO_HASH_FINALIZED#

hash.digest() 被多次调用。hash.digest() 方法必须每个 Hash 对象实例调用不超过一次。

ERR_CRYPTO_HASH_UPDATE_FAILED#

hash.update() 因任何原因而失败。这种情况很少发生，甚至可能永远不会发生。

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#

提供了无效的 JSON Web Key。

ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE#

给定的加密密钥对象的类型对于尝试的操作无效。

ERR_CRYPTO_INVALID_KEYLEN#

提供了无效的密钥长度。

ERR_CRYPTO_INVALID_KEYPAIR#

提供了无效的密钥对。

ERR_CRYPTO_INVALID_KEYTYPE#

提供了无效的密钥类型。

ERR_CRYPTO_INVALID_MESSAGELEN#

提供了无效的消息长度。

ERR_CRYPTO_INVALID_SCRYPT_PARAMS#

提供了无效的 scrypt 算法参数。

ERR_CRYPTO_INVALID_STATE#

在状态无效的对象上使用了加密方法。例如，在调用 cipher.final() 之前调用 cipher.getAuthTag()。

ERR_CRYPTO_INVALID_TAG_LENGTH#

提供了无效的身份验证标记长度。

ERR_CRYPTO_JOB_INIT_FAILED#

异步加密操作的初始化失败。

ERR_CRYPTO_JWK_UNSUPPORTED_CURVE#

密钥的椭圆曲线未注册，无法在 JSON Web Key 椭圆曲线注册表 中使用。

ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE#

密钥的非对称密钥类型未注册，无法在 JSON Web Key 类型注册表 中使用。

ERR_CRYPTO_OPERATION_FAILED#

由于其他未指定的原因，加密操作失败。

ERR_CRYPTO_PBKDF2_ERROR#

PBKDF2 算法由于未指定的原因而失败。OpenSSL 没有提供更多详细信息，因此 Node.js 也没有提供。

ERR_CRYPTO_SCRYPT_INVALID_PARAMETER#

一个或多个 crypto.scrypt() 或 crypto.scryptSync() 参数超出了其合法范围。

ERR_CRYPTO_SCRYPT_NOT_SUPPORTED#

Node.js 在编译时未启用 scrypt 支持。官方发布的二进制文件不可能出现这种情况，但自定义版本（包括发行版版本）中可能会出现这种情况。

ERR_CRYPTO_SIGN_KEY_REQUIRED#

未向 sign.sign() 方法提供签名 key。

ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH#

crypto.timingSafeEqual() 被调用时，Buffer、TypedArray 或 DataView 参数的长度不同。

ERR_CRYPTO_UNKNOWN_CIPHER#

指定了未知的密码。

ERR_CRYPTO_UNKNOWN_DH_GROUP#

给出了未知的 Diffie-Hellman 组名称。有关有效组名称的列表，请参阅 crypto.getDiffieHellman()。

ERR_CRYPTO_UNSUPPORTED_OPERATION#

尝试调用不受支持的加密操作。

ERR_DEBUGGER_ERROR#

调试器 出现错误。

ERR_DEBUGGER_STARTUP_ERROR#

调试器 超时，等待所需的主机/端口空闲。

ERR_DLOPEN_DISABLED#

已使用 --no-addons 禁用加载本机加载项。

ERR_DLOPEN_FAILED#

调用 process.dlopen() 失败。

ERR_DIR_CLOSED#

fs.Dir 之前已关闭。

ERR_DIR_CONCURRENT_OPERATION#

尝试在具有正在进行的异步操作的 fs.Dir 上执行同步读取或关闭调用。

ERR_DNS_SET_SERVERS_FAILED#

c-ares 无法设置 DNS 服务器。

ERR_DOMAIN_CALLBACK_NOT_AVAILABLE#

node:domain 模块不可用，因为它无法建立所需的错误处理挂钩，因为 process.setUncaughtExceptionCaptureCallback() 已在较早的时间点被调用。

ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE#

process.setUncaughtExceptionCaptureCallback() 无法调用，因为 node:domain 模块已在较早的时间点加载。

堆栈跟踪已扩展，包括加载 node:domain 模块的时间点。

ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION#

v8.startupSnapshot.setDeserializeMainFunction() 无法调用，因为它之前已调用过。

ERR_ENCODING_INVALID_ENCODED_DATA#

提供给 TextDecoder() API 的数据根据提供的编码无效。

ERR_ENCODING_NOT_SUPPORTED#

提供给 TextDecoder() API 的编码不是 WHATWG 支持的编码 之一。

ERR_EVAL_ESM_CANNOT_PRINT#

--print 无法与 ESM 输入一起使用。

ERR_EVENT_RECURSION#

尝试在 EventTarget 上递归分派事件时引发。

ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE#

JS 执行上下文与 Node.js 环境无关。当 Node.js 用作嵌入式库并且 JS 引擎的一些挂钩未正确设置时，可能会发生这种情况。

ERR_FALSY_VALUE_REJECTION#

通过 util.callbackify() 回调化的 Promise 被虚假值拒绝。

ERR_FEATURE_UNAVAILABLE_ON_PLATFORM#

在使用当前运行 Node.js 的平台不可用的功能时使用。

ERR_FS_CP_DIR_TO_NON_DIR#

尝试使用 fs.cp() 将目录复制到非目录（文件、符号链接等）。

ERR_FS_CP_EEXIST#

尝试使用 fs.cp() 覆盖已存在的文件，且 force 和 errorOnExist 设置为 true。

ERR_FS_CP_EINVAL#

使用 fs.cp() 时，src 或 dest 指向无效路径。

ERR_HTTP_BODY_NOT_ALLOWED#

向不允许内容的 HTTP 响应中写入时引发错误。

ERR_HTTP_CONTENT_LENGTH_MISMATCH#

响应正文大小与指定的 content-length 标头值不匹配。

ERR_FS_CP_FIFO_PIPE#

尝试使用 fs.cp() 复制命名管道。

ERR_FS_CP_NON_DIR_TO_DIR#

尝试使用 fs.cp() 将非目录（文件、符号链接等）复制到目录。

ERR_FS_CP_SOCKET#

尝试使用 fs.cp() 复制到套接字。

ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY#

使用 fs.cp() 时，dest 中的符号链接指向 src 的子目录。

ERR_FS_CP_UNKNOWN#

尝试使用 fs.cp() 复制到未知的文件类型。

ERR_FS_EISDIR#

路径是一个目录。

ERR_FS_FILE_TOO_LARGE#

尝试读取的文件大小大于 Buffer 允许的最大大小。

ERR_FS_INVALID_SYMLINK_TYPE#

传递给 fs.symlink() 或 fs.symlinkSync() 方法的符号链接类型无效。

ERR_HTTP_HEADERS_SENT#

尝试在标头已发送后添加更多标头。

ERR_HTTP_INVALID_HEADER_VALUE#

指定了无效的 HTTP 标头值。

ERR_HTTP_INVALID_STATUS_CODE#

状态代码超出常规状态代码范围 (100-999)。

ERR_HTTP_REQUEST_TIMEOUT#

客户端未在允许的时间内发送整个请求。

ERR_HTTP_SOCKET_ASSIGNED#

给定的 ServerResponse 已分配了一个套接字。

ERR_HTTP_SOCKET_ENCODING#

根据 RFC 7230 第 3 节，不允许更改套接字编码。

ERR_HTTP_TRAILER_INVALID#

Trailer 标头已设置，尽管传输编码不支持该标头。

ERR_HTTP2_ALTSVC_INVALID_ORIGIN#

HTTP/2 ALTSVC 帧需要一个有效的来源。

ERR_HTTP2_ALTSVC_LENGTH#

HTTP/2 ALTSVC 帧的最大有效载荷字节数限制为 16,382。

ERR_HTTP2_CONNECT_AUTHORITY#

对于使用 CONNECT 方法的 HTTP/2 请求，需要 :authority 伪标头。

ERR_HTTP2_CONNECT_PATH#

对于使用 CONNECT 方法的 HTTP/2 请求，禁止使用 :path 伪标头。

ERR_HTTP2_CONNECT_SCHEME#

对于使用 CONNECT 方法的 HTTP/2 请求，禁止使用 :scheme 伪标头。

ERR_HTTP2_ERROR#

发生了非特定 HTTP/2 错误。

ERR_HTTP2_GOAWAY_SESSION#

在 Http2Session 从连接的对等方收到 GOAWAY 帧后，可能无法打开新的 HTTP/2 流。

ERR_HTTP2_HEADER_SINGLE_VALUE#

为要求仅具有单个值的 HTTP/2 标头字段提供了多个值。

ERR_HTTP2_HEADERS_AFTER_RESPOND#

在启动 HTTP/2 响应后指定了其他标头。

ERR_HTTP2_HEADERS_SENT#

尝试发送多个响应头。

ERR_HTTP2_INFO_STATUS_NOT_ALLOWED#

HTTP/2 响应中，信息性 HTTP 状态代码（1xx）不能设置为响应状态代码。

ERR_HTTP2_INVALID_CONNECTION_HEADERS#

禁止在 HTTP/2 请求和响应中使用特定于 HTTP/1 连接的头。

ERR_HTTP2_INVALID_HEADER_VALUE#

指定了无效的 HTTP/2 头值。

ERR_HTTP2_INVALID_INFO_STATUS#

指定了无效的 HTTP 信息状态代码。信息状态代码必须是介于 100 和 199（包括）之间的整数。

ERR_HTTP2_INVALID_ORIGIN#

HTTP/2 ORIGIN 帧需要有效的来源。

ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH#

传递给 http2.getUnpackedSettings() API 的输入 Buffer 和 Uint8Array 实例的长度必须是 6 的倍数。

ERR_HTTP2_INVALID_PSEUDOHEADER#

只能使用有效的 HTTP/2 伪头（:status、:path、:authority、:scheme 和 :method）。

ERR_HTTP2_INVALID_SESSION#

对已销毁的 Http2Session 对象执行了操作。

ERR_HTTP2_INVALID_SETTING_VALUE#

为 HTTP/2 设置指定了无效值。

ERR_HTTP2_INVALID_STREAM#

对已销毁的流执行了操作。

ERR_HTTP2_MAX_PENDING_SETTINGS_ACK#

每当向已连接的对等方发送 HTTP/2 SETTINGS 帧时，对等方都必须发送确认，表明它已接收并应用了新的 SETTINGS。默认情况下，在任何给定时间最多可以发送一定数量未确认的 SETTINGS 帧。当达到该限制时，将使用此错误代码。

ERR_HTTP2_NESTED_PUSH#

尝试从推送流中启动新的推送流。不允许嵌套推送流。

ERR_HTTP2_NO_MEM#

使用 http2session.setLocalWindowSize(windowSize) API 时内存不足。

ERR_HTTP2_NO_SOCKET_MANIPULATION#

尝试直接操作（读取、写入、暂停、恢复等）附加到 Http2Session 的套接字。

ERR_HTTP2_ORIGIN_LENGTH#

HTTP/2 ORIGIN 帧的长度限制为 16382 字节。

ERR_HTTP2_OUT_OF_STREAMS#

在单个 HTTP/2 会话上创建的流数量达到最大限制。

ERR_HTTP2_PAYLOAD_FORBIDDEN#

为禁止有效负载的 HTTP 响应代码指定了消息有效负载。

ERR_HTTP2_PING_CANCEL#

已取消 HTTP/2 ping。

ERR_HTTP2_PING_LENGTH#

HTTP/2 ping 有效负载的长度必须恰好为 8 字节。

ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED#

HTTP/2 伪首部已不当使用。伪首部是以下划线 : 开头的首部键名称。

ERR_HTTP2_PUSH_DISABLED#

尝试创建已被客户端禁用的推送流。

ERR_HTTP2_SEND_FILE#

尝试使用 Http2Stream.prototype.responseWithFile() API 发送目录。

ERR_HTTP2_SEND_FILE_NOSEEK#

尝试使用 Http2Stream.prototype.responseWithFile() API 发送常规文件以外的内容，但提供了 offset 或 length 选项。

ERR_HTTP2_SESSION_ERROR#

Http2Session 已关闭，且错误代码非零。

ERR_HTTP2_SETTINGS_CANCEL#

Http2Session 设置已取消。

ERR_HTTP2_SOCKET_BOUND#

尝试将 Http2Session 对象连接到已绑定到另一个 Http2Session 对象的 net.Socket 或 tls.TLSSocket。

ERR_HTTP2_SOCKET_UNBOUND#

尝试使用已关闭的 Http2Session 的 socket 属性。

ERR_HTTP2_STATUS_101#

HTTP/2 中禁止使用 101 信息状态代码。

ERR_HTTP2_STATUS_INVALID#

已指定无效的 HTTP 状态代码。状态代码必须是 100 到 599（含）之间的整数。

ERR_HTTP2_STREAM_CANCEL#

在向已连接的对等方传输任何数据之前，Http2Stream 已被销毁。

ERR_HTTP2_STREAM_ERROR#

RST_STREAM 帧中已指定非零错误代码。

ERR_HTTP2_STREAM_SELF_DEPENDENCY#

在设置 HTTP/2 流的优先级时，该流可能会被标记为父流的依赖项。当尝试将流标记为其自身的依赖项时，会使用此错误代码。

ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS#

已超过支持的自定义设置数 (10)。

ERR_HTTP2_TOO_MANY_INVALID_FRAMES#

通过 maxSessionInvalidFrames 选项指定的对等方发送的可接受的无效 HTTP/2 协议帧的限制已超出。

ERR_HTTP2_TRAILERS_ALREADY_SENT#

尾部标头已在 Http2Stream 上发送。

ERR_HTTP2_TRAILERS_NOT_READY#

在 Http2Stream 对象上发出 'wantTrailers' 事件后，才能调用 http2stream.sendTrailers() 方法。仅当为 Http2Stream 设置 waitForTrailers 选项时，才会发出 'wantTrailers' 事件。

ERR_HTTP2_UNSUPPORTED_PROTOCOL#

http2.connect() 传递了一个使用 http: 或 https: 以外任何协议的 URL。

ERR_ILLEGAL_CONSTRUCTOR#

尝试使用非公有构造函数构造一个对象。

ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE#

提供了导入 type 属性，但指定的模块类型不同。

ERR_IMPORT_ATTRIBUTE_MISSING#

缺少导入属性，阻止导入指定的模块。

ERR_IMPORT_ATTRIBUTE_UNSUPPORTED#

此版本的 Node.js 不支持导入属性。

ERR_INCOMPATIBLE_OPTION_PAIR#

一对选项不兼容，不能同时使用。

ERR_INPUT_TYPE_NOT_ALLOWED#

--input-type 标志用于尝试执行文件。此标志只能与通过 --eval、--print 或 STDIN 输入一起使用。

ERR_INSPECTOR_ALREADY_ACTIVATED#

使用 node:inspector 模块时，尝试在已开始在端口上侦听时激活检查器。在不同地址上激活检查器之前，请使用 inspector.close()。

ERR_INSPECTOR_ALREADY_CONNECTED#

使用 node:inspector 模块时，在检查器已连接时尝试连接。

ERR_INSPECTOR_CLOSED#

使用 node:inspector 模块时，在会话已关闭后尝试使用检查器。

ERR_INSPECTOR_COMMAND#

通过 node:inspector 模块发出命令时发生错误。

ERR_INSPECTOR_NOT_ACTIVE#

调用 inspector.waitForDebugger() 时，inspector 未处于活动状态。

ERR_INSPECTOR_NOT_AVAILABLE#

node:inspector 模块不可用。

ERR_INSPECTOR_NOT_CONNECTED#

使用 node:inspector 模块时，在检查器连接之前尝试使用检查器。

ERR_INSPECTOR_NOT_WORKER#

在主线程上调用了只能在工作线程中使用的 API。

ERR_INTERNAL_ASSERTION#

Node.js 中存在错误，或 Node.js 内部使用不正确。要修复错误，请在 https://github.com/nodejs/node/issues 处提交问题。

ERR_INVALID_ADDRESS_FAMILY#

Node.js API 未识别提供的地址族。

ERR_INVALID_ARG_TYPE#

向 Node.js API 传递了类型错误的参数。

ERR_INVALID_ARG_VALUE#

为给定参数传递了无效或不受支持的值。

ERR_INVALID_ASYNC_ID#

使用 AsyncHooks 传递了无效的 asyncId 或 triggerAsyncId。id 小于 -1 的情况绝不会发生。

ERR_INVALID_BUFFER_SIZE#

对 Buffer 执行了交换，但其大小与操作不兼容。

ERR_INVALID_CHAR#

在标头中检测到无效字符。

ERR_INVALID_CURSOR_POS#

在未指定列的情况下，无法将给定流上的游标移动到指定行。

ERR_INVALID_FD#

文件描述符 ('fd') 无效（例如，它是一个负值）。

ERR_INVALID_FD_TYPE#

文件描述符 ('fd') 类型无效。

ERR_INVALID_FILE_URL_HOST#

使用 file: URL 的 Node.js API（例如 fs 模块中的某些函数）遇到了具有不兼容主机的文件 URL。此情况仅可能发生在仅支持 localhost 或空主机的类 Unix 系统上。

ERR_INVALID_FILE_URL_PATH#

使用 file: URL 的 Node.js API（例如 fs 模块中的某些函数）遇到了具有不兼容路径的文件 URL。确定是否可以使用路径的确切语义取决于平台。

ERR_INVALID_HANDLE_TYPE#

尝试通过 IPC 通信通道向子进程发送不受支持的“句柄”。有关更多信息，请参见 subprocess.send() 和 process.send()。

ERR_INVALID_HTTP_TOKEN#

提供了一个无效的 HTTP 令牌。

ERR_INVALID_IP_ADDRESS#

IP 地址无效。

ERR_INVALID_MIME_SYNTAX#

MIME 语法无效。

ERR_INVALID_MODULE#

尝试加载不存在或其他无效的模块。

ERR_INVALID_MODULE_SPECIFIER#

导入的模块字符串是无效的 URL、包名称或包子路径说明符。

ERR_INVALID_OBJECT_DEFINE_PROPERTY#

为对象的属性设置无效属性时出错。

ERR_INVALID_PACKAGE_CONFIG#

无效的 package.json 文件解析失败。

ERR_INVALID_PACKAGE_TARGET#

package.json "exports" 字段包含无效的目标映射值，用于尝试的模块解析。

ERR_INVALID_PERFORMANCE_MARK#

在使用 Performance Timing API (perf_hooks) 时，性能标记无效。

ERR_INVALID_PROTOCOL#

传递给 http.request() 的 options.protocol 无效。

ERR_INVALID_REPL_EVAL_CONFIG#

在 REPL 配置中设置了 breakEvalOnSigint 和 eval 选项，但不支持这样做。

ERR_INVALID_REPL_INPUT#

输入不能在 REPL 中使用。此错误的使用条件在 REPL 文档中进行了描述。

ERR_INVALID_RETURN_PROPERTY#

在执行时，如果函数选项未为其返回的对象属性之一提供有效值，则抛出此错误。

ERR_INVALID_RETURN_PROPERTY_VALUE#

在执行时，如果函数选项未为其返回的对象属性之一提供预期的值类型，则抛出此错误。

ERR_INVALID_RETURN_VALUE#

在执行时，如果函数选项未返回预期的值类型，则抛出此错误，例如当预期函数返回一个 Promise 时。

ERR_INVALID_STATE#

表示由于状态无效，无法完成操作。例如，对象可能已被销毁，或可能正在执行其他操作。

ERR_INVALID_SYNC_FORK_INPUT#

将 Buffer、TypedArray、DataView 或 string 作为 stdio 输入提供给异步 fork。有关更多信息，请参阅 child_process 模块的文档。

ERR_INVALID_THIS#

使用不兼容的 this 值调用了 Node.js API 函数。

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

const buf = Buffer.alloc(1);
urlSearchParams.has.call(buf, 'foo');
// Throws a TypeError with code 'ERR_INVALID_THIS' copy

ERR_INVALID_TUPLE#

提供给 WHATWG URLSearchParams 构造函数 的 iterable 中的一个元素不表示 [name, value] 元组 - 也就是说，如果一个元素不可迭代，或者不恰好由两个元素组成。

ERR_INVALID_URI#

传递了一个无效的 URI。

ERR_INVALID_URL#

一个无效的 URL 传递给了 WHATWG URL 构造函数 或旧版 url.parse() 进行解析。抛出的错误对象通常有一个附加属性 'input'，其中包含解析失败的 URL。

ERR_INVALID_URL_SCHEME#

尝试将不兼容方案（协议）的 URL 用于特定目的。它仅用于 WHATWG URL API 在 fs 模块中的支持（仅接受具有 'file' 方案的 URL），但将来也可能在其他 Node.js API 中使用。

ERR_IPC_CHANNEL_CLOSED#

尝试使用已关闭的 IPC 通信通道。

ERR_IPC_DISCONNECTED#

尝试断开已断开的 IPC 通信通道。有关更多信息，请参阅 child_process 模块的文档。

ERR_IPC_ONE_PIPE#

尝试使用多个 IPC 通信通道创建子 Node.js 进程。有关更多信息，请参阅 child_process 模块的文档。

ERR_IPC_SYNC_FORK#

尝试使用同步分叉的 Node.js 进程打开 IPC 通信通道。有关更多信息，请参阅 child_process 模块的文档。

ERR_LOADER_CHAIN_INCOMPLETE#

ESM 加载器挂钩返回时未调用 next() 且未明确发出短路信号。

ERR_MANIFEST_ASSERT_INTEGRITY#

尝试加载资源，但资源与策略清单定义的完整性不匹配。有关详细信息，请参阅策略清单的文档。

ERR_MANIFEST_DEPENDENCY_MISSING#

尝试加载资源，但资源未列为尝试加载它的位置的依赖项。有关详细信息，请参阅策略清单的文档。

ERR_MANIFEST_INTEGRITY_MISMATCH#

尝试加载策略清单，但清单中有多个资源条目不匹配。更新清单条目以匹配，以解决此错误。有关详细信息，请参阅策略清单的文档。

ERR_MANIFEST_INVALID_RESOURCE_FIELD#

策略清单资源的一个字段具有无效值。更新清单条目以匹配，以解决此错误。有关详细信息，请参阅策略清单的文档。

ERR_MANIFEST_INVALID_SPECIFIER#

策略清单资源的一个依赖项映射具有无效值。更新清单条目以匹配，以解决此错误。有关详细信息，请参阅策略清单的文档。

ERR_MANIFEST_PARSE_POLICY#

尝试加载策略清单，但无法解析清单。有关详细信息，请参阅策略清单的文档。

ERR_MANIFEST_TDZ#

尝试从策略清单中读取，但清单初始化尚未进行。这可能是 Node.js 中的错误。

ERR_MANIFEST_UNKNOWN_ONERROR#

已加载策略清单，但其“onerror”行为具有未知值。有关详细信息，请参阅策略清单的文档。

ERR_MEMORY_ALLOCATION_FAILED#

尝试分配内存（通常在 C++ 层），但失败了。

ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE#

发送到 MessagePort 的消息无法在目标 vm Context 中反序列化。目前，并非所有 Node.js 对象都可以在任何上下文中成功实例化，而且在这种情况下，尝试使用 postMessage() 传输它们可能会在接收端失败。

ERR_METHOD_NOT_IMPLEMENTED#

需要一个方法，但未实现。

ERR_MISSING_ARGS#

未传递 Node.js API 的必需参数。这仅用于严格遵守 API 规范（在某些情况下，它可能接受 func(undefined) 但不接受 func()）。在大多数本机 Node.js API 中，func(undefined) 和 func() 的处理方式相同，并且可以使用 ERR_INVALID_ARG_TYPE 错误代码。

ERR_MISSING_OPTION#

对于接受选项对象的 API，某些选项可能是必需的。如果缺少必需的选项，则会抛出此代码。

ERR_MISSING_PASSPHRASE#

尝试读取加密密钥，但未指定密码。

ERR_MISSING_PLATFORM_FOR_WORKER#

此 Node.js 实例使用的 V8 平台不支持创建 Worker。这是因为嵌入器不支持 Worker。特别是，Node.js 的标准版本不会出现此错误。

ERR_MODULE_NOT_FOUND#

在尝试执行 import 操作或加载程序入口点时，ECMAScript 模块加载器无法解析模块文件。

ERR_MULTIPLE_CALLBACK#

回调被调用多次。

回调几乎总是只被调用一次，因为查询可以被满足或被拒绝，但不可能同时满足和拒绝。通过多次调用回调可以实现后者。

ERR_NAPI_CONS_FUNCTION#

使用 Node-API 时，传递的构造函数不是一个函数。

ERR_NAPI_INVALID_DATAVIEW_ARGS#

调用 napi_create_dataview() 时，给定的 offset 超出了 dataview 的范围，或者 offset + length 大于给定 buffer 的长度。

ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT#

调用 napi_create_typedarray() 时，提供的 offset 不是元素大小的倍数。

ERR_NAPI_INVALID_TYPEDARRAY_LENGTH#

调用 napi_create_typedarray() 时，(length * size_of_element) + byte_offset 大于给定 buffer 的长度。

ERR_NAPI_TSFN_CALL_JS#

调用线程安全函数的 JavaScript 部分时出错。

ERR_NAPI_TSFN_GET_UNDEFINED#

尝试获取 JavaScript undefined 值时出错。

ERR_NAPI_TSFN_START_IDLE_LOOP#

在主线程上，将值从与线程安全函数关联的队列中移除，并在空闲循环中进行。此错误表示在尝试启动循环时出错。

ERR_NAPI_TSFN_STOP_IDLE_LOOP#

队列中没有更多项目后，必须暂停空闲循环。此错误表示空闲循环无法停止。

ERR_NOT_BUILDING_SNAPSHOT#

尝试使用只能在构建 V8 启动快照时使用的操作，即使 Node.js 没有构建快照。

ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION#

当不在单可执行应用程序中时，无法执行操作。

ERR_NOT_SUPPORTED_IN_SNAPSHOT#

尝试执行在构建启动快照时不受支持的操作。

ERR_NO_CRYPTO#

尝试使用加密功能，而 Node.js 并未使用 OpenSSL 加密支持进行编译。

ERR_NO_ICU#

尝试使用需要 ICU 的功能，但 Node.js 并未使用 ICU 支持进行编译。

ERR_NON_CONTEXT_AWARE_DISABLED#

在不允许非上下文感知的本机加载项的进程中加载了非上下文感知的本机加载项。

ERR_OUT_OF_RANGE#

给定值超出接受范围。

ERR_PACKAGE_IMPORT_NOT_DEFINED#

package.json "imports" 字段未定义给定的内部包说明符映射。

ERR_PACKAGE_PATH_NOT_EXPORTED#

package.json "exports" 字段未导出请求的子路径。由于导出是封装的，因此无法通过包解析导入未导出的私有内部模块，除非使用绝对 URL。

ERR_PARSE_ARGS_INVALID_OPTION_VALUE#

当 strict 设置为 true 时，如果为 <string> 类型的选项提供了 <boolean> 值，或者为 <boolean> 类型的选项提供了 <string> 值，则由 util.parseArgs() 抛出。

ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL#

当提供了位置参数且 allowPositionals 设置为 false 时，由 util.parseArgs() 抛出。

ERR_PARSE_ARGS_UNKNOWN_OPTION#

当 strict 设置为 true 时，如果某个参数未在 options 中配置，则由 util.parseArgs() 抛出。

ERR_PERFORMANCE_INVALID_TIMESTAMP#

为性能标记或度量提供了无效的时间戳值。

ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS#

为性能度量提供了无效的选项。

ERR_PROTO_ACCESS#

使用 --disable-proto=throw 禁止访问 Object.prototype.__proto__。应使用 Object.getPrototypeOf 和 Object.setPrototypeOf 来获取和设置对象的原型。

ERR_REQUIRE_ESM#

尝试require()一个ES 模块。

ERR_SCRIPT_EXECUTION_INTERRUPTED#

脚本执行被SIGINT中断（例如，按下了Ctrl+C）。

ERR_SCRIPT_EXECUTION_TIMEOUT#

脚本执行超时，可能是由于正在执行的脚本中存在错误。

ERR_SERVER_ALREADY_LISTEN#

当net.Server已在监听时，调用了server.listen()方法。这适用于net.Server的所有实例，包括 HTTP、HTTPS 和 HTTP/2 Server实例。

ERR_SERVER_NOT_RUNNING#

当net.Server未运行时，调用了server.close()方法。这适用于net.Server的所有实例，包括 HTTP、HTTPS 和 HTTP/2 Server实例。

ERR_SINGLE_EXECUTABLE_APPLICATION_ASSET_NOT_FOUND#

将密钥传递给单可执行应用程序 API 以标识资产，但找不到匹配项。

ERR_SOCKET_ALREADY_BOUND#

尝试绑定已绑定的套接字。

ERR_SOCKET_BAD_BUFFER_SIZE#

在dgram.createSocket()中的recvBufferSize或sendBufferSize选项中传递了无效（负）大小。

ERR_SOCKET_BAD_PORT#

一个期望端口 >= 0 和 < 65536 的 API 函数收到一个无效值。

ERR_SOCKET_BAD_TYPE#

一个期望套接字类型（udp4或udp6）的 API 函数收到一个无效值。

ERR_SOCKET_BUFFER_SIZE#

使用 dgram.createSocket() 时，无法确定接收或发送 Buffer 的大小。

ERR_SOCKET_CLOSED#

尝试对已关闭的套接字进行操作。

ERR_SOCKET_CLOSED_BEFORE_CONNECTION#

在连接套接字上调用 net.Socket.write() 时，在建立连接之前套接字已关闭。

ERR_SOCKET_CONNECTION_TIMEOUT#

使用系列自动选择算法时，套接字无法在允许的超时时间内连接到 DNS 返回的任何地址。

ERR_SOCKET_DGRAM_IS_CONNECTED#

对已连接的套接字调用了 dgram.connect()。

ERR_SOCKET_DGRAM_NOT_CONNECTED#

对已断开的套接字调用了 dgram.disconnect() 或 dgram.remoteAddress()。

ERR_SOCKET_DGRAM_NOT_RUNNING#

进行了调用，但 UDP 子系统未运行。

ERR_SRI_PARSE#

为子资源完整性检查提供了字符串，但无法解析。通过查看 子资源完整性规范，检查完整性属性的格式。

ERR_STREAM_ALREADY_FINISHED#

调用了无法完成的流方法，因为流已完成。

ERR_STREAM_CANNOT_PIPE#

尝试对 Writable 流调用 stream.pipe()。

ERR_STREAM_DESTROYED#

调用了一个流方法，该方法无法完成，因为已使用 stream.destroy() 销毁了流。

ERR_STREAM_NULL_VALUES#

尝试使用 null 块调用 stream.write()。

ERR_STREAM_PREMATURE_CLOSE#

stream.finished() 和 stream.pipeline() 返回的错误，当流或管道在没有明确错误的情况下非正常结束时。

ERR_STREAM_PUSH_AFTER_EOF#

尝试在将 null(EOF) 推送到流后调用 stream.push()。

ERR_STREAM_UNSHIFT_AFTER_END_EVENT#

尝试在发出 'end' 事件后调用 stream.unshift()。

ERR_STREAM_WRAP#

如果在 Socket 上设置了字符串解码器或解码器处于 objectMode，则防止中止。

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

instance.setEncoding('utf8'); copy

ERR_STREAM_WRITE_AFTER_END#

尝试在调用 stream.end() 之后调用 stream.write()。

ERR_STRING_TOO_LONG#

尝试创建的字符串长度超过允许的最大长度。

ERR_SYNTHETIC#

用于捕获诊断报告的调用堆栈的人工错误对象。

ERR_SYSTEM_ERROR#

Node.js 进程中发生了未指定或非特定的系统错误。错误对象将具有一个 err.info 对象属性，其中包含其他详细信息。

ERR_TAP_LEXER_ERROR#

表示失败的词法分析器状态的错误。

ERR_TAP_PARSER_ERROR#

表示失败的解析器状态的错误。可以通过 cause 属性获得有关导致错误的标记的其他信息。

ERR_TAP_VALIDATION_ERROR#

此错误表示 TAP 验证失败。

ERR_TEST_FAILURE#

此错误表示测试失败。可以通过 cause 属性获得有关失败的更多信息。failureType 属性指定在发生失败时测试正在执行的操作。

ERR_TLS_ALPN_CALLBACK_INVALID_RESULT#

当 ALPNCallback 返回的值不在客户端提供的 ALPN 协议列表中时，将引发此错误。

ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS#

如果 TLS 选项同时包含 ALPNProtocols 和 ALPNCallback，则在创建 TLSServer 时将引发此错误。这些选项互斥。

ERR_TLS_CERT_ALTNAME_FORMAT#

如果用户提供的 subjectaltname 属性违反编码规则，则 checkServerIdentity 将引发此错误。Node.js 本身生成的证书对象始终符合编码规则，绝不会导致此错误。

ERR_TLS_CERT_ALTNAME_INVALID#

在使用 TLS 时，对等方的主机名/IP 与其证书中的任何 subjectAltNames 都不匹配。

ERR_TLS_DH_PARAM_SIZE#

在使用 TLS 时，为 Diffie-Hellman (DH) 密钥协商协议提供的参数太小。默认情况下，密钥长度必须大于或等于 1024 位才能避免漏洞，尽管强烈建议使用 2048 位或更大的密钥以获得更强的安全性。

ERR_TLS_HANDSHAKE_TIMEOUT#

TLS/SSL 握手超时。在这种情况下，服务器还必须中止连接。

ERR_TLS_INVALID_CONTEXT#

上下文必须是 SecureContext。

ERR_TLS_INVALID_PROTOCOL_METHOD#

指定的 secureProtocol 方法无效。它要么未知，要么因为不安全而被禁用。

ERR_TLS_INVALID_PROTOCOL_VERSION#

有效的 TLS 协议版本是 'TLSv1'、'TLSv1.1' 或 'TLSv1.2'。

ERR_TLS_INVALID_STATE#

TLS 套接字必须已连接且安全建立。在继续之前，确保已发出“安全”事件。

ERR_TLS_PROTOCOL_VERSION_CONFLICT#

尝试设置 TLS 协议 minVersion 或 maxVersion 与尝试显式设置 secureProtocol 冲突。使用一种机制或另一种机制。

ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED#

未能设置 PSK 标识提示。提示可能太长。

ERR_TLS_RENEGOTIATION_DISABLED#

尝试在已禁用重新协商的套接字实例上重新协商 TLS。

ERR_TLS_REQUIRED_SERVER_NAME#

在使用 TLS 时，调用了 server.addContext() 方法，但未在第一个参数中提供主机名。

ERR_TLS_SESSION_ATTACK#

检测到过量的 TLS 重新协商，这是拒绝服务攻击的潜在媒介。

ERR_TLS_SNI_FROM_SERVER#

尝试从 TLS 服务器端套接字发出服务器名称指示，而这仅对客户端有效。

ERR_TRACE_EVENTS_CATEGORY_REQUIRED#

trace_events.createTracing() 方法至少需要一个跟踪事件类别。

ERR_TRACE_EVENTS_UNAVAILABLE#

node:trace_events 模块无法加载，因为 Node.js 是使用 --without-v8-platform 标志编译的。

ERR_TRANSFORM_ALREADY_TRANSFORMING#

一个 Transform 流在仍在转换时已完成。

ERR_TRANSFORM_WITH_LENGTH_0#

一个 Transform 流在写缓冲区中仍有数据时已完成。

ERR_TTY_INIT_FAILED#

由于系统错误，TTY 初始化失败。

ERR_UNAVAILABLE_DURING_EXIT#

在不应该在 process.on('exit') 处理程序中调用的 process.on('exit') 处理程序中调用了函数。

ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET#

process.setUncaughtExceptionCaptureCallback() 被调用了两次，而没有先将回调重置为 null。

此错误旨在防止意外覆盖从另一个模块注册的回调。

ERR_UNESCAPED_CHARACTERS#

收到了包含未转义字符的字符串。

ERR_UNHANDLED_ERROR#

发生了未处理的错误（例如，当 EventEmitter 发出 'error' 事件，但未注册 'error' 处理程序时）。

ERR_UNKNOWN_BUILTIN_MODULE#

用于标识特定类型的内部 Node.js 错误，此错误通常不应由用户代码触发。此错误的实例指向 Node.js 二进制文件本身的内部错误。

ERR_UNKNOWN_CREDENTIAL#

传递了一个不存在的 Unix 组或用户标识符。

ERR_UNKNOWN_ENCODING#

向 API 传递了无效或未知的编码选项。

ERR_UNKNOWN_FILE_EXTENSION#

尝试加载具有未知或不受支持的文件扩展名的模块。

ERR_UNKNOWN_MODULE_FORMAT#

尝试加载具有未知或不受支持格式的模块。

ERR_UNKNOWN_SIGNAL#

向预期有效信号（例如 subprocess.kill()）的 API 传递了无效或未知的进程信号。

ERR_UNSUPPORTED_DIR_IMPORT#

不支持import目录 URL。相反，使用其名称自引用包并在 package.json 文件的 "exports" 字段中定义自定义子路径。

import './'; // unsupported
import './index.js'; // supported
import 'package-name'; // supported copy

ERR_UNSUPPORTED_ESM_URL_SCHEME#

不支持使用 file 和 data 以外的 URL 方案进行import。

ERR_UNSUPPORTED_RESOLVE_REQUEST#

尝试解析无效的模块引用者。这可能发生在使用以下方式导入或调用 import.meta.resolve() 时：

• URL 方案不是 file 的模块中的裸规范，该规范不是内置模块。
• URL 方案不是 特殊方案 的模块中的 相对 URL。

try {
  // Trying to import the package 'bare-specifier' from a `data:` URL module:
  await import('data:text/javascript,import "bare-specifier"');
} catch (e) {
  console.log(e.code); // ERR_UNSUPPORTED_RESOLVE_REQUEST
} copy

ERR_USE_AFTER_CLOSE#

尝试使用已关闭的内容。

ERR_VALID_PERFORMANCE_ENTRY_TYPE#

使用 Performance Timing API (perf_hooks) 时，未找到有效的性能条目类型。

ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG#

在没有 --experimental-vm-modules 的情况下调用了动态导入回调。

ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING#

未指定动态导入回调。

ERR_VM_MODULE_ALREADY_LINKED#

由于以下原因之一，尝试链接的模块不适合链接

• 它已链接（linkingStatus 为 'linked'）
• 它正在链接（linkingStatus 为 'linking'）
• 此模块的链接失败（linkingStatus 为 'errored'）

ERR_VM_MODULE_CACHED_DATA_REJECTED#

传递给模块构造函数的 cachedData 选项无效。

ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA#

无法为已评估的模块创建缓存数据。

ERR_VM_MODULE_DIFFERENT_CONTEXT#

从链接器函数返回的模块与父模块来自不同的上下文。链接的模块必须共享相同的上下文。

ERR_VM_MODULE_LINK_FAILURE#

由于故障，无法链接模块。

ERR_VM_MODULE_NOT_MODULE#

链接承诺的已实现值不是 vm.Module 对象。

ERR_VM_MODULE_STATUS#

当前模块的状态不允许此操作。错误的具体含义取决于具体函数。

ERR_WASI_ALREADY_STARTED#

WASI 实例已启动。

ERR_WASI_NOT_STARTED#

WASI 实例尚未启动。

ERR_WEBASSEMBLY_RESPONSE#

已传递给 WebAssembly.compileStreaming 或 WebAssembly.instantiateStreaming 的 Response 不是有效的 WebAssembly 响应。

ERR_WORKER_INIT_FAILED#

Worker 初始化失败。

ERR_WORKER_INVALID_EXEC_ARGV#

传递给 Worker 构造函数的 execArgv 选项包含无效的标志。

ERR_WORKER_NOT_RUNNING#

操作失败，因为 Worker 实例当前未运行。

ERR_WORKER_OUT_OF_MEMORY#

Worker 实例已终止，因为它达到了其内存限制。

ERR_WORKER_PATH#

工作线程主脚本的路径既不是绝对路径，也不是以 ./ 或 ../ 开头的相对路径。

ERR_WORKER_UNSERIALIZABLE_ERROR#

对工作线程未捕获异常进行序列化的所有尝试都失败了。

ERR_WORKER_UNSUPPORTED_OPERATION#

worker 线程中不支持所请求的功能。

ERR_ZLIB_INITIALIZATION_FAILED#

由于配置不正确，创建 zlib 对象失败。

HPE_HEADER_OVERFLOW#

收到了过多的 HTTP 标头数据。为了防止恶意或配置错误的客户端，如果收到了超过 8 KiB 的 HTTP 标头数据，则 HTTP 解析将中止，而不会创建请求或响应对象，并且会发出带有此代码的 Error。

HPE_CHUNK_EXTENSIONS_OVERFLOW#

为块扩展收到了过多的数据。为了防止恶意或配置错误的客户端，如果收到了超过 16 KiB 的数据，则会发出带有此代码的 Error。

HPE_UNEXPECTED_CONTENT_LENGTH#

服务器同时发送 Content-Length 标头和 Transfer-Encoding: chunked。

Transfer-Encoding: chunked 允许服务器为动态生成的内容维护 HTTP 持久连接。在这种情况下，无法使用 Content-Length HTTP 标头。

使用 Content-Length 或 Transfer-Encoding: chunked。

MODULE_NOT_FOUND#

在尝试执行 require() 操作或加载程序入口点时，CommonJS 模块加载器无法解析模块文件。

旧版 Node.js 错误代码#

ERR_CANNOT_TRANSFER_OBJECT#

传递给 postMessage() 的值包含一个不支持传输的对象。

ERR_CRYPTO_HASH_DIGEST_NO_UTF16#

UTF-16 编码与 hash.digest() 一起使用。虽然 hash.digest() 方法确实允许传递 encoding 参数，导致该方法返回一个字符串而不是 Buffer，但 UTF-16 编码（例如 ucs 或 utf16le）不受支持。

ERR_HTTP2_FRAME_ERROR#

在 HTTP/2 会话中发送单个帧时发生故障时使用。

ERR_HTTP2_HEADERS_OBJECT#

预期 HTTP/2 头对象时使用。

ERR_HTTP2_HEADER_REQUIRED#

HTTP/2 消息中缺少必需头时使用。

ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND#

HTTP/2 信息头必须在调用 Http2Stream.prototype.respond() 方法之前发送。

ERR_HTTP2_STREAM_CLOSED#

对已关闭的 HTTP/2 流执行操作时使用。

ERR_HTTP_INVALID_CHAR#

在 HTTP 响应状态消息（原因短语）中找到无效字符时使用。

ERR_INDEX_OUT_OF_RANGE#

给定的索引超出可接受的范围（例如，负偏移量）。

ERR_INVALID_OPT_VALUE#

在选项对象中传递了无效或意外的值。

ERR_INVALID_OPT_VALUE_ENCODING#

传递了无效或未知的文件编码。

ERR_INVALID_TRANSFER_OBJECT#

传递给 postMessage() 的传输对象无效。

ERR_IMPORT_ASSERTION_TYPE_FAILED#

导入断言失败，阻止导入指定的模块。

ERR_IMPORT_ASSERTION_TYPE_MISSING#

导入断言缺失，阻止导入指定的模块。

ERR_IMPORT_ASSERTION_TYPE_UNSUPPORTED#

此版本的 Node.js 不支持导入属性。

ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST#

此错误代码在 Node.js v15.0.0 中被 ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST 替换，因为它不再准确，因为现在还存在其他类型的可传输对象。

ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST#

需要在 transferList 参数中明确列出的对象位于传递给 postMessage() 调用的对象中，但未在该调用的 transferList 中提供。通常，这是一个 MessagePort。

在 v15.0.0 之前的 Node.js 版本中，此处使用的错误代码是 ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST。但是，可传输对象类型的集合已扩展为涵盖比 MessagePort 更多的类型。

ERR_NAPI_CONS_PROTOTYPE_OBJECT#

当 Constructor.prototype 不是对象时，Node-API 使用。

ERR_NETWORK_IMPORT_BAD_RESPONSE#

通过网络导入模块时，接收到响应，但该响应无效。

ERR_NETWORK_IMPORT_DISALLOWED#

网络模块尝试加载它不允许加载的另一个模块。这种限制可能是出于安全原因。

ERR_NO_LONGER_SUPPORTED#

以不受支持的方式调用了 Node.js API，例如 Buffer.write(string, encoding, offset[, length])。

ERR_OPERATION_FAILED#

操作失败。这通常用于表示异步操作的常规失败。

ERR_OUTOFMEMORY#

通常用于识别导致内存不足条件的操作。

ERR_PARSE_HISTORY_DATA#

node:repl 模块无法从 REPL 历史记录文件中解析数据。

ERR_SOCKET_CANNOT_SEND#

无法在套接字上发送数据。

ERR_STDERR_CLOSE#

尝试关闭process.stderr流。根据设计，Node.js 不允许用户代码关闭stdout或stderr流。

ERR_STDOUT_CLOSE#

尝试关闭process.stdout流。根据设计，Node.js 不允许用户代码关闭stdout或stderr流。

ERR_STREAM_READ_NOT_IMPLEMENTED#

尝试使用尚未实现readable._read()的可读流时使用。

ERR_TLS_RENEGOTIATION_FAILED#

TLS 重新协商请求以非特定方式失败时使用。

ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER#

在序列化过程中遇到一个其内存不受 JavaScript 引擎或 Node.js 管理的SharedArrayBuffer。此类SharedArrayBuffer无法序列化。

只有当本机加载项以“外部化”模式创建SharedArrayBuffer或将现有SharedArrayBuffer置于外部化模式时，才会发生这种情况。

ERR_UNKNOWN_STDIN_TYPE#

尝试使用未知stdin文件类型启动 Node.js 进程。此错误通常表示 Node.js 本身存在错误，尽管用户代码也有可能触发此错误。

ERR_UNKNOWN_STREAM_TYPE#

尝试使用未知stdout或stderr文件类型启动 Node.js 进程。此错误通常表示 Node.js 本身存在错误，尽管用户代码也有可能触发此错误。

ERR_V8BREAKITERATOR#

使用了 V8 BreakIterator API，但未安装完整的 ICU 数据集。

ERR_VALUE_OUT_OF_RANGE#

在给定值超出可接受范围时使用。

ERR_VM_MODULE_NOT_LINKED#

在实例化之前，必须成功链接模块。

ERR_VM_MODULE_LINKING_ERRORED#

链接器函数返回了一个链接失败的模块。

ERR_WORKER_UNSUPPORTED_EXTENSION#

用于 worker 的主脚本的路径名具有未知的文件扩展名。

ERR_ZLIB_BINDING_CLOSED#

在尝试使用已关闭的 zlib 对象时使用。

ERR_CPU_USAGE#

无法处理来自 process.cpuUsage 的本机调用。