Node.js v18.18.2 文档

严格断言模式#

在严格断言模式下，非严格方法的行为与其相应的严格方法类似。例如，assert.deepEqual() 的行为类似于 assert.deepStrictEqual()。

在严格断言模式下，对象的错误消息显示差异。在旧断言模式中，对象的错误消息显示对象，通常会被截断。

要使用严格断言模式：

import { strict as assert } from 'node:assert';const assert = require('node:assert').strict;copy

import assert from 'node:assert/strict';const assert = require('node:assert/strict');copy

错误差异示例：

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
//   ]copy

要停用颜色，请使用NO_COLOR或NODE_DISABLE_COLORS 环境变量。这也将停用 REPL 中的颜色。有关终端环境中颜色支持的更多信息，请阅读 tty getColorDepth()文档。

遗留断言模式#

传统断言模式在以下情况中使用==运算符：

• assert.deepEqual()
• assert.equal()
• assert.notDeepEqual()
• assert.notEqual()

要使用旧断言模式：

import assert from 'node:assert';const assert = require('node:assert');copy

传统断言模式可能会产生令人惊讶的结果，特别是在使用 assert.deepEqual()时：

// WARNING: This does not throw an AssertionError in legacy assertion mode!
assert.deepEqual(/a/gi, new Date()); copy

类：assert.AssertionError[来源]#

• 扩展：<错误.错误>

表示断言失败。node:assert模块抛出的所有错误 都将是AssertionError类的实例。

new assert.AssertionError(options)#

• options <对象>
  • message <string>如果提供，错误消息将设置为此值。
  • actual <any>错误实例的actual属性。
  • expected <any>错误实例的expected属性。
  • operator <string>错误实例的operator属性。
  • stackStartFn <Function>如果提供，生成的堆栈跟踪将省略该函数之前的帧。

Error的子类，指示断言失败。

所有实例都包含内置的Error属性（message和name）并且：

• actual <any>设置为assert.strictEqual()等方法的 actual参数。
• expected <any>设置为expected等方法的值 assert.strictEqual()。
• generatedMessage <boolean>指示消息是否自动生成 ( true )。
• code <string>值始终为ERR_ASSERTION以表明该错误是断言错误。
• operator <string>设置为传入的运算符值。

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

类：assert.CallTracker#

此功能目前处于实验阶段，行为可能仍会发生变化。

new assert.CallTracker()#

创建一个新的CallTracker对象，可用于跟踪函数是否被调用特定次数。必须调用tracker.verify()才能进行验证。通常的模式是在process.on('exit')处理程序中调用它 。

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 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();
});copy

tracker.calls([fn][, exact])#

• fn <Function> 默认：无操作函数。
• exact <数字> 默认值： 1。
• 返回：包装fn的<Function>。

包装函数预计会被准确调用exact次。如果在调用tracker.verify()时该函数尚未被准确调用 exact 次 ，则tracker.verify()将抛出错误。

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

tracker.getCalls(fn)#

• fn <函数> .

• 返回：<Array>包含对跟踪函数的所有调用。

• 对象<对象>

  • thisArg <对象>
  • arguments <Array>传递给跟踪函数的参数

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] }]);copy

tracker.report()#

• 返回：对象的<Array> ，其中包含有关tracker.calls()返回的包装器函数的信息。
• 对象<对象>
  • message <字符串>
  • actual <number>调用函数的实际次数。
  • expected <number>预期调用函数的次数。
  • operator <string>被包装的函数的名称。
  • stack <Object>函数的堆栈跟踪。

这些数组包含有关未调用预期次数的函数的预期调用次数和实际调用次数的信息。

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
//  }
// ]copy

tracker.reset([fn])#

• fn <Function>要重置的跟踪函数。

重置呼叫跟踪器的呼叫。如果跟踪的函数作为参数传递，则将重置它的调用。如果没有传递参数，所有跟踪的函数将被重置

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

tracker.verify()#

迭代传递给 tracker.calls()的函数列表，并对未调用预期次数的函数抛出错误。

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

assert(value[, message])#

• value <any>检查输入是否真实。
• message <字符串> | <错误>

assert.ok()的别名。

assert.deepEqual(actual, expected[, message])#

• actual <任意>
• expected <任意>
• message <字符串> | <错误>

严格断言模式

assert.deepStrictEqual()的别名。

遗留断言模式

测试actual和expected参数之间的深度相等。考虑使用assert.deepStrictEqual()代替。assert.deepEqual()可能会产生令人惊讶的结果。

深度相等意味着子对象的可枚举“自己”属性也按以下规则递归评估。

比较详情#

• 原始值与==运算符进行比较，但NaN除外。如果双方都是NaN ，则将其视为相同。
• 对象的类型标签应该相同。
• 仅考虑可枚举的“自己”属性。
• Error名称和消息始终会进行比较，即使它们不是可枚举属性。
• 对象包装器作为对象和未包装的值进行比较。
• Object属性按无序进行比较。
• Map键和Set项按无序进行比较。
• 当双方不同或双方遇到循环引用时，递归停止。
• 实现不会测试对象的[[Prototype]]。
• 不比较Symbol属性。
• WeakMap和WeakSet比较不依赖于它们的值。
• RegExp lastIndex、flags 和 source 始终会进行比较，即使这些不是可枚举属性。

以下示例不会抛出AssertionError，因为基元是使用==运算符进行比较的。

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

“深度”相等意味着子对象的可枚举“自己”属性也会被评估：

import assert from 'node:assert';

const obj1 = {
  a: {
    b: 1,
  },
};
const obj2 = {
  a: {
    b: 2,
  },
};
const obj3 = {
  a: {
    b: 1,
  },
};
const obj4 = Object.create(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 = Object.create(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 {}copy

如果值不相等，则会抛出一个AssertionError，其中的message 属性设置等于message参数的值。如果 未定义message参数，则会分配默认错误消息。如果message参数是Error 的实例，那么它将被抛出，而不是 AssertionError。

assert.deepStrictEqual(actual, expected[, message])#

• actual <任意>
• expected <任意>
• message <字符串> | <错误>

测试actual和expected参数之间的深度相等。“深度”相等意味着子对象的可枚举“自己”属性也按以下规则递归评估。

比较详情#

• 使用Object.is()比较原始值。
• 对象的类型标签应该相同。
• 使用===运算符比较[[Prototype]]对象。
• 仅考虑可枚举的“自己”属性。
• Error名称和消息始终会进行比较，即使它们不是可枚举属性。
• 还比较了枚举自己的Symbol属性。
• 对象包装器作为对象和未包装的值进行比较。
• Object属性按无序进行比较。
• Map键和Set项按无序进行比较。
• 当双方不同或双方遇到循环引用时，递归停止。
• WeakMap和WeakSet比较不依赖于它们的值。请参阅下文了解更多详情。
• RegExp lastIndex、flags 和 source 始终会进行比较，即使这些不是可枚举属性。

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
//   }copy

如果值不相等，则会抛出一个AssertionError，其中的message 属性设置等于message参数的值。如果 未定义message参数，则会分配默认错误消息。如果message参数是Error 的实例，那么它将被抛出，而不是 AssertionError。

assert.doesNotMatch(string, regexp[, message])#

• string <字符串>
• regexp <正则表达式>
• message <字符串> | <错误>

预计string输入与正则表达式不匹配。

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/);
// OKconst 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/);
// OKcopy

如果值确实匹配，或者如果string参数的类型不是 string，则会抛出带有message属性的AssertionError设置等于message参数的值。如果未定义message参数，则会分配默认错误消息。如果message参数是Error的实例，那么它将被抛出，而不是 AssertionError。

assert.doesNotReject(asyncFn[, error][, message])#

• asyncFn <函数> | < Promise >
• error <正则表达式> | <函数>
• message <字符串>

等待asyncFn Promise，或者如果asyncFn是函数，则立即调用该函数并等待返回的 Promise 完成。然后它会检查 Promise 是否未被拒绝。

如果asyncFn是一个函数并且它同步抛出错误，则 assert.doesNotReject()将返回带有该错误的被拒绝的Promise。如果该函数不返回 Promise，则assert.doesNotReject()将返回被拒绝的Promise并出现ERR_INVALID_RETURN_VALUE错误。在这两种情况下，都会跳过错误处理程序。

使用assert.doesNotReject()实际上没有什么用，因为捕获拒绝然后再次拒绝它没有什么好处。相反，请考虑在特定代码路径旁边添加注释，该注释不应拒绝并尽可能保持错误消息的表达性。

如果指定，error可以是Class、RegExp或验证函数。请参阅assert.throws()了解更多详情。

除了等待完成的异步性质之外，其行为与 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,
  );
})();copy

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(() => {
    // ...
  });copy

assert.doesNotThrow(fn[, error][, message])#

• fn <函数>
• error <正则表达式> | <函数>
• message <字符串>

断言函数fn不会引发错误。

使用assert.doesNotThrow()实际上没有什么用，因为捕获错误然后重新抛出它没有任何好处。相反，请考虑在特定代码路径旁边添加注释，该注释不应抛出并尽可能保持错误消息的表达力。

当调用assert.doesNotThrow()时，它会立即调用fn 函数。

如果抛出错误且其类型与error参数指定的类型相同 ，则抛出AssertionError 。如果错误属于不同类型，或者如果error参数未定义，则错误将传播回调用方。

如果指定，error可以是Class、RegExp或验证函数。请参阅assert.throws()了解更多详情。

例如，以下内容将抛出TypeError，因为断言中没有匹配的错误类型：

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

但是，以下操作将导致AssertionError出现消息“出现不需要的异常...”：

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

如果抛出AssertionError并为message参数提供了值，则 message 的值将附加到AssertionError 消息中:

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  /Wrong value/,
  'Whoops',
);
// Throws: AssertionError: Got unwanted exception: Whoopsconst assert = require('node:assert/strict');

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  /Wrong value/,
  'Whoops',
);
// Throws: AssertionError: Got unwanted exception: Whoopscopy

assert.equal(actual, expected[, message])#

• actual <任意>
• expected <任意>
• message <字符串> | <错误>

严格断言模式

assert.strictEqual()的别名。

遗留断言模式

使用==运算符测试actual和expected参数之间的浅层强制相等。如果两边都是 NaN ，则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 } }copy

如果值不相等，则会抛出一个AssertionError，其中的message 属性设置等于message参数的值。如果 未定义message参数，则会分配默认错误消息。如果message参数是Error 的实例，那么它将被抛出，而不是 AssertionError。

assert.fail([message])#

• message <字符串> | <错误> 默认值： 'Failed'

抛出一个带有提供的错误消息或默认错误消息的AssertionError 。如果message参数是Error的实例，那么它将被抛出，而不是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 arrayconst 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 arraycopy

可以将assert.fail()与两个以上的参数一起使用，但已弃用。请参阅下文了解更多详情。

assert.fail(actual, expected[, message[, operator[, stackStartFn]]])#

• actual <任意>
• expected <任意>
• message <字符串> | <错误>
• operator <字符串> 默认值： '!='
• stackStartFn <函数> 默认： assert.fail

如果message为假，则错误消息设置为actual和 expected的值，并由提供的operator分隔。如果仅提供两个actual和 expected参数，则operator将默认为'!='。如果 提供message作为第三个参数，它将用作错误消息，其他参数将作为属性存储在抛出的对象上。如果 提供了stackStartFn，则该函数上方的所有堆栈帧都将从堆栈跟踪中删除（请参阅Error.captureStackTrace）。如果未给出参数，则将使用默认消息Failed 。

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 arrayconst 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 arraycopy

在最后三种情况下， actual、expected和operator对错误消息没有影响。

使用stackStartFn截断异常堆栈跟踪的示例：

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

assert.ifError(value)#

• value <任意>

如果value不是undefined或null ，则抛出 value 。这在测试回调中的error参数时非常有用。堆栈跟踪包含传递到ifError()的错误中的所有帧，包括ifError()本身的潜在新帧 。

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 errorFrameconst 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 errorFramecopy

assert.match(string, regexp[, message])#

• string <字符串>
• regexp <正则表达式>
• message <字符串> | <错误>

期望string输入与正则表达式匹配。

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/);
// OKconst 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/);
// OKcopy

如果值不匹配，或者string参数的类型不是 string，则会抛出AssertionError和message属性设置等于message参数的值。如果未定义message参数，则会分配默认错误消息。如果message参数是Error的实例，那么它将被抛出，而不是 AssertionError。

assert.notDeepEqual(actual, expected[, message])#

• actual <任意>
• expected <任意>
• message <字符串> | <错误>

严格断言模式

assert.notDeepStrictEqual()的别名。

遗留断言模式

测试是否存在严重的不平等。与assert.deepEqual()相反。

import assert from 'node:assert';

const obj1 = {
  a: {
    b: 1,
  },
};
const obj2 = {
  a: {
    b: 2,
  },
};
const obj3 = {
  a: {
    b: 1,
  },
};
const obj4 = Object.create(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);
// OKconst assert = require('node:assert');

const obj1 = {
  a: {
    b: 1,
  },
};
const obj2 = {
  a: {
    b: 2,
  },
};
const obj3 = {
  a: {
    b: 1,
  },
};
const obj4 = Object.create(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);
// OKcopy

如果值非常相等，则会抛出 一个AssertionError，其中的message属性设置等于message参数的值。如果 未定义message参数，则会分配默认错误消息。如果 message参数是Error的实例，那么它将被抛出，而不是AssertionError。

assert.notDeepStrictEqual(actual, expected[, message])#

• actual <任意>
• expected <任意>
• message <字符串> | <错误>

测试深度严格的不平等。与assert.deepStrictEqual()相反。

import assert from 'node:assert/strict';

assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// OKconst assert = require('node:assert/strict');

assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// OKcopy

如果这些值深度且严格相等，则会抛出一个AssertionError，其中的 message属性设置等于message参数的值。如果未定义message参数，则会分配默认错误消息。如果message参数是Error的实例，那么它将被抛出，而不是AssertionError。

assert.notEqual(actual, expected[, message])#

• actual <任意>
• expected <任意>
• message <字符串> | <错误>

严格断言模式

assert.notStrictEqual()的别名。

遗留断言模式

使用!=运算符测试浅层强制不等式。如果两边都是NaN ，则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'copy

如果值相等，则会抛出一个AssertionError，其中的message属性设置等于message参数 的值。如果 未定义message参数，则会分配默认错误消息。如果message参数是Error 的实例，那么它将被抛出，而不是 AssertionError。

assert.notStrictEqual(actual, expected[, message])#

• actual <任意>
• expected <任意>
• message <字符串> | <错误>

测试actual和expected参数之间的严格不等式（由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');
// OKconst 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');
// OKcopy

如果这些值严格相等，则会抛出 一个AssertionError，其中的 message属性设置等于message参数的值。如果 未定义message参数，则会分配默认错误消息。如果 message参数是Error的实例，那么它将被抛出，而不是AssertionError。

assert.ok(value[, message])#

• value <任意>
• message <字符串> | <错误>

测试value是否为真。它相当于 assert.equal(!!value, true, message)。

如果value不为真，则会抛出AssertionError ，且message属性设置等于message参数 的值。如果message 参数为undefined，则分配默认错误消息。如果message参数是Error 的实例，那么它将被抛出，而不是 AssertionError。如果根本没有传入任何参数，message将被设置为字符串： 'No value argument passed to `assert.ok()`'。

请注意， repl中的错误消息将与文件中抛出的错误消息不同！请参阅下文了解更多详情。

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

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

assert.rejects(asyncFn[, error][, message])#

• asyncFn <函数> | < Promise >
• error <正则表达式> | <函数> | <对象> | <错误>
• message <字符串>

等待asyncFn Promise，或者如果asyncFn是函数，则立即调用该函数并等待返回的 Promise 完成。然后它会检查 Promise 是否被拒绝。

如果asyncFn是一个函数并且它同步抛出错误，则 assert.rejects()将返回带有该错误的被拒绝的Promise。如果函数不返回 Promise，assert.rejects()将返回被拒绝的 Promise并出现ERR_INVALID_RETURN_VALUE错误。在这两种情况下，都会跳过错误处理程序。

除了等待完成的异步性质之外，其行为与 assert.throws()相同。

如果指定，error可以是Class、RegExp、验证函数、将测试每个属性的对象或每个属性的错误实例将测试属性是否包含不可枚举的message和 name属性。

如果指定，则 当asyncFn拒绝失败时， message 将是AssertionError提供的消息。

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',
    },
  );
})();copy

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;
    },
  );
})();copy

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(() => {
  // ...
});copy

error不能是字符串。如果提供字符串作为第二个参数，则假定省略error，并且该字符串将用于 message。这可能会导致容易被忽略的错误。如果考虑使用字符串作为第二个参数，请仔细阅读assert.throws()中的示例。

assert.strictEqual(actual, expected[, message])#

• actual <任意>
• expected <任意>
• message <字符串> | <错误>

测试actual和expected参数之间的严格相等性（由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 identicalconst 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 identicalcopy

如果这些值不严格相等，则会抛出 一个AssertionError，其中的 message属性设置等于message参数的值。如果 未定义message参数，则会分配默认错误消息。如果 message参数是Error的实例，那么它将被抛出，而不是AssertionError。

assert.throws(fn[, error][, message])#

• fn <函数>
• error <正则表达式> | <函数> | <对象> | <错误>
• message <字符串>

期望函数fn抛出错误。

如果指定，error可以是Class、RegExp、验证函数、验证对象（其中每个属性将被测试严格深度相等）或实例错误，其中每个属性都将测试严格的深度相等性，包括不可枚举的message和name属性。使用对象时，还可以在针对字符串属性进行验证时使用正则表达式。请参阅下面的示例。

如果指定，如果fn调用未能抛出或错误验证失败，则message 将附加到 AssertionError提供的消息中 。

自定义验证对象/错误实例：

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

使用构造函数验证instanceof：

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

使用RegExp验证错误消息：

使用正则表达式在错误对象上运行.toString，因此还将包含错误名称。

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$/,
);copy

自定义错误验证：

该函数必须返回true以指示所有内部验证均已通过。否则它将失败并显示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',
);copy

error不能是字符串。如果提供字符串作为第二个参数，则假定省略error，并且该字符串将用于 message。这可能会导致容易被忽略的错误。使用与抛出的错误消息相同的消息将导致 ERR_AMBIGUOUS_ARGUMENT错误。如果考虑使用字符串作为第二个参数，请仔细阅读下面的示例：

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

由于令人困惑且容易出错的表示法，请避免使用字符串作为第二个参数。