错误

在 Node.js 中运行的应用程序通常会遇到以下几类错误：

• 标准 JavaScript 错误，例如 EvalError、SyntaxError、RangeError、ReferenceError、TypeError 和 URIError。
• 标准 DOMException。
• 由底层操作系统约束触发的系统错误，例如尝试打开不存在的文件或尝试通过关闭的套接字发送数据。
• AssertionError 是一类特殊的错误，当 Node.js 检测到绝不应发生的异常逻辑违规时会触发。这些错误通常由 node:assert 模块抛出。
• 应用程序代码触发的用户指定错误。

Node.js 抛出的所有 JavaScript 和系统错误都继承自标准 JavaScript Error 类，或是其实例，并保证提供 至少 该类上可用的属性。

Node.js 抛出的错误的 error.message 属性可能会在任何版本中更改。请使用 error.code 来识别错误。对于 DOMException，请使用 domException.name 来识别其类型。

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

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

// 因为 z 未定义而抛出 ReferenceError。
try {
  const m = 1;
  const n = m + z;
} catch (err) {
  // 在此处处理错误。
}

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

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

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

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

  const fs = require('node:fs/promises');
  
  (async () => {
    let data;
    try {
      data = await fs.readFile('a file that does not exist');
    } catch (err) {
      console.error('读取文件时出错！', err);
      return;
    }
    // 否则处理数据
  })();

  JavaScriptCopy to clipboard

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

  const fs = require('node:fs');
  fs.readFile('a file that does not exist', (err, data) => {
    if (err) {
      console.error('读取文件时出错！', err);
      return;
    }
    // 否则处理数据
  });

  JavaScriptCopy to clipboard

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

  const net = require('node:net');
  const connection = net.connect('localhost');
  
  // 向流添加 'error' 事件处理程序：
  connection.on('error', (err) => {
    // 如果连接被服务器重置，或者根本无法
    // 连接，或者连接遇到任何类型的错误，
    // 错误将被发送到这里。
    console.error(err);
  });
  
  connection.pipe(process.stdout);

  JavaScriptCopy to clipboard

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

'error' 事件机制的使用对于 基于流的 和 基于事件发射器的 API 最为常见，它们本身代表了一系列随时间进行的异步操作（而不是单个可能成功或失败的操作）。

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

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

setImmediate(() => {
  // 这将导致进程崩溃，因为没有添加
  // 'error' 事件处理程序。
  ee.emit('error', new Error('这会导致崩溃'));
});

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

开发者必须参考每个方法的文档以确定这些方法抛出的错误究竟是如何传播的。

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

Node.js 生成的所有错误，包括所有系统和 JavaScript 错误，要么是 Error 类的实例，要么继承自该类。

new Error(message, options?): void

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

Error.captureStackTrace(targetObject, constructorOpt?): void

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

const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // 类似于 `new Error().stack`

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

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

constructorOpt 参数有助于向用户隐藏错误生成的实现细节。例如：

function a() {
  b();
}

function b() {
  c();
}

function c() {
  // 创建一个没有堆栈跟踪的错误，以避免计算堆栈跟踪两次。
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;

  // 捕获函数 b 以上的堆栈跟踪
  Error.captureStackTrace(error, b); // 堆栈跟踪中既不包含函数 c，也不包含 b
  throw error;
}

a();

• 类型：number

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

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

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

• 类型：any

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

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

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

const cause = new Error('远程 HTTP 服务器响应了 500 状态');
const symptom = new Error('消息发送失败', { cause });

console.log(symptom);
// 打印：
//   Error: 消息发送失败
//       at REPL2:1:17
//       at Script.runInThisContext (node:vm:130:12)
//       ... 7 行匹配 cause 堆栈跟踪 ...
//       at [_line] [as _line] (node:internal/readline/interface:886:18) {
//     [cause]: Error: 远程 HTTP 服务器响应了 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)

• 类型：string

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

• 类型：string

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

const err = new Error('The message');
console.error(err.message);
// 打印：消息

• 类型：string

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

Error: 事情不断发生！
   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)

第一行格式为 <error class name>: <error message>，后跟一系列堆栈帧（每行以 "at " 开头）。

每个帧描述代码中导致错误生成的调用站点。V8 尝试为每个函数显示一个名称（通过变量名、函数名或对象方法名），但偶尔无法找到合适的名称。如果 V8 无法确定函数的名称，则该帧仅显示位置信息。否则，将显示确定的函数名称，并在括号中附加位置信息。

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

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

function makeFaster() {
  // `cheetahify()` *同步* 调用 speedy。
  cheetahify(function speedy() {
    throw new Error('oh no!');
  });
}

makeFaster();
// 将抛出：
//   /home/gbusey/file.js:6
//       throw new Error('oh no!');
//           ^
//   Error: 哦不！
//       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

位置信息将是以下之一：

• 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.stackTraceLimit 或当前事件循环滴答可用帧数中较小者的限制。

error.stack 是隐藏内部属性的 getter/setter，仅存在于内置 Error 对象上（那些 Error.isError 返回 true 的对象）。如果 error 不是内置错误对象，则 error.stack getter 将始终返回 undefined，setter 将不执行任何操作。如果访问器是使用非内置错误对象的 this 值手动调用的，例如 Proxy，则可能发生这种情况。

• 继承：errors.Error

表示断言失败。详细信息，请参阅 [ 类：assert.AssertionError][]

• 继承：errors.Error

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

require('node:net').connect(-1);
// 抛出 "RangeError: "port" 选项应 >= 0 且 < 65536: -1"

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

• 继承：errors.Error

表示试图访问未定义的变量。此类错误通常表明代码中有拼写错误， 或者程序已损坏。

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

doesNotExist;
// 抛出 ReferenceError，doesNotExist 在此程序中不是变量。

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

• 继承：errors.Error

表示程序不是有效的 JavaScript。这些错误只能 作为代码求值的结果生成和传播。代码求值可能 作为 eval、Function、require 或 vm 的结果发生。这些错误 几乎总是表明程序已损坏。

try {
  require('node:vm').runInThisContext('binary ! isNotOk');
} catch (err) {
  // 'err' 将是一个 SyntaxError。
}

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

• 继承：errors.Error

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

• 类型：string

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

• 类型：string

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

• 类型：string

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

• 类型：number

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

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

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

• 类型：Object

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

• 类型：string

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

• 类型：string

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

• 类型：number

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

• 类型：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 查找失败）：表示 EAI_NODATA 或 EAI_NONAME 的 DNS 失败。这不是标准的 POSIX 错误。

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

• EPIPE（管道破裂）：在没有进程 读取数据的情况下写入管道、套接字或 FIFO。通常在 net 和 http 层遇到，表明正在 写入的流的远程端已关闭。

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

• 继承自 errors.Error

表示提供的参数不是允许的类型。例如，向期望字符串的参数传入函数会导致 TypeError。

require('node:url').parse(() => { });
// 抛出 TypeError，因为它期望的是一个字符串。

Node.js 会将其作为参数校验的一种形式，立即 创建并抛出 TypeError 实例。

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

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

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

一个错误数组，可以提供上下文以了解错误源自 OpenSSL 库中的何处。

错误源自的 OpenSSL 函数。

错误源自的 OpenSSL 库。

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

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

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

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

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

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

Node.js API 要求提供一个可迭代参数（即适用于 for...of 循环的值），但未提供。

一种特殊类型的错误，当 Node.js 检测到不应发生的异常逻辑违规时就会触发。此类错误通常由 node:assert 模块抛出。

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

与模块加载相关的操作由异步加载器 钩子自定义，该钩子在加载器线程退出前从未结算 promise。

domain 属性已从 AsyncResource 中移除。domain 模块 现在改用 AsyncLocalStorage 进行上下文传播，而不是 async_hooks。 请改用 AsyncLocalStorage 进行上下文传播。

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

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

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

试图在与 Node.js 实例无关的 JS 引擎上下文中，从插件或嵌入者 代码创建 Node.js Buffer 实例。传递给 Buffer 方法的数据将在 方法返回时被释放。

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

尝试执行超出 Buffer 边界的操作。

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

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

当分叉子进程而未指定 IPC 通道时使用。

当主进程试图从子进程的 STDERR/STDOUT 读取数据，且数据长度超过 maxBuffer 选项时使用。

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

Console 实例化时没有 stdout 流，或者 Console 具有 不可写的 stdout 或 stderr 流。

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

调用类的构造函数时没有使用 new。

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

具有给定名称的 CPU 性能分析已启动。

具有给定名称的 CPU 配置文件尚未启动。

正在收集的 CPU 配置文件太多。

当前使用的 OpenSSL 版本不支持 Argon2。

请求使用了 OpenSSL 引擎（例如通过 clientCertEngine 或 privateKeyEngine TLS 选项），但正在使用的 OpenSSL 版本不支持该引擎， 可能是因为编译时启用了 OPENSSL_NO_ENGINE 标志。

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

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

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

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

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

hash.digest() 已被调用多次。hash.digest() 方法 在每个 Hash 对象实例上只能调用一次。

hash.update() 因任何原因失败。这种情况应该很少发生，甚至几乎不会发生。

提供的加密密钥与所尝试的操作不兼容。

所选的公钥或私钥编码与其他选项不兼容。

加密子系统初始化失败。

提供了无效的身份验证标签。

为计数器模式密码提供了无效的计数器。

提供了无效的椭圆曲线。

指定了无效的 [加密摘要算法][]。

提供了无效的初始化向量。

提供了无效的 JSON Web 密钥。

提供了无效的密钥长度。

提供了无效的密钥对。

提供了无效的密钥类型。

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

提供了无效的消息长度。

一个或多个 crypto.scrypt() 或 crypto.scryptSync() 参数超出其有效范围。

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

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

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

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

密钥的非对称密钥类型未在 [JSON Web 密钥类型注册表][] 中注册使用。

试图使用 KEM 操作，而 Node.js 编译时未使用 支持 KEM 的 OpenSSL。

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

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

Node.js 编译时未包含 scrypt 支持。官方 发布二进制文件不可能出现这种情况，但自定义构建（包括发行版构建）可能发生。

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

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

指定了未知的加密算法。

提供了未知的 Diffie-Hellman 组名称。请参阅 crypto.getDiffieHellman() 以获取有效组名称列表。

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

调试器 出现错误。

调试器 在等待所需的主机/端口可用时超时。

fs.Dir 之前已关闭。

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

使用 --no-addons 禁用了加载原生插件。

调用 process.dlopen() 失败。

c-ares 设置 DNS 服务器失败。

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

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

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

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

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

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

--print 不能与 ESM 输入一起使用。

尝试在 EventTarget 上递归分发事件时抛出。

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

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

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

低级 FFI 调用失败。

向 FFI 操作传递了一个无效指针。

在 FFI 动态库关闭后，尝试对其执行操作。

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

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

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

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

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

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

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

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

该路径是一个目录。

尝试读取一个大于 fs.readFile() 支持的 2 GiB 限制的文件。这不是 Buffer 的限制，而是一个内部 I/O 约束。 对于处理更大的文件，可以考虑使用 fs.createReadStream() 按块读取该 文件。

fs.watch() 的 maxQueue 中指定的大小超过了已排队但尚未处理的文件系统事件数量。

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

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

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

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

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

发生了未指定的 HTTP/2 错误。

在 Http2Session 从连接的对方收到 GOAWAY 帧后，不得打开新的 HTTP/2 流。

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

尝试发送多个响应头。

为需要单个值的 HTTP/2 头字段提供了多个值。

信息性 HTTP 状态码（1xx）不得设置为 HTTP/2 响应的响应状态码。

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

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

指定了无效的 HTTP 信息性状态码。信息性 状态码必须是 100 到 199（含）之间的整数。

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

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

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

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

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

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

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

尝试从推送流内部发起新的推送流。
不允许嵌套推送流。

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

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

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

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

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

HTTP/2 ping 被取消。

HTTP/2 ping 有效载荷长度必须正好为 8 字节。

HTTP/2 伪头使用不当。伪头是以 : 为前缀开头的头键名。

试图创建推送流，但该流已被客户端 禁用。

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

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

Http2Session 以非零错误代码关闭。

Http2Session 设置被取消。

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

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

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

指定了无效的 HTTP 状态码。状态码必须是介于 100 和 599 之间的整数（含边界值）。

对端在发送 END_STREAM 之前，使用干净的错误代码（NGHTTP2_NO_ERROR 或 NGHTTP2_CANCEL）重置了 Http2Stream，因此可读端将 无法被完整传递。这对应于 HTTP/1 的 ECONNRESET ，并适用于对端的 socket.destroy()。

Http2Stream 在向连接的 对端传输任何数据之前被销毁。

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

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

正在使用过多的自定义设置（10）。

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

服务器发送的唯一源数量已超过 options.maxOriginSetSize 中定义的值。

尾随头已在 Http2Stream 上发送。

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

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

当向不允许包含内容的 HTTP 响应写入数据时抛出错误。

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

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

指定了无效的 HTTP 头值。

状态码超出常规状态码范围（100-999）。

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

给定的 ServerResponse 已分配套接字。

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

设置了 Trailer 头，但传输编码不支持 该头。

试图使用非公共构造函数构造对象。

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

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

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

该选项组合不兼容，不能一起使用。

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

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

使用 node:inspector 模块时，在检查器 已经连接的情况下尝试进行连接。

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

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

在 inspector 未激活时调用了 inspector.waitForDebugger()。

node:inspector 模块不可用。

使用 node:inspector 模块时，在 inspector 连接之前尝试使用了它。

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

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

Node.js API 无法理解所提供的地址。

Node.js API 不理解提供的地址族。

将错误类型的参数传递给 Node.js API。

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

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

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

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

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

无效的文件描述符（'fd'）（例如，它是负值）。

无效的文件描述符（'fd'）类型。

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

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

抛出的错误对象包括一个 input 属性，其中包含无效 file: URL 的 URL 对象。

试图通过 IPC 通信
通道向子进程发送不支持的 "handle"。有关更多信息，请参阅 subprocess.send() 和 process.send()。

提供了无效的 HTTP 令牌。

无效的 IP 地址。

无效的 MIME 语法。

试图加载不存在或以其他方式 无效的模块。

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

在对象的属性上设置无效属性时发生错误。

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

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

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

在 REPL 配置中同时设置了 breakEvalOnSigint 和 eval 选项， 这是不支持的。

当函数选项在执行时未为其返回对象属性之一提供有效值时抛出。

当函数选项在执行时未为其返回对象属性之一提供预期值类型时抛出。

当函数选项在执行时未返回预期值 类型时抛出，例如当函数期望返回 promise 时。

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

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

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

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

const buf = Buffer.alloc(1);
urlSearchParams.has.call(buf, 'foo');
// 抛出代码为 'ERR_INVALID_THIS' 的 TypeError

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

提供的 TypeScript 语法无效。

传入了无效的 URI。

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

将无效的 URLPattern 传递给 WHATWG URLPattern 构造函数 进行解析。

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

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

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

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

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

IP 被 net.BlockList 阻止。

ESM 加载器钩子返回时未调用 next() 且未显式 指示短路。

加载 SQLite 扩展时发生错误。

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

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

必需但未实现的方法。

未传递 Node.js API 的必需参数。这仅用于 严格符合 API 规范（某些情况下可能接受 func(undefined) 但不接受 func()）。在大多数原生 Node.js API 中， func(undefined) 和 func() 被视为相同，并且可以使用 ERR_INVALID_ARG_TYPE 错误代码。

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

试图读取加密密钥而未指定密码短语。

此 Node.js 实例使用的 V8 平台不支持创建
Worker。这是由于缺乏对 Worker 的嵌入者支持。特别是，
此错误不会在 Node.js 的标准构建中发生。

无法链接模块，因为其中的相同模块请求未解析为同一模块。

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

回调函数被调用了多次。

回调函数几乎总是应该只被调用一次，因为查询可以被满足或被拒绝，但不能两者兼有。后者可以通过多次调用回调函数来实现。

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

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

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

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

调用线程安全函数的 JavaScript 部分时发生错误。

尝试检索 JavaScript undefined 值时发生错误。

在不允许非上下文感知原生加载项的进程中加载了此类加载项。

尽管 Node.js 当前并未构建 V8 启动快照，但仍尝试执行了只有在构建 V8 启动快照时才可用的操作。

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

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

尝试使用加密功能，但 Node.js 编译时未启用 OpenSSL 加密支持。

尝试使用需要 ICU 的功能，但 Node.js 在编译时未启用 ICU 支持。

有人尝试使用需要 Temporal 的功能，但 Node.js 在编译时未启用 Temporal 支持，或者它已在当前环境中被禁用 （例如，在使用 --no-harmony-temporal 运行时）。

尝试使用需要 原生 TypeScript 支持 的功能，但 Node.js 编译时未包含 TypeScript 支持。

操作失败。这通常用于表示异步操作的一般性失败。

尝试在引导启动之前获取选项。

给定的值超出可接受范围。

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

模块尝试使用 包映射 解析一个裸说明符，但导入文件不位于映射中定义的任何包内。

$ node --experimental-package-map=./package-map.json /tmp/script.js
Error [ERR_PACKAGE_MAP_EXTERNAL_FILE]: Cannot resolve "dep-a" from "/tmp/script.js": file is not within any package defined in /path/to/package-map.json

要修复此错误，请确保导入文件位于包映射中列出的某个包目录内，或者添加一个新的包条目，使其 url 覆盖导入文件。

[package map][] 配置文件无效。这种情况可能发生在以下情形：

• 文件在指定路径下不存在。
• 文件包含无效的 JSON。
• 文件缺少必需的 packages 对象。
• 某个包条目缺少必需的 url 字段。
• 两个包条目具有相同的 url 值。

$ node --experimental-package-map=./missing.json app.js
Error [ERR_PACKAGE_MAP_INVALID]: 无效的 package map 位于 "./missing.json"：未找到文件

在包映射中，包的 dependencies 对象引用了一个未在 packages 对象中定义的包键。

{
  "packages": {
    "app": {
      "url": "./app",
      "dependencies": {
        "foo": "nonexistent"
      }
    }
  }
}

在此示例中，"nonexistent" 被引用为依赖目标，但它未在 packages 中定义，因此会抛出此错误。

要修复此错误，请确保 dependencies 值中引用的所有包键都已在 packages 对象中定义。

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

当 strict 设置为 true 时，如果为 string 类型的选项提供 boolean 值，或者为 boolean 类型的选项提供 string 值，util.parseArgs() 将抛出此错误。

当提供位置参数且 util.parseArgs() 的 allowPositionals 设置为 false 时，将抛出此错误。

当 strict 设置为 true 时，如果参数未在 options 中配置，util.parseArgs() 将抛出此错误。

为 performance 标记或测量提供了无效的时间戳值。

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

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

由于代理配置无效，代理请求失败。

当启用 NODE_USE_ENV_PROXY 或 --use-env-proxy 时，建立代理隧道失败。

稳定性：1 - 实验性

发生 QUIC 应用程序错误。

稳定性：1 - 实验性

建立 QUIC 连接失败。

稳定性：1 - 实验性

QUIC 端点因错误而关闭。

稳定性：1 - 实验性

打开 QUIC 流失败。

稳定性：1 - 实验性

用于抛出 QuicError 的 Node.js 错误代码，以使用显式应用程序或传输错误代码中止 QUIC 流 或会话。

稳定性：1 - 实验性

QUIC 流被对端重置。错误包含 对端提供的重置代码。

稳定性：1 - 实验性

发生 QUIC 传输错误。

稳定性：1 - 实验性

QUIC 会话失败，因为需要进行版本协商。

尝试 require() 一个 ES 模块 时，该模块被发现是异步的。 也就是说，它包含顶层 await。

在未被捕获时，标志 --experimental-print-required-tla 会将 图中顶层 await 的位置打印到 stderr。

此错误具有以下额外的不可枚举属性：

尝试 require() 一个 ES 模块 时，CommonJS 到 ESM 或 ESM 到 CommonJS 的边参与了一个即时循环。 这是不允许的，因为 ES 模块无法在自身已经处于求值过程时进行求值。

为避免循环，参与循环的 require() 调用不应位于 ES 模块（通过 createRequire()）或 CommonJS 模块的顶层，而应在内部函数中延迟执行。

稳定性：0 - 已弃用

尝试 require() ES 模块。此错误已弃用，因为 require() 现在支持加载同步 ES 模块。当 require() 遇到包含顶层 await 的 ES 模块时，将改为抛出 ERR_REQUIRE_ASYNC_MODULE。

稳定性：1 - 实验性。

当另一个 import() 调用已在异步加载某个 ES 模块 时，尝试使用 require() 加载该模块。

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

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

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

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

向单可执行应用程序 API 传递了用于标识资产的键，但找不到匹配的资产。

尝试绑定一个已经绑定的套接字。

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

期望端口 >= 0 且 < 65536 的 API 函数收到了无效值。

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

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

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

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

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

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

在未连接的套接字上调用了 dgram.disconnect() 或 dgram.remoteAddress()。

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

对已被 BoundSocket 或 net.Server 接管的 net.Socket 尝试执行了操作。一旦绑定套接字被接管，其 address() 和 close() 方法将不再可用。

无法解析源映射，因为它不存在或已损坏。

未找到从源映射导入的文件。

提供的模块导入未为源阶段导入语法 import source x from 'x' 或 import.source(x) 提供源阶段导入表示。

从 SQLite 返回了一个错误。

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

调用了流方法，但由于流已完成，无法完成。

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

调用了流方法，但该流已通过 stream.destroy() 被销毁，因此无法完成。

在未启用 --experimental-stream-iter CLI 标志的情况下使用了 stream/iter API。

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

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

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

尝试将数据通过管道传输到已关闭或已销毁的流。

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

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

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

instance.setEncoding('utf8');

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

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

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

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

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

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

如果在创建 TLSServer 时 TLS 选项同时包含 ALPNProtocols 和 ALPNCallback，则会抛出此错误。这些选项是互斥的。

如果用户提供的 subjectaltname 属性违反了编码规则，checkServerIdentity 将抛出此错误。由 Node.js 自身生成的证书对象始终符合编码规则，并且永远不会导致此错误。

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

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

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

上下文必须是 SecureContext。

指定的 secureProtocol 方法无效。该方法可能未知，或因不安全而被禁用。

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

TLS 套接字必须已连接并安全建立。确保在继续之前发出 'secure' 事件。

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

设置 PSK 身份提示失败。提示可能太长。

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

尝试重新协商 TLS，但 TLS 实现不支持由调用方发起的重新协商。

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

检测到过多的 TLS 重新协商，这可能成为拒绝服务攻击的潜在手段。

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

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

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

在压缩流结束后发现尾随垃圾数据。当在压缩流（例如，在 zlib 或 gzip 解压缩）结束后检测到额外的意外数据时，会抛出此错误。

Transform 流在仍在转换时完成。

Transform 完成时写缓冲区中仍有数据。

TTY 初始化失败，原因是系统错误。

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

process.setUncaughtExceptionCaptureCallback() 在未先将回调重置为 null 的情况下被调用了两次。

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

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

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

用于标识一种特定类型的 Node.js 内部错误，通常不应由用户代码触发。此错误的实例表示 Node.js 二进制文件自身发生了内部错误。

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

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

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

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

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

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

import './'; // 不支持
import './index.js'; // 支持
import 'package-name'; // 支持

import 不支持除 file 和 data 之外的 URL 方案。

不支持对 node_modules 目录下的文件进行类型剥离。

尝试解析无效的模块引用者。当从 URL 方案不是 file 的模块导入或调用 import.meta.resolve() 时，可能会发生这种情况：

• 不是内置模块的裸说明符。
• 来自 URL 方案不是 特殊方案 的模块的 相对 URL。

try {
  // 尝试从 `data:` URL 模块导入包 'bare-specifier'：
  await import('data:text/javascript,import "bare-specifier"');
} catch (e) {
  console.log(e.code); // ERR_UNSUPPORTED_RESOLVE_REQUEST
}

所提供的 TypeScript 语法不受支持。当使用需要 [类型擦除][] 转换的 TypeScript 语法时，可能会发生这种情况。

尝试使用已被关闭的对象。

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

未指定动态导入回调。

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

正在被链接的模块不满足链接条件，原因可能如下之一：

• 它已经被链接过（linkingStatus 为 'linked'）
• 它正在链接过程中（linkingStatus 为 'linking'）
• 链接该模块失败（linkingStatus 为 'errored'）

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

无法为已经求值的模块创建缓存数据。

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

由于链接失败，模块无法完成链接。

链接承诺的履行值不是 vm.Module 对象。

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

WASI 实例已经启动。

WASI 实例尚未启动。

使用了需要 WebAssembly 的功能，但当前环境不支持 WebAssembly，或者已将其禁用（例如在使用 --jitless 运行时）。

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

尝试通过 worker_threads 的 postMessage() 调用将 net.Socket 或 net.Server 传输到另一个线程，但它当时并不处于可传输状态，例如因为它已经开始读取或已经有了缓冲数据。

Worker 初始化失败。

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

稳定性：1.1 - 积极开发中

目标线程在处理通过 postMessageToThread() 发送的消息时抛出错误。

稳定性：1.1 - 积极开发中

postMessageToThread() 中请求的线程无效或没有 workerMessage 监听器。

稳定性：1.1 - 积极开发中

postMessageToThread() 中请求的线程 ID 是当前线程 ID。

稳定性：1.1 - 积极开发中

通过 postMessageToThread() 发送消息超时。

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

Worker 实例因达到内存限制而终止。

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

从工作线程中序列化未捕获异常的所有尝试均失败。

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

归档级结构超出限制：归档注释超过了 ZIP 格式允许的 65,535 字节编码长度，或者归档的中央目录过大，无法缓冲到内存中。

ZIP 归档条目在读取时未通过 CRC-32 校验，或产生的字节数多于或少于其声明的未压缩大小。

从不包含该名称条目的 ZipFile 或 ZipBuffer 中请求了一个具名条目。

ZIP 归档条目声明的大小超过了配置的限制，或者提供的条目名称或注释超过了 ZIP 格式允许的 65,535 字节编码长度。

原本应为 ZIP 归档或其中结构的数据缺失、超出范围，或以其他方式与 ZIP 格式不一致。

在未使用 { writable: true } 打开的 ZipFile 上调用了变更方法（例如 zipFile.addEntry() 或 zipFile.delete()）。

ZIP 归档使用了此实现不支持的功能， 例如条目加密、不受支持的压缩方法或多磁盘归档。

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

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

接收到的分块扩展数据过多。为防止恶意或错误的客户端，如果接收到超过 16 KiB 的数据，将抛出一个带有此代码的 Error。

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

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

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

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

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

稳定性：0 - 已弃用。这些错误代码要么不一致，要么已被移除。

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

无法处理来自 process.cpuUsage 的原生调用。

hash.digest() 使用了 UTF-16 编码。虽然 hash.digest() 方法允许传入 encoding 参数，使方法返回字符串而不是 Buffer，但不支持 UTF-16 编码（例如 ucs 或 utf16le）。

传递给 crypto.scrypt() 或 crypto.scryptSync() 的选项组合不兼容。新版本的 Node.js 使用错误代码 ERR_INCOMPATIBLE_OPTION_PAIR 代替，这与其他 API 一致。

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

当在 HTTP/2 会话上发送单个帧发生失败时使用。

当需要 HTTP/2 头部对象时使用。

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

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

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

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

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

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

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

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

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

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

在使用性能计时 API（perf_hooks）时，性能标记无效。

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

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

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

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

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

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

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

尝试从策略清单读取，但清单初始化尚未发生。这可能是 Node.js 中的缺陷。

加载了策略清单，但其 "onerror" 行为的值未知。有关更多信息，请参阅策略清单的文档。

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

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

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

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

在主线程上，值在空闲循环中从与线程安全函数关联的队列中移除。此错误表明尝试启动循环时发生了错误。

一旦队列中没有更多项，必须暂停空闲循环。此错误表明空闲循环未能停止。

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

通常用于标识操作导致内存不足的情况。

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

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

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

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

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

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

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

此错误表示 TAP 验证失败。

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

在序列化期间遇到一个内存不由 JavaScript 引擎或 Node.js 管理的 SharedArrayBuffer。此类 SharedArrayBuffer 无法被序列化。

这只有在原生插件以“外部化”模式创建 SharedArrayBuffer，或将现有 SharedArrayBuffer 放入外部化模式时才会发生。

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

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

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

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

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

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

用于工作线程主脚本的路径名具有未知的文件扩展名。

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

证书尚未生效：notBefore 日期在当前时间之后。

证书已过期：notAfter 日期在当前时间之前。

证书吊销列表 (CRL) 具有未来的签发日期。

证书吊销列表 (CRL) 已过期。

证书已被吊销；它位于证书吊销列表 (CRL) 上。

找不到查找证书的颁发者证书。这通常意味着受信任证书列表不完整。

证书的颁发者未知。如果颁发者未包含在受信任证书列表中，就会出现这种情况。

传入的证书是自签名的，并且在受信任证书列表中找不到相同的证书。

证书的颁发者未知。如果颁发者未包含在受信任证书列表中，就会出现这种情况。

证书链长度大于最大深度。

找不到证书引用的 CRL。

无法验证任何签名，因为链只包含一个证书且它不是自签名的。

根证书颁发机构 (CA) 未标记为用于指定目的的可信机构。

CA 证书无效。要么它不是 CA，要么其扩展与提供的目的不一致。

basicConstraints pathlength 参数已超出。

证书与提供的名称不匹配。

提供的证书不能用于指定目的。

根 CA 被标记为拒绝指定目的。

证书签名无效。

证书吊销列表 (CRL) 的签名无效。

证书 notBefore 字段包含无效时间。

证书 notAfter 字段包含无效时间。

CRL lastUpdate 字段包含无效时间。

CRL nextUpdate 字段包含无效时间。

证书签名无法解密。这意味着无法确定实际签名值，而不是它与预期值不匹配，这仅对 RSA 密钥有意义。

证书吊销列表 (CRL) 签名无法解密：这意味着无法确定实际签名值，而不是它与预期值不匹配。

无法读取证书 SubjectPublicKeyInfo 中的公钥。

尝试分配内存时发生错误。这绝不应该发生。