- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用 Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议 2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS 模块
- module/esm ECMAScript 模块
- module/package 包模块
- module/typescript TS 模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- sea 单个可执行应用程序
Node.js v22.11.0 文档
- Node.js v22.11.0
-
目录
- 断言
- 严格断言模式
- 旧版断言模式
- 类:assert.AssertionError
- 类:
assert.CallTracker
assert(value[, message])
assert.deepEqual(actual, expected[, message])
assert.deepStrictEqual(actual, expected[, message])
assert.doesNotMatch(string, regexp[, message])
assert.doesNotReject(asyncFn[, error][, message])
assert.doesNotThrow(fn[, error][, message])
assert.equal(actual, expected[, message])
assert.fail([message])
assert.fail(actual, expected[, message[, operator[, stackStartFn]]])
assert.ifError(value)
assert.match(string, regexp[, message])
assert.notDeepEqual(actual, expected[, message])
assert.notDeepStrictEqual(actual, expected[, message])
assert.notEqual(actual, expected[, message])
assert.notStrictEqual(actual, expected[, message])
assert.ok(value[, message])
assert.rejects(asyncFn[, error][, message])
assert.strictEqual(actual, expected[, message])
assert.throws(fn[, error][, message])
- 断言
-
导航
- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用 Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议 2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS 模块
- module/esm ECMAScript 模块
- module/package 包模块
- module/typescript TS 模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- sea 单个可执行应用程序
- 其他版本
断言#
¥Assert
¥Stability: 2 - Stable
源代码: lib/assert.js
node:assert
模块提供了一组用于验证不变量的断言函数。
¥The node:assert
module provides a set of assertion functions for verifying
invariants.
严格断言模式#
¥Strict assertion mode
在严格断言模式下,非严格方法的行为与其对应的严格方法相同。例如,assert.deepEqual()
的行为类似于 assert.deepStrictEqual()
。
¥In strict assertion mode, non-strict methods behave like their corresponding
strict methods. For example, assert.deepEqual()
will behave like
assert.deepStrictEqual()
.
在严格断言模式下,对象的错误消息显示差异。在旧版断言模式下,对象的错误消息显示对象,通常被截断。
¥In strict assertion mode, error messages for objects display a diff. In legacy assertion mode, error messages for objects display the objects, often truncated.
使用严格断言模式:
¥To use strict assertion mode:
import { strict as assert } from 'node:assert';
const assert = require('node:assert').strict;
import assert from 'node:assert/strict';
const assert = require('node:assert/strict');
错误差异的示例:
¥Example error diff:
import { strict as assert } from 'node:assert';
assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
// [
// [
// ...
// 2,
// + 3
// - '3'
// ],
// ...
// 5
// ]
const assert = require('node:assert/strict');
assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
// [
// [
// ...
// 2,
// + 3
// - '3'
// ],
// ...
// 5
// ]
要停用颜色,则使用 NO_COLOR
或 NODE_DISABLE_COLORS
环境变量。这也将停用交互式解释器中的颜色。有关终端环境中颜色支持的更多信息,请读阅终端 getColorDepth()
文档。
¥To deactivate the colors, use the NO_COLOR
or NODE_DISABLE_COLORS
environment variables. This will also deactivate the colors in the REPL. For
more on color support in terminal environments, read the tty
getColorDepth()
documentation.
旧版断言模式#
¥Legacy assertion mode
旧版断言模式在以下情况下使用 ==
操作符:
¥Legacy assertion mode uses the ==
operator in:
要使用旧版断言模式:
¥To use legacy assertion mode:
import assert from 'node:assert';
const assert = require('node:assert');
旧版断言模式可能会产生意外的结果,尤其是在使用 assert.deepEqual()
时:
¥Legacy assertion mode may have surprising results, especially when using
assert.deepEqual()
:
// WARNING: This does not throw an AssertionError in legacy assertion mode!
assert.deepEqual(/a/gi, new Date());
类:assert.AssertionError#
¥Class: assert.AssertionError
-
¥Extends: <errors.Error>
表示断言的失败。node:assert
模块抛出的所有错误都是 AssertionError
类的实例。
¥Indicates the failure of an assertion. All errors thrown by the node:assert
module will be instances of the AssertionError
class.
new assert.AssertionError(options)
#
-
options
<Object>-
message
<string> 如果提供,则错误消息将设置为此值。¥
message
<string> If provided, the error message is set to this value. -
actual
<any> 错误实例上的actual
属性。¥
actual
<any> Theactual
property on the error instance. -
expected
<any> 错误实例上的expected
属性。¥
expected
<any> Theexpected
property on the error instance. -
operator
<string> 错误实例上的operator
属性。¥
operator
<string> Theoperator
property on the error instance. -
stackStartFn
<Function> 如果提供,则生成的堆栈跟踪将省略此函数之前的帧。¥
stackStartFn
<Function> If provided, the generated stack trace omits frames before this function.
-
Error
的子类,表示断言的失败。
¥A subclass of Error
that indicates the failure of an assertion.
所有实例都包含内置的 Error
属性(message
和 name
),以及:
¥All instances contain the built-in Error
properties (message
and name
)
and:
-
actual
<any> 对于assert.strictEqual()
等方法,设置为actual
参数。¥
actual
<any> Set to theactual
argument for methods such asassert.strictEqual()
. -
expected
<any> 对于assert.strictEqual()
等方法,设置为expected
值。¥
expected
<any> Set to theexpected
value for methods such asassert.strictEqual()
. -
generatedMessage
<boolean> 指示消息是否是自动生成的 (true
)。¥
generatedMessage
<boolean> Indicates if the message was auto-generated (true
) or not. -
code
<string> 值始终为ERR_ASSERTION
,以表明该错误是断言错误。¥
code
<string> Value is alwaysERR_ASSERTION
to show that the error is an assertion error. -
operator
<string> 设置为传入的运算符值。¥
operator
<string> Set to the passed in operator value.
import assert from 'node:assert';
// Generate an AssertionError to compare the error message later:
const { message } = new assert.AssertionError({
actual: 1,
expected: 2,
operator: 'strictEqual',
});
// Verify error output:
try {
assert.strictEqual(1, 2);
} catch (err) {
assert(err instanceof assert.AssertionError);
assert.strictEqual(err.message, message);
assert.strictEqual(err.name, 'AssertionError');
assert.strictEqual(err.actual, 1);
assert.strictEqual(err.expected, 2);
assert.strictEqual(err.code, 'ERR_ASSERTION');
assert.strictEqual(err.operator, 'strictEqual');
assert.strictEqual(err.generatedMessage, true);
}
const assert = require('node:assert');
// Generate an AssertionError to compare the error message later:
const { message } = new assert.AssertionError({
actual: 1,
expected: 2,
operator: 'strictEqual',
});
// Verify error output:
try {
assert.strictEqual(1, 2);
} catch (err) {
assert(err instanceof assert.AssertionError);
assert.strictEqual(err.message, message);
assert.strictEqual(err.name, 'AssertionError');
assert.strictEqual(err.actual, 1);
assert.strictEqual(err.expected, 2);
assert.strictEqual(err.code, 'ERR_ASSERTION');
assert.strictEqual(err.operator, 'strictEqual');
assert.strictEqual(err.generatedMessage, true);
}
类:assert.CallTracker
#
¥Class: assert.CallTracker
¥Stability: 0 - Deprecated
此功能已弃用,将在未来版本中删除。请考虑使用替代方法,例如 mock
辅助函数。
¥This feature is deprecated and will be removed in a future version.
Please consider using alternatives such as the
mock
helper function.
new assert.CallTracker()
#
创建新的 CallTracker
对象,其可用于跟踪函数是否被调用了特定次数。必须调用 tracker.verify()
才能进行验证。通常的模式是在 process.on('exit')
句柄中调用。
¥Creates a new CallTracker
object which can be used to track if functions
were called a specific number of times. The tracker.verify()
must be called
for the verification to take place. The usual pattern would be to call it in a
process.on('exit')
handler.
import assert from 'node:assert';
import process from 'node:process';
const tracker = new assert.CallTracker();
function func() {}
// callsfunc() must be called exactly 1 time before tracker.verify().
const callsfunc = tracker.calls(func, 1);
callsfunc();
// Calls tracker.verify() and verifies if all tracker.calls() functions have
// been called exact times.
process.on('exit', () => {
tracker.verify();
});
const assert = require('node:assert');
const process = require('node:process');
const tracker = new assert.CallTracker();
function func() {}
// callsfunc() must be called exactly 1 time before tracker.verify().
const callsfunc = tracker.calls(func, 1);
callsfunc();
// Calls tracker.verify() and verifies if all tracker.calls() functions have
// been called exact times.
process.on('exit', () => {
tracker.verify();
});
tracker.calls([fn][, exact])
#
-
fn
<Function> 默认值:空操作函数。¥
fn
<Function> Default: A no-op function. -
exact
<number> 默认值:1
。¥
exact
<number> Default:1
. -
返回:<Function> 封装
fn
的函数。¥Returns: <Function> A function that wraps
fn
.
预计封装函数将被精确调用 exact
次。如果在调用 tracker.verify()
时函数没有被精确调用 exact
次,那么 tracker.verify()
将抛出错误。
¥The wrapper function is expected to be called exactly exact
times. If the
function has not been called exactly exact
times when
tracker.verify()
is called, then tracker.verify()
will throw an
error.
import assert from 'node:assert';
// Creates call tracker.
const tracker = new assert.CallTracker();
function func() {}
// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func);
const assert = require('node:assert');
// Creates call tracker.
const tracker = new assert.CallTracker();
function func() {}
// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func);
tracker.getCalls(fn)
#
-
fn
<Function> -
返回:<Array> 包含对跟踪函数的所有调用的数组。
¥Returns: <Array> An array with all the calls to a tracked function.
-
对象 <Object>
¥Object <Object>
import assert from 'node:assert';
const tracker = new assert.CallTracker();
function func() {}
const callsfunc = tracker.calls(func);
callsfunc(1, 2, 3);
assert.deepStrictEqual(tracker.getCalls(callsfunc),
[{ thisArg: undefined, arguments: [1, 2, 3] }]);
const assert = require('node:assert');
// Creates call tracker.
const tracker = new assert.CallTracker();
function func() {}
const callsfunc = tracker.calls(func);
callsfunc(1, 2, 3);
assert.deepStrictEqual(tracker.getCalls(callsfunc),
[{ thisArg: undefined, arguments: [1, 2, 3] }]);
tracker.report()
#
-
返回:<Array> 包含有关
tracker.calls()
返回的封装函数信息的对象数组。¥Returns: <Array> An array of objects containing information about the wrapper functions returned by
tracker.calls()
. -
对象 <Object>
¥Object <Object>
-
message
<string> -
actual
<number> 函数被调用的实际次数。¥
actual
<number> The actual number of times the function was called. -
expected
<number> 函数预期被调用的次数。¥
expected
<number> The number of times the function was expected to be called. -
operator
<string> 被封装的函数的名称。¥
operator
<string> The name of the function that is wrapped. -
stack
<Object> 函数的堆栈跟踪。¥
stack
<Object> A stack trace of the function.
-
数组包含有关未调用预期次数的函数的预期和实际调用次数的信息。
¥The arrays contains information about the expected and actual number of calls of the functions that have not been called the expected number of times.
import assert from 'node:assert';
// Creates call tracker.
const tracker = new assert.CallTracker();
function func() {}
// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);
// Returns an array containing information on callsfunc()
console.log(tracker.report());
// [
// {
// message: 'Expected the func function to be executed 2 time(s) but was
// executed 0 time(s).',
// actual: 0,
// expected: 2,
// operator: 'func',
// stack: stack trace
// }
// ]
const assert = require('node:assert');
// Creates call tracker.
const tracker = new assert.CallTracker();
function func() {}
// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);
// Returns an array containing information on callsfunc()
console.log(tracker.report());
// [
// {
// message: 'Expected the func function to be executed 2 time(s) but was
// executed 0 time(s).',
// actual: 0,
// expected: 2,
// operator: 'func',
// stack: stack trace
// }
// ]
tracker.reset([fn])
#
-
fn
<Function> 一个要重置的跟踪函数。¥
fn
<Function> a tracked function to reset.
重置调用跟踪器的调用。如果被跟踪的函数作为参数传递,调用将被重置。如果没有传递参数,所有跟踪的函数将被重置。
¥Reset calls of the call tracker. If a tracked function is passed as an argument, the calls will be reset for it. If no arguments are passed, all tracked functions will be reset.
import assert from 'node:assert';
const tracker = new assert.CallTracker();
function func() {}
const callsfunc = tracker.calls(func);
callsfunc();
// Tracker was called once
assert.strictEqual(tracker.getCalls(callsfunc).length, 1);
tracker.reset(callsfunc);
assert.strictEqual(tracker.getCalls(callsfunc).length, 0);
const assert = require('node:assert');
const tracker = new assert.CallTracker();
function func() {}
const callsfunc = tracker.calls(func);
callsfunc();
// Tracker was called once
assert.strictEqual(tracker.getCalls(callsfunc).length, 1);
tracker.reset(callsfunc);
assert.strictEqual(tracker.getCalls(callsfunc).length, 0);
tracker.verify()
#
遍历传给 tracker.calls()
的函数列表,对于未按预期调用次数的函数将抛出错误。
¥Iterates through the list of functions passed to
tracker.calls()
and will throw an error for functions that
have not been called the expected number of times.
import assert from 'node:assert';
// Creates call tracker.
const tracker = new assert.CallTracker();
function func() {}
// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);
callsfunc();
// Will throw an error since callsfunc() was only called once.
tracker.verify();
const assert = require('node:assert');
// Creates call tracker.
const tracker = new assert.CallTracker();
function func() {}
// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);
callsfunc();
// Will throw an error since callsfunc() was only called once.
tracker.verify();
assert(value[, message])
#
assert.ok()
的别名。
¥An alias of assert.ok()
.
assert.deepEqual(actual, expected[, message])
#
严格断言模式
¥Strict assertion mode
¥An alias of assert.deepStrictEqual()
.
旧版断言模式
¥Legacy assertion mode
assert.deepStrictEqual()
。¥Stability: 3 - Legacy: Use assert.deepStrictEqual()
instead.
测试 actual
和 expected
参数之间的深度相等。考虑使用 assert.deepStrictEqual()
代替。assert.deepEqual()
可能产生意外的结果。
¥Tests for deep equality between the actual
and expected
parameters. Consider
using assert.deepStrictEqual()
instead. assert.deepEqual()
can have
surprising results.
深度相等意味着子对象的可枚举 "自有" 属性也按以下规则递归计算。
¥Deep equality means that the enumerable "own" properties of child objects are also recursively evaluated by the following rules.
比较详情#
¥Comparison details
-
原始值与
==
操作符 进行比较,但NaN
除外。如果双方都是NaN
,则视为相同。¥Primitive values are compared with the
==
operator, with the exception ofNaN
. It is treated as being identical in case both sides areNaN
. -
对象的 类型标签 应该是相同的。
¥Type tags of objects should be the same.
-
仅考虑 可枚举的 "自有" 属性。
¥Only enumerable "own" properties are considered.
-
始终比较
Error
名称、消息、原因和错误,即使这些不是可枚举属性。¥
Error
names, messages, causes, and errors are always compared, even if these are not enumerable properties. -
对象封装器 作为对象和展开的值进行比较。
¥Object wrappers are compared both as objects and unwrapped values.
-
Object
属性是无序比较的。¥
Object
properties are compared unordered. -
当双方不同或双方遇到循环引用时,则递归停止。
¥Recursion stops when both sides differ or both sides encounter a circular reference.
-
实现不测试对象的
[[Prototype]]
。¥Implementation does not test the
[[Prototype]]
of objects. -
不比较
Symbol
属性。¥
Symbol
properties are not compared. -
WeakMap
和WeakSet
的比较不依赖于它们的值。¥
WeakMap
andWeakSet
comparison does not rely on their values. -
RegExp
的 lastIndex、flags 和 source 总是被比较,即使它们不是可枚举的属性。¥
RegExp
lastIndex, flags, and source are always compared, even if these are not enumerable properties.
以下示例不会抛出 AssertionError
,因为基础类型是使用 ==
操作符 进行比较的。
¥The following example does not throw an AssertionError
because the
primitives are compared using the ==
operator.
import assert from 'node:assert';
// WARNING: This does not throw an AssertionError!
assert.deepEqual('+00000000', false);
const assert = require('node:assert');
// WARNING: This does not throw an AssertionError!
assert.deepEqual('+00000000', false);
"深度" 相等意味着子对象的可枚举 "自有" 属性也被评估:
¥"Deep" equality means that the enumerable "own" properties of child objects are evaluated also:
import assert from 'node:assert';
const obj1 = {
a: {
b: 1,
},
};
const obj2 = {
a: {
b: 2,
},
};
const obj3 = {
a: {
b: 1,
},
};
const obj4 = { __proto__: obj1 };
assert.deepEqual(obj1, obj1);
// OK
// Values of b are different:
assert.deepEqual(obj1, obj2);
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
assert.deepEqual(obj1, obj3);
// OK
// Prototypes are ignored:
assert.deepEqual(obj1, obj4);
// AssertionError: { a: { b: 1 } } deepEqual {}
const assert = require('node:assert');
const obj1 = {
a: {
b: 1,
},
};
const obj2 = {
a: {
b: 2,
},
};
const obj3 = {
a: {
b: 1,
},
};
const obj4 = { __proto__: obj1 };
assert.deepEqual(obj1, obj1);
// OK
// Values of b are different:
assert.deepEqual(obj1, obj2);
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
assert.deepEqual(obj1, obj3);
// OK
// Prototypes are ignored:
assert.deepEqual(obj1, obj4);
// AssertionError: { a: { b: 1 } } deepEqual {}
如果值不相等,则抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果未定义 message
参数,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥If the values are not equal, an AssertionError
is thrown with a message
property set equal to the value of the message
parameter. If the message
parameter is undefined, a default error message is assigned. If the message
parameter is an instance of an Error
then it will be thrown instead of the
AssertionError
.
assert.deepStrictEqual(actual, expected[, message])
#
测试 actual
和 expected
参数之间的深度相等。"深度" 相等意味着子对象的可枚举 "自有" 属性也按以下规则递归计算。
¥Tests for deep equality between the actual
and expected
parameters.
"Deep" equality means that the enumerable "own" properties of child objects
are recursively evaluated also by the following rules.
比较详情#
¥Comparison details
-
使用
Object.is()
比较原始值。¥Primitive values are compared using
Object.is()
. -
对象的 类型标签 应该是相同的。
¥Type tags of objects should be the same.
-
使用
===
操作符 比较对象的[[Prototype]]
。¥
[[Prototype]]
of objects are compared using the===
operator. -
仅考虑 可枚举的 "自有" 属性。
¥Only enumerable "own" properties are considered.
-
始终比较
Error
名称、消息、原因和错误,即使这些不是可枚举属性。errors
也进行了比较。¥
Error
names, messages, causes, and errors are always compared, even if these are not enumerable properties.errors
is also compared. -
也比较了可枚举的自有
Symbol
属性。¥Enumerable own
Symbol
properties are compared as well. -
对象封装器 作为对象和展开的值进行比较。
¥Object wrappers are compared both as objects and unwrapped values.
-
Object
属性是无序比较的。¥
Object
properties are compared unordered. -
当双方不同或双方遇到循环引用时,则递归停止。
¥Recursion stops when both sides differ or both sides encounter a circular reference.
-
WeakMap
和WeakSet
的比较不依赖于它们的值。有关更多详细信息,请参见下文。¥
WeakMap
andWeakSet
comparison does not rely on their values. See below for further details. -
RegExp
的 lastIndex、flags 和 source 总是被比较,即使它们不是可枚举的属性。¥
RegExp
lastIndex, flags, and source are always compared, even if these are not enumerable properties.
import assert from 'node:assert/strict';
// This fails because 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// {
// + a: 1
// - a: '1'
// }
// The following objects don't have own properties
const date = new Date();
const object = {};
const fakeDate = {};
Object.setPrototypeOf(fakeDate, Date.prototype);
// Different [[Prototype]]:
assert.deepStrictEqual(object, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}
// Different type tags:
assert.deepStrictEqual(date, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}
assert.deepStrictEqual(NaN, NaN);
// OK because Object.is(NaN, NaN) is true.
// Different unwrapped numbers:
assert.deepStrictEqual(new Number(1), new Number(2));
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]
assert.deepStrictEqual(new String('foo'), Object('foo'));
// OK because the object and the string are identical when unwrapped.
assert.deepStrictEqual(-0, -0);
// OK
// Different zeros:
assert.deepStrictEqual(0, -0);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0
const symbol1 = Symbol();
const symbol2 = Symbol();
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 });
// OK, because it is the same symbol on both objects.
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 });
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
// [Symbol()]: 1
// }
const weakMap1 = new WeakMap();
const weakMap2 = new WeakMap([[{}, {}]]);
const weakMap3 = new WeakMap();
weakMap3.unequal = true;
assert.deepStrictEqual(weakMap1, weakMap2);
// OK, because it is impossible to compare the entries
// Fails because weakMap3 has a property that weakMap1 does not contain:
assert.deepStrictEqual(weakMap1, weakMap3);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// WeakMap {
// + [items unknown]
// - [items unknown],
// - unequal: true
// }
const assert = require('node:assert/strict');
// This fails because 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// {
// + a: 1
// - a: '1'
// }
// The following objects don't have own properties
const date = new Date();
const object = {};
const fakeDate = {};
Object.setPrototypeOf(fakeDate, Date.prototype);
// Different [[Prototype]]:
assert.deepStrictEqual(object, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}
// Different type tags:
assert.deepStrictEqual(date, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}
assert.deepStrictEqual(NaN, NaN);
// OK because Object.is(NaN, NaN) is true.
// Different unwrapped numbers:
assert.deepStrictEqual(new Number(1), new Number(2));
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]
assert.deepStrictEqual(new String('foo'), Object('foo'));
// OK because the object and the string are identical when unwrapped.
assert.deepStrictEqual(-0, -0);
// OK
// Different zeros:
assert.deepStrictEqual(0, -0);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0
const symbol1 = Symbol();
const symbol2 = Symbol();
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 });
// OK, because it is the same symbol on both objects.
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 });
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
// [Symbol()]: 1
// }
const weakMap1 = new WeakMap();
const weakMap2 = new WeakMap([[{}, {}]]);
const weakMap3 = new WeakMap();
weakMap3.unequal = true;
assert.deepStrictEqual(weakMap1, weakMap2);
// OK, because it is impossible to compare the entries
// Fails because weakMap3 has a property that weakMap1 does not contain:
assert.deepStrictEqual(weakMap1, weakMap3);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// WeakMap {
// + [items unknown]
// - [items unknown],
// - unequal: true
// }
如果值不相等,则抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果未定义 message
参数,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥If the values are not equal, an AssertionError
is thrown with a message
property set equal to the value of the message
parameter. If the message
parameter is undefined, a default error message is assigned. If the message
parameter is an instance of an Error
then it will be thrown instead of the
AssertionError
.
assert.doesNotMatch(string, regexp[, message])
#
期望 string
输入与正则表达式不匹配。
¥Expects the string
input not to match the regular expression.
import assert from 'node:assert/strict';
assert.doesNotMatch('I will fail', /fail/);
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...
assert.doesNotMatch(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
assert.doesNotMatch('I will pass', /different/);
// OK
const assert = require('node:assert/strict');
assert.doesNotMatch('I will fail', /fail/);
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...
assert.doesNotMatch(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
assert.doesNotMatch('I will pass', /different/);
// OK
如果值匹配,或者 string
参数的类型不是 string
,则抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果未定义 message
参数,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥If the values do match, or if the string
argument is of another type than
string
, an AssertionError
is thrown with a message
property set equal
to the value of the message
parameter. If the message
parameter is
undefined, a default error message is assigned. If the message
parameter is an
instance of an Error
then it will be thrown instead of the
AssertionError
.
assert.doesNotReject(asyncFn[, error][, message])
#
-
asyncFn
<Function> | <Promise> -
error
<RegExp> | <Function> -
message
<string>
等待 asyncFn
promise,或者,如果 asyncFn
是函数,则立即调用该函数并等待返回的 promise 完成。然后会检查 promise 是否没有被拒绝。
¥Awaits the asyncFn
promise or, if asyncFn
is a function, immediately
calls the function and awaits the returned promise to complete. It will then
check that the promise is not rejected.
如果 asyncFn
是函数并且它同步抛出错误,则 assert.doesNotReject()
将返回使用使用该错误拒绝的 Promise
。如果函数没有返回 promise,则 assert.doesNotReject()
将返回使用 ERR_INVALID_RETURN_VALUE
错误拒绝的 Promise
。在这两种情况下,都会跳过错误句柄。
¥If asyncFn
is a function and it throws an error synchronously,
assert.doesNotReject()
will return a rejected Promise
with that error. If
the function does not return a promise, assert.doesNotReject()
will return a
rejected Promise
with an ERR_INVALID_RETURN_VALUE
error. In both cases
the error handler is skipped.
使用 assert.doesNotReject()
实际上没有用,因为捕获拒绝然后再次拒绝它几乎没有什么好处。相反,请考虑在特定代码路径旁边添加不应拒绝的注释,并尽可能使错误消息具有表现力。
¥Using assert.doesNotReject()
is actually not useful because there is little
benefit in catching a rejection and then rejecting it again. Instead, consider
adding a comment next to the specific code path that should not reject and keep
error messages as expressive as possible.
如果指定,则 error
可以是 Class
、RegExp
或验证函数。有关详细信息,请参阅 assert.throws()
。
¥If specified, error
can be a Class
, RegExp
, or a validation
function. See assert.throws()
for more details.
除了等待完成的异步性质外,其行为与 assert.doesNotThrow()
相同。
¥Besides the async nature to await the completion behaves identically to
assert.doesNotThrow()
.
import assert from 'node:assert/strict';
await assert.doesNotReject(
async () => {
throw new TypeError('Wrong value');
},
SyntaxError,
);
const assert = require('node:assert/strict');
(async () => {
await assert.doesNotReject(
async () => {
throw new TypeError('Wrong value');
},
SyntaxError,
);
})();
import assert from 'node:assert/strict';
assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
.then(() => {
// ...
});
const assert = require('node:assert/strict');
assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
.then(() => {
// ...
});
assert.doesNotThrow(fn[, error][, message])
#
-
fn
<Function> -
error
<RegExp> | <Function> -
message
<string>
断言函数 fn
不会抛出错误。
¥Asserts that the function fn
does not throw an error.
使用 assert.doesNotThrow()
实际上没有用,因为捕获错误然后重新抛出它没有任何好处。相反,请考虑在不应该抛出的特定代码路径旁边添加注释,并尽可能保持错误消息的表现力。
¥Using assert.doesNotThrow()
is actually not useful because there
is no benefit in catching an error and then rethrowing it. Instead, consider
adding a comment next to the specific code path that should not throw and keep
error messages as expressive as possible.
当 assert.doesNotThrow()
被调用时,它会立即调用 fn
函数。
¥When assert.doesNotThrow()
is called, it will immediately call the fn
function.
如果抛出错误并且它与 error
参数指定的类型相同,则抛出 AssertionError
。如果错误属于不同类型,或者 error
参数未定义,则错误将传播回调用者。
¥If an error is thrown and it is the same type as that specified by the error
parameter, then an AssertionError
is thrown. If the error is of a
different type, or if the error
parameter is undefined, the error is
propagated back to the caller.
如果指定,则 error
可以是 Class
、RegExp
或验证函数。有关详细信息,请参阅 assert.throws()
。
¥If specified, error
can be a Class
, RegExp
, or a validation
function. See assert.throws()
for more details.
例如,以下将抛出 TypeError
,因为断言中没有匹配的错误类型:
¥The following, for instance, will throw the TypeError
because there is no
matching error type in the assertion:
import assert from 'node:assert/strict';
assert.doesNotThrow(
() => {
throw new TypeError('Wrong value');
},
SyntaxError,
);
const assert = require('node:assert/strict');
assert.doesNotThrow(
() => {
throw new TypeError('Wrong value');
},
SyntaxError,
);
然而,以下将导致 AssertionError
和消息 '出现不需要的异常...':
¥However, the following will result in an AssertionError
with the message
'Got unwanted exception...':
import assert from 'node:assert/strict';
assert.doesNotThrow(
() => {
throw new TypeError('Wrong value');
},
TypeError,
);
const assert = require('node:assert/strict');
assert.doesNotThrow(
() => {
throw new TypeError('Wrong value');
},
TypeError,
);
如果抛出 AssertionError
并且为 message
参数提供了值,则 message
的值将附加到 AssertionError
消息:
¥If an AssertionError
is thrown and a value is provided for the message
parameter, the value of message
will be appended to the AssertionError
message:
import assert from 'node:assert/strict';
assert.doesNotThrow(
() => {
throw new TypeError('Wrong value');
},
/Wrong value/,
'Whoops',
);
// Throws: AssertionError: Got unwanted exception: Whoops
const assert = require('node:assert/strict');
assert.doesNotThrow(
() => {
throw new TypeError('Wrong value');
},
/Wrong value/,
'Whoops',
);
// Throws: AssertionError: Got unwanted exception: Whoops
assert.equal(actual, expected[, message])
#
严格断言模式
¥Strict assertion mode
assert.strictEqual()
的别名。
¥An alias of assert.strictEqual()
.
旧版断言模式
¥Legacy assertion mode
使用 ==
操作符 测试 actual
和 expected
参数之间的浅层强制相等性。NaN
是特殊处理的,如果双方都是 NaN
,则视为相同。
¥Tests shallow, coercive equality between the actual
and expected
parameters
using the ==
operator. NaN
is specially handled
and treated as being identical if both sides are NaN
.
import assert from 'node:assert';
assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 1 == '1'
assert.equal(NaN, NaN);
// OK
assert.equal(1, 2);
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
const assert = require('node:assert');
assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 1 == '1'
assert.equal(NaN, NaN);
// OK
assert.equal(1, 2);
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
如果值不相等,则抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果未定义 message
参数,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥If the values are not equal, an AssertionError
is thrown with a message
property set equal to the value of the message
parameter. If the message
parameter is undefined, a default error message is assigned. If the message
parameter is an instance of an Error
then it will be thrown instead of the
AssertionError
.
assert.fail([message])
#
抛出带有提供的错误消息或默认错误消息的 AssertionError
。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥Throws an AssertionError
with the provided error message or a default
error message. If the message
parameter is an instance of an Error
then
it will be thrown instead of the AssertionError
.
import assert from 'node:assert/strict';
assert.fail();
// AssertionError [ERR_ASSERTION]: Failed
assert.fail('boom');
// AssertionError [ERR_ASSERTION]: boom
assert.fail(new TypeError('need array'));
// TypeError: need array
const assert = require('node:assert/strict');
assert.fail();
// AssertionError [ERR_ASSERTION]: Failed
assert.fail('boom');
// AssertionError [ERR_ASSERTION]: boom
assert.fail(new TypeError('need array'));
// TypeError: need array
可以使用带有两个以上参数的 assert.fail()
,但不推荐使用。有关更多详细信息,请参见下文。
¥Using assert.fail()
with more than two arguments is possible but deprecated.
See below for further details.
assert.fail(actual, expected[, message[, operator[, stackStartFn]]])
#
assert.fail([message])
或其他断言函数。¥Stability: 0 - Deprecated: Use assert.fail([message])
or other assert
functions instead.
-
actual
<any> -
expected
<any> -
operator
<string> 默认值:'!='
¥
operator
<string> Default:'!='
-
stackStartFn
<Function> 默认值:assert.fail
¥
stackStartFn
<Function> Default:assert.fail
如果 message
为假,则错误消息设置为由提供的 operator
分隔的 actual
和 expected
的值。如果只提供了两个 actual
和 expected
参数,则 operator
将默认为 '!='
。如果 message
作为第三个参数提供,则它将用作错误消息,其他参数将作为抛出对象的属性存储。如果提供了 stackStartFn
,则该函数之上的所有堆栈帧都将从堆栈跟踪中删除(参见 Error.captureStackTrace
)。如果没有给出参数,则将使用默认消息 Failed
。
¥If message
is falsy, the error message is set as the values of actual
and
expected
separated by the provided operator
. If just the two actual
and
expected
arguments are provided, operator
will default to '!='
. If
message
is provided as third argument it will be used as the error message and
the other arguments will be stored as properties on the thrown object. If
stackStartFn
is provided, all stack frames above that function will be
removed from stacktrace (see Error.captureStackTrace
). If no arguments are
given, the default message Failed
will be used.
import assert from 'node:assert/strict';
assert.fail('a', 'b');
// AssertionError [ERR_ASSERTION]: 'a' != 'b'
assert.fail(1, 2, undefined, '>');
// AssertionError [ERR_ASSERTION]: 1 > 2
assert.fail(1, 2, 'fail');
// AssertionError [ERR_ASSERTION]: fail
assert.fail(1, 2, 'whoops', '>');
// AssertionError [ERR_ASSERTION]: whoops
assert.fail(1, 2, new TypeError('need array'));
// TypeError: need array
const assert = require('node:assert/strict');
assert.fail('a', 'b');
// AssertionError [ERR_ASSERTION]: 'a' != 'b'
assert.fail(1, 2, undefined, '>');
// AssertionError [ERR_ASSERTION]: 1 > 2
assert.fail(1, 2, 'fail');
// AssertionError [ERR_ASSERTION]: fail
assert.fail(1, 2, 'whoops', '>');
// AssertionError [ERR_ASSERTION]: whoops
assert.fail(1, 2, new TypeError('need array'));
// TypeError: need array
在后三种情况下,actual
、expected
和 operator
对错误消息没有影响。
¥In the last three cases actual
, expected
, and operator
have no
influence on the error message.
使用 stackStartFn
截断异常堆栈跟踪的示例:
¥Example use of stackStartFn
for truncating the exception's stacktrace:
import assert from 'node:assert/strict';
function suppressFrame() {
assert.fail('a', 'b', undefined, '!==', suppressFrame);
}
suppressFrame();
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
// at repl:1:1
// at ContextifyScript.Script.runInThisContext (vm.js:44:33)
// ...
const assert = require('node:assert/strict');
function suppressFrame() {
assert.fail('a', 'b', undefined, '!==', suppressFrame);
}
suppressFrame();
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
// at repl:1:1
// at ContextifyScript.Script.runInThisContext (vm.js:44:33)
// ...
assert.ifError(value)
#
value
<any>
如果 value
不是 undefined
或 null
,则抛出 value
。这在回调中测试 error
参数时很有用。堆栈跟踪包含来自传给 ifError()
的错误的所有帧,包括 ifError()
本身的潜在新帧。
¥Throws value
if value
is not undefined
or null
. This is useful when
testing the error
argument in callbacks. The stack trace contains all frames
from the error passed to ifError()
including the potential new frames for
ifError()
itself.
import assert from 'node:assert/strict';
assert.ifError(null);
// OK
assert.ifError(0);
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('error');
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
assert.ifError(new Error());
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error
// Create some random error frames.
let err;
(function errorFrame() {
err = new Error('test error');
})();
(function ifErrorFrame() {
assert.ifError(err);
})();
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
// at ifErrorFrame
// at errorFrame
const assert = require('node:assert/strict');
assert.ifError(null);
// OK
assert.ifError(0);
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('error');
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
assert.ifError(new Error());
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error
// Create some random error frames.
let err;
(function errorFrame() {
err = new Error('test error');
})();
(function ifErrorFrame() {
assert.ifError(err);
})();
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
// at ifErrorFrame
// at errorFrame
assert.match(string, regexp[, message])
#
期望 string
输入与正则表达式匹配。
¥Expects the string
input to match the regular expression.
import assert from 'node:assert/strict';
assert.match('I will fail', /pass/);
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...
assert.match(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
assert.match('I will pass', /pass/);
// OK
const assert = require('node:assert/strict');
assert.match('I will fail', /pass/);
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...
assert.match(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
assert.match('I will pass', /pass/);
// OK
如果值不匹配,或者 string
参数的类型不是 string
,则抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果未定义 message
参数,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥If the values do not match, or if the string
argument is of another type than
string
, an AssertionError
is thrown with a message
property set equal
to the value of the message
parameter. If the message
parameter is
undefined, a default error message is assigned. If the message
parameter is an
instance of an Error
then it will be thrown instead of the
AssertionError
.
assert.notDeepEqual(actual, expected[, message])
#
严格断言模式
¥Strict assertion mode
assert.notDeepStrictEqual()
的别名。
¥An alias of assert.notDeepStrictEqual()
.
旧版断言模式
¥Legacy assertion mode
assert.notDeepStrictEqual()
。¥Stability: 3 - Legacy: Use assert.notDeepStrictEqual()
instead.
测试任何深度不相等。assert.deepEqual()
的相反。
¥Tests for any deep inequality. Opposite of assert.deepEqual()
.
import assert from 'node:assert';
const obj1 = {
a: {
b: 1,
},
};
const obj2 = {
a: {
b: 2,
},
};
const obj3 = {
a: {
b: 1,
},
};
const obj4 = { __proto__: obj1 };
assert.notDeepEqual(obj1, obj1);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
assert.notDeepEqual(obj1, obj2);
// OK
assert.notDeepEqual(obj1, obj3);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
assert.notDeepEqual(obj1, obj4);
// OK
const assert = require('node:assert');
const obj1 = {
a: {
b: 1,
},
};
const obj2 = {
a: {
b: 2,
},
};
const obj3 = {
a: {
b: 1,
},
};
const obj4 = { __proto__: obj1 };
assert.notDeepEqual(obj1, obj1);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
assert.notDeepEqual(obj1, obj2);
// OK
assert.notDeepEqual(obj1, obj3);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
assert.notDeepEqual(obj1, obj4);
// OK
如果值深度相等,则会抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果未定义 message
参数,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥If the values are deeply equal, an AssertionError
is thrown with a
message
property set equal to the value of the message
parameter. If the
message
parameter is undefined, a default error message is assigned. If the
message
parameter is an instance of an Error
then it will be thrown
instead of the AssertionError
.
assert.notDeepStrictEqual(actual, expected[, message])
#
检验深度严格不相等。assert.deepStrictEqual()
的相反。
¥Tests for deep strict inequality. Opposite of assert.deepStrictEqual()
.
import assert from 'node:assert/strict';
assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// OK
const assert = require('node:assert/strict');
assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// OK
如果值是深度且严格相等的,则抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果未定义 message
参数,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥If the values are deeply and strictly equal, an AssertionError
is thrown
with a message
property set equal to the value of the message
parameter. If
the message
parameter is undefined, a default error message is assigned. If
the message
parameter is an instance of an Error
then it will be thrown
instead of the AssertionError
.
assert.notEqual(actual, expected[, message])
#
严格断言模式
¥Strict assertion mode
¥An alias of assert.notStrictEqual()
.
旧版断言模式
¥Legacy assertion mode
使用 !=
操作符 测试肤浅的强制性不平等。NaN
是特殊处理的,如果双方都是 NaN
,则视为相同。
¥Tests shallow, coercive inequality with the !=
operator. NaN
is
specially handled and treated as being identical if both sides are NaN
.
import assert from 'node:assert';
assert.notEqual(1, 2);
// OK
assert.notEqual(1, 1);
// AssertionError: 1 != 1
assert.notEqual(1, '1');
// AssertionError: 1 != '1'
const assert = require('node:assert');
assert.notEqual(1, 2);
// OK
assert.notEqual(1, 1);
// AssertionError: 1 != 1
assert.notEqual(1, '1');
// AssertionError: 1 != '1'
如果值相等,则抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果未定义 message
参数,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥If the values are equal, an AssertionError
is thrown with a message
property set equal to the value of the message
parameter. If the message
parameter is undefined, a default error message is assigned. If the message
parameter is an instance of an Error
then it will be thrown instead of the
AssertionError
.
assert.notStrictEqual(actual, expected[, message])
#
测试由 Object.is()
确定的 actual
和 expected
参数之间的严格不相等。
¥Tests strict inequality between the actual
and expected
parameters as
determined by Object.is()
.
import assert from 'node:assert/strict';
assert.notStrictEqual(1, 2);
// OK
assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1
assert.notStrictEqual(1, '1');
// OK
const assert = require('node:assert/strict');
assert.notStrictEqual(1, 2);
// OK
assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1
assert.notStrictEqual(1, '1');
// OK
如果值严格相等,则抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果未定义 message
参数,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥If the values are strictly equal, an AssertionError
is thrown with a
message
property set equal to the value of the message
parameter. If the
message
parameter is undefined, a default error message is assigned. If the
message
parameter is an instance of an Error
then it will be thrown
instead of the AssertionError
.
assert.ok(value[, message])
#
测试 value
是否为真。相当于 assert.equal(!!value, true, message)
。
¥Tests if value
is truthy. It is equivalent to
assert.equal(!!value, true, message)
.
如果 value
不是真值,则抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果 message
参数为 undefined
,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。如果根本没有传入任何参数,message
将被设置为字符串:'No value argument passed to
assert.ok()'
。
¥If value
is not truthy, an AssertionError
is thrown with a message
property set equal to the value of the message
parameter. If the message
parameter is undefined
, a default error message is assigned. If the message
parameter is an instance of an Error
then it will be thrown instead of the
AssertionError
.
If no arguments are passed in at all message
will be set to the string:
'No value argument passed to `assert.ok()`'
.
请注意,在 repl
中,错误消息将与文件中抛出的错误消息不同!有关更多详细信息,请参见下文。
¥Be aware that in the repl
the error message will be different to the one
thrown in a file! See below for further details.
import assert from 'node:assert/strict';
assert.ok(true);
// OK
assert.ok(1);
// OK
assert.ok();
// AssertionError: No value argument passed to `assert.ok()`
assert.ok(false, 'it\'s false');
// AssertionError: it's false
// In the repl:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true
// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: The expression evaluated to a falsy value:
//
// assert.ok(typeof 123 === 'string')
assert.ok(false);
// AssertionError: The expression evaluated to a falsy value:
//
// assert.ok(false)
assert.ok(0);
// AssertionError: The expression evaluated to a falsy value:
//
// assert.ok(0)
const assert = require('node:assert/strict');
assert.ok(true);
// OK
assert.ok(1);
// OK
assert.ok();
// AssertionError: No value argument passed to `assert.ok()`
assert.ok(false, 'it\'s false');
// AssertionError: it's false
// In the repl:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true
// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: The expression evaluated to a falsy value:
//
// assert.ok(typeof 123 === 'string')
assert.ok(false);
// AssertionError: The expression evaluated to a falsy value:
//
// assert.ok(false)
assert.ok(0);
// AssertionError: The expression evaluated to a falsy value:
//
// assert.ok(0)
import assert from 'node:assert/strict';
// Using `assert()` works the same:
assert(0);
// AssertionError: The expression evaluated to a falsy value:
//
// assert(0)
const assert = require('node:assert');
// Using `assert()` works the same:
assert(0);
// AssertionError: The expression evaluated to a falsy value:
//
// assert(0)
assert.rejects(asyncFn[, error][, message])
#
-
asyncFn
<Function> | <Promise> -
error
<RegExp> | <Function> | <Object> | <Error> -
message
<string>
等待 asyncFn
promise,或者,如果 asyncFn
是函数,则立即调用该函数并等待返回的 promise 完成。然后将检查 promise 是否被拒绝。
¥Awaits the asyncFn
promise or, if asyncFn
is a function, immediately
calls the function and awaits the returned promise to complete. It will then
check that the promise is rejected.
如果 asyncFn
是函数并且它同步抛出错误,则 assert.rejects()
将返回使用使用该错误拒绝的 Promise
。如果函数没有返回 promise,则 assert.rejects()
将返回使用 ERR_INVALID_RETURN_VALUE
错误拒绝的 Promise
。在这两种情况下,都会跳过错误句柄。
¥If asyncFn
is a function and it throws an error synchronously,
assert.rejects()
will return a rejected Promise
with that error. If the
function does not return a promise, assert.rejects()
will return a rejected
Promise
with an ERR_INVALID_RETURN_VALUE
error. In both cases the error
handler is skipped.
除了等待完成的异步性质外,其行为与 assert.throws()
相同。
¥Besides the async nature to await the completion behaves identically to
assert.throws()
.
如果指定,则 error
可以是 Class
、RegExp
、验证函数、每个属性将被测试的对象,或者每个属性(包括不可枚举的 message
和 name
属性)将被测试的错误实例。
¥If specified, error
can be a Class
, RegExp
, a validation function,
an object where each property will be tested for, or an instance of error where
each property will be tested for including the non-enumerable message
and
name
properties.
如果指定,则 message
将是 AssertionError
提供的消息(如果 asyncFn
没有被拒绝)。
¥If specified, message
will be the message provided by the AssertionError
if the asyncFn
fails to reject.
import assert from 'node:assert/strict';
await assert.rejects(
async () => {
throw new TypeError('Wrong value');
},
{
name: 'TypeError',
message: 'Wrong value',
},
);
const assert = require('node:assert/strict');
(async () => {
await assert.rejects(
async () => {
throw new TypeError('Wrong value');
},
{
name: 'TypeError',
message: 'Wrong value',
},
);
})();
import assert from 'node:assert/strict';
await assert.rejects(
async () => {
throw new TypeError('Wrong value');
},
(err) => {
assert.strictEqual(err.name, 'TypeError');
assert.strictEqual(err.message, 'Wrong value');
return true;
},
);
const assert = require('node:assert/strict');
(async () => {
await assert.rejects(
async () => {
throw new TypeError('Wrong value');
},
(err) => {
assert.strictEqual(err.name, 'TypeError');
assert.strictEqual(err.message, 'Wrong value');
return true;
},
);
})();
import assert from 'node:assert/strict';
assert.rejects(
Promise.reject(new Error('Wrong value')),
Error,
).then(() => {
// ...
});
const assert = require('node:assert/strict');
assert.rejects(
Promise.reject(new Error('Wrong value')),
Error,
).then(() => {
// ...
});
error
不能是字符串。如果提供字符串作为第二个参数,则假定 error
被省略,而该字符串将用于 message
。这可能会导致容易遗漏的错误。如果考虑使用字符串作为第二个参数,则请仔细读阅 assert.throws()
中的示例。
¥error
cannot be a string. If a string is provided as the second
argument, then error
is assumed to be omitted and the string will be used for
message
instead. This can lead to easy-to-miss mistakes. Please read the
example in assert.throws()
carefully if using a string as the second
argument gets considered.
assert.strictEqual(actual, expected[, message])
#
测试由 Object.is()
确定的 actual
和 expected
参数之间的严格相等。
¥Tests strict equality between the actual
and expected
parameters as
determined by Object.is()
.
import assert from 'node:assert/strict';
assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2
assert.strictEqual(1, 1);
// OK
assert.strictEqual('Hello foobar', 'Hello World!');
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
// ^
const apples = 1;
const oranges = 2;
assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2
assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
// TypeError: Inputs are not identical
const assert = require('node:assert/strict');
assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2
assert.strictEqual(1, 1);
// OK
assert.strictEqual('Hello foobar', 'Hello World!');
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
// ^
const apples = 1;
const oranges = 2;
assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2
assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
// TypeError: Inputs are not identical
如果值不严格相等,则抛出 AssertionError
,其 message
属性设置为等于 message
参数的值。如果未定义 message
参数,则分配默认错误消息。如果 message
参数是 Error
的实例,则将抛出错误而不是 AssertionError
。
¥If the values are not strictly equal, an AssertionError
is thrown with a
message
property set equal to the value of the message
parameter. If the
message
parameter is undefined, a default error message is assigned. If the
message
parameter is an instance of an Error
then it will be thrown
instead of the AssertionError
.
assert.throws(fn[, error][, message])
#
-
fn
<Function> -
error
<RegExp> | <Function> | <Object> | <Error> -
message
<string>
期望函数 fn
抛出错误。
¥Expects the function fn
to throw an error.
如果指定,则 error
可以是 Class
、RegExp
、验证函数、其中每个属性都将进行严格深度相等测试的验证对象,或者其中每个属性(包括不可枚举的 message
和 name
属性)都将进行严格深度相等测试的错误实例。使用对象时,也可以使用正则表达式来验证字符串属性。有关示例,请参见下文。
¥If specified, error
can be a Class
, RegExp
, a validation function,
a validation object where each property will be tested for strict deep equality,
or an instance of error where each property will be tested for strict deep
equality including the non-enumerable message
and name
properties. When
using an object, it is also possible to use a regular expression, when
validating against a string property. See below for examples.
如果指定,且如果 fn
调用失败或错误验证失败,则 message
将附加到 AssertionError
提供的消息。
¥If specified, message
will be appended to the message provided by the
AssertionError
if the fn
call fails to throw or in case the error validation
fails.
自定义验证对象/错误实例:
¥Custom validation object/error instance:
import assert from 'node:assert/strict';
const err = new TypeError('Wrong value');
err.code = 404;
err.foo = 'bar';
err.info = {
nested: true,
baz: 'text',
};
err.reg = /abc/i;
assert.throws(
() => {
throw err;
},
{
name: 'TypeError',
message: 'Wrong value',
info: {
nested: true,
baz: 'text',
},
// Only properties on the validation object will be tested for.
// Using nested objects requires all properties to be present. Otherwise
// the validation is going to fail.
},
);
// Using regular expressions to validate error properties:
assert.throws(
() => {
throw err;
},
{
// The `name` and `message` properties are strings and using regular
// expressions on those will match against the string. If they fail, an
// error is thrown.
name: /^TypeError$/,
message: /Wrong/,
foo: 'bar',
info: {
nested: true,
// It is not possible to use regular expressions for nested properties!
baz: 'text',
},
// The `reg` property contains a regular expression and only if the
// validation object contains an identical regular expression, it is going
// to pass.
reg: /abc/i,
},
);
// Fails due to the different `message` and `name` properties:
assert.throws(
() => {
const otherErr = new Error('Not found');
// Copy all enumerable properties from `err` to `otherErr`.
for (const [key, value] of Object.entries(err)) {
otherErr[key] = value;
}
throw otherErr;
},
// The error's `message` and `name` properties will also be checked when using
// an error as validation object.
err,
);
const assert = require('node:assert/strict');
const err = new TypeError('Wrong value');
err.code = 404;
err.foo = 'bar';
err.info = {
nested: true,
baz: 'text',
};
err.reg = /abc/i;
assert.throws(
() => {
throw err;
},
{
name: 'TypeError',
message: 'Wrong value',
info: {
nested: true,
baz: 'text',
},
// Only properties on the validation object will be tested for.
// Using nested objects requires all properties to be present. Otherwise
// the validation is going to fail.
},
);
// Using regular expressions to validate error properties:
assert.throws(
() => {
throw err;
},
{
// The `name` and `message` properties are strings and using regular
// expressions on those will match against the string. If they fail, an
// error is thrown.
name: /^TypeError$/,
message: /Wrong/,
foo: 'bar',
info: {
nested: true,
// It is not possible to use regular expressions for nested properties!
baz: 'text',
},
// The `reg` property contains a regular expression and only if the
// validation object contains an identical regular expression, it is going
// to pass.
reg: /abc/i,
},
);
// Fails due to the different `message` and `name` properties:
assert.throws(
() => {
const otherErr = new Error('Not found');
// Copy all enumerable properties from `err` to `otherErr`.
for (const [key, value] of Object.entries(err)) {
otherErr[key] = value;
}
throw otherErr;
},
// The error's `message` and `name` properties will also be checked when using
// an error as validation object.
err,
);
使用构造函数验证 instanceof:
¥Validate instanceof using constructor:
import assert from 'node:assert/strict';
assert.throws(
() => {
throw new Error('Wrong value');
},
Error,
);
const assert = require('node:assert/strict');
assert.throws(
() => {
throw new Error('Wrong value');
},
Error,
);
使用 RegExp
验证错误消息:
¥Validate error message using RegExp
:
使用正则表达式在错误对象上运行 .toString
,因此还将包含错误名称。
¥Using a regular expression runs .toString
on the error object, and will
therefore also include the error name.
import assert from 'node:assert/strict';
assert.throws(
() => {
throw new Error('Wrong value');
},
/^Error: Wrong value$/,
);
const assert = require('node:assert/strict');
assert.throws(
() => {
throw new Error('Wrong value');
},
/^Error: Wrong value$/,
);
自定义错误验证:
¥Custom error validation:
该函数必须返回 true
以指示通过了所有内部验证。否则它将因 AssertionError
而失败。
¥The function must return true
to indicate all internal validations passed.
It will otherwise fail with an AssertionError
.
import assert from 'node:assert/strict';
assert.throws(
() => {
throw new Error('Wrong value');
},
(err) => {
assert(err instanceof Error);
assert(/value/.test(err));
// Avoid returning anything from validation functions besides `true`.
// Otherwise, it's not clear what part of the validation failed. Instead,
// throw an error about the specific validation that failed (as done in this
// example) and add as much helpful debugging information to that error as
// possible.
return true;
},
'unexpected error',
);
const assert = require('node:assert/strict');
assert.throws(
() => {
throw new Error('Wrong value');
},
(err) => {
assert(err instanceof Error);
assert(/value/.test(err));
// Avoid returning anything from validation functions besides `true`.
// Otherwise, it's not clear what part of the validation failed. Instead,
// throw an error about the specific validation that failed (as done in this
// example) and add as much helpful debugging information to that error as
// possible.
return true;
},
'unexpected error',
);
error
不能是字符串。如果提供字符串作为第二个参数,则假定 error
被省略,而该字符串将用于 message
。这可能会导致容易遗漏的错误。使用与抛出的错误消息相同的消息将导致 ERR_AMBIGUOUS_ARGUMENT
错误。如果考虑使用字符串作为第二个参数,则请仔细读阅下面的示例:
¥error
cannot be a string. If a string is provided as the second
argument, then error
is assumed to be omitted and the string will be used for
message
instead. This can lead to easy-to-miss mistakes. Using the same
message as the thrown error message is going to result in an
ERR_AMBIGUOUS_ARGUMENT
error. Please read the example below carefully if using
a string as the second argument gets considered:
import assert from 'node:assert/strict';
function throwingFirst() {
throw new Error('First');
}
function throwingSecond() {
throw new Error('Second');
}
function notThrowing() {}
// The second argument is a string and the input function threw an Error.
// The first case will not throw as it does not match for the error message
// thrown by the input function!
assert.throws(throwingFirst, 'Second');
// In the next example the message has no benefit over the message from the
// error and since it is not clear if the user intended to actually match
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]
// The string is only used (as message) in case the function does not throw:
assert.throws(notThrowing, 'Second');
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second
// If it was intended to match for the error message do this instead:
// It does not throw because the error messages match.
assert.throws(throwingSecond, /Second$/);
// If the error message does not match, an AssertionError is thrown.
assert.throws(throwingFirst, /Second$/);
// AssertionError [ERR_ASSERTION]
const assert = require('node:assert/strict');
function throwingFirst() {
throw new Error('First');
}
function throwingSecond() {
throw new Error('Second');
}
function notThrowing() {}
// The second argument is a string and the input function threw an Error.
// The first case will not throw as it does not match for the error message
// thrown by the input function!
assert.throws(throwingFirst, 'Second');
// In the next example the message has no benefit over the message from the
// error and since it is not clear if the user intended to actually match
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]
// The string is only used (as message) in case the function does not throw:
assert.throws(notThrowing, 'Second');
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second
// If it was intended to match for the error message do this instead:
// It does not throw because the error messages match.
assert.throws(throwingSecond, /Second$/);
// If the error message does not match, an AssertionError is thrown.
assert.throws(throwingFirst, /Second$/);
// AssertionError [ERR_ASSERTION]
由于容易混淆的符号,请避免将字符串作为第二个参数。
¥Due to the confusing error-prone notation, avoid a string as the second argument.