Assert

Assert

Stability: 2 - Stable

The node:assert module provides a set of assertion functions for verifying invariants.

Strict assertion mode

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.

Message parameter semantics

For assertion methods that accept an optional message parameter, the message may be provided in one of the following forms:

string: Used as-is. If additional arguments are supplied after the message string, they are treated as printf-like substitutions (see [util.format()][]).
Error: If an Error instance is provided as message, that error is thrown directly instead of an AssertionError.
function: A function of the form (actual, expected) => string. It is called only when the assertion fails and should return a string to be used as the error message. Non-string return values are ignored and the default message is used instead.

If additional arguments are passed along with an Error or a function as message, the call is rejected with ERR_AMBIGUOUS_ARGUMENT.

If the first item is neither a string, Error, nor function, ERR_INVALID_ARG_TYPE is thrown.

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

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:

[assert.deepEqual()][]
[assert.equal()][]
[assert.notDeepEqual()][]
[assert.notEqual()][]

To use legacy assertion mode:

import assert from 'node:assert';

const assert = require('node:assert');

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

Class: `assert.AssertionError`

Extends: {errors.Error}

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} If provided, the error message is set to this value.
actual {any} The actual property on the error instance.
expected {any} The expected property on the error instance.
operator {string} The operator property on the error instance.
stackStartFn {Function} If provided, the generated stack trace omits frames before this function.
diff {string} If set to 'full', shows the full diff in assertion errors. Defaults to 'simple'. Accepted values: 'simple', 'full'.

A subclass of {Error} that indicates the failure of an assertion.

All instances contain the built-in Error properties (message and name) and:

actual {any} Set to the actual argument for methods such as [assert.strictEqual()][].
expected {any} Set to the expected value for methods such as [assert.strictEqual()][].
generatedMessage {boolean} Indicates if the message was auto-generated (true) or not.
code {string} Value is always ERR_ASSERTION to show that the error is an assertion error.
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);
}

Class: `assert.Assert`

The Assert class allows creating independent assertion instances with custom options.

`new assert.Assert([options])`

options {Object}
diff {string} If set to 'full', shows the full diff in assertion errors. Defaults to 'simple'. Accepted values: 'simple', 'full'.
strict {boolean} If set to true, non-strict methods behave like their corresponding strict methods. Defaults to true.
skipPrototype {boolean} If set to true, skips prototype and constructor comparison in deep equality checks. Defaults to false.

Creates a new assertion instance. The diff option controls the verbosity of diffs in assertion error messages.

const { Assert } = require('node:assert');
const assertInstance = new Assert({ diff: 'full' });
assertInstance.deepStrictEqual({ a: 1 }, { a: 2 });
// Shows a full diff in the error message.

Important: When destructuring assertion methods from an Assert instance, the methods lose their connection to the instance's configuration options (such as diff, strict, and skipPrototype settings). The destructured methods will fall back to default behavior instead.

const myAssert = new Assert({ diff: 'full' });

// This works as expected - uses 'full' diff
myAssert.strictEqual({ a: 1 }, { b: { c: 1 } });

// This loses the 'full' diff setting - falls back to default 'simple' diff
const { strictEqual } = myAssert;
strictEqual({ a: 1 }, { b: { c: 1 } });

The skipPrototype option affects all deep equality methods:

class Foo {
  constructor(a) {
    this.a = a;
  }
}

class Bar {
  constructor(a) {
    this.a = a;
  }
}

const foo = new Foo(1);
const bar = new Bar(1);

// Default behavior - fails due to different constructors
const assert1 = new Assert();
assert1.deepStrictEqual(foo, bar); // AssertionError

// Skip prototype comparison - passes if properties are equal
const assert2 = new Assert({ skipPrototype: true });
assert2.deepStrictEqual(foo, bar); // OK

When destructured, methods lose access to the instance's this context and revert to the default assertion behavior (diff: 'simple', non-strict mode). To maintain custom options when using destructured methods, avoid destructuring and call methods directly on the instance.

`assert(value[, message])`

value {any} The input that is checked for being truthy.
message {string|Error|Function}

An alias of [assert.ok()][].

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

actual {any}
expected {any}
message {string|Error|Function}

Strict assertion mode

An alias of [assert.deepStrictEqual()][].

Legacy assertion mode

Stability: 3 - Legacy: Use [assert.deepStrictEqual()][] instead.

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

Primitive values are compared with the [== operator][], except for {NaN}, which is treated as identical when both sides are {NaN}.
[Type tags][Object.prototype.toString()] of objects should be the same.
Only [enumerable “own” properties][] are considered.
Object constructors are compared when available.
{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 properties are compared unordered.
{Map} keys and {Set} items are compared unordered.
Recursion stops when both sides differ or either side encounters a circular reference.
Implementation does not test the [[[Prototype]]][prototype-spec] of objects.
{Symbol} properties are not compared.
{WeakMap}, {WeakSet} and {Promise} instances are not compared structurally. They are only equal if they reference the same object. Any comparison between different WeakMap, WeakSet, or Promise instances will result in inequality, even if they contain the same content.
{RegExp} lastIndex, flags, and source are always compared, even if these are not enumerable properties.

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 {}

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 {Error} then it will be thrown instead of the [AssertionError][].

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

actual {any}
expected {any}
message {string|Error|Function}

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

Primitive values are compared using [Object.is()][].
[Type tags][Object.prototype.toString()] of objects should be the same.
[[[Prototype]]][prototype-spec] of objects are compared using the [=== operator][].
Only [enumerable “own” properties][] are considered.
Object constructors are compared when available.
{Error} names, messages, causes, and errors are always compared, even if these are not enumerable properties. errors is also compared.
Enumerable own {Symbol} properties are compared as well.
[Object wrappers][] are compared both as objects and unwrapped values.
Object properties are compared unordered.
{Map} keys and {Set} items are compared unordered.
Recursion stops when both sides differ or either side encounters a circular reference.
{WeakMap}, {WeakSet} and {Promise} instances are not compared structurally. They are only equal if they reference the same object. Any comparison between different WeakMap, WeakSet, or Promise instances will result in inequality, even if they contain the same content.
{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 obj = {};

weakMap1.set(obj, 'value');
weakMap2.set(obj, 'value');

// Comparing different instances fails, even with same contents
assert.deepStrictEqual(weakMap1, weakMap2);
// AssertionError: Values have same structure but are not reference-equal:
//
// WeakMap {
//   <items unknown>
// }

// Comparing the same instance to itself succeeds
assert.deepStrictEqual(weakMap1, weakMap1);
// OK

const weakSet1 = new WeakSet();
const weakSet2 = new WeakSet();
weakSet1.add(obj);
weakSet2.add(obj);

// Comparing different instances fails, even with same contents
assert.deepStrictEqual(weakSet1, weakSet2);
// AssertionError: Values have same structure but are not reference-equal:
// + actual - expected
//
// WeakSet {
//   <items unknown>
// }

// Comparing the same instance to itself succeeds
assert.deepStrictEqual(weakSet1, weakSet1);
// OK

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 obj = {};

weakMap1.set(obj, 'value');
weakMap2.set(obj, 'value');

// Comparing different instances fails, even with same contents
assert.deepStrictEqual(weakMap1, weakMap2);
// AssertionError: Values have same structure but are not reference-equal:
//
// WeakMap {
//   <items unknown>
// }

// Comparing the same instance to itself succeeds
assert.deepStrictEqual(weakMap1, weakMap1);
// OK

const weakSet1 = new WeakSet();
const weakSet2 = new WeakSet();
weakSet1.add(obj);
weakSet2.add(obj);

// Comparing different instances fails, even with same contents
assert.deepStrictEqual(weakSet1, weakSet2);
// AssertionError: Values have same structure but are not reference-equal:
// + actual - expected
//
// WeakSet {
//   <items unknown>
// }

// Comparing the same instance to itself succeeds
assert.deepStrictEqual(weakSet1, weakSet1);
// OK

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

string {string}
regexp {RegExp}
message {string|Error|Function}

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

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 {Error} then it will be thrown instead of the [AssertionError][].

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

asyncFn {Function|Promise}
error {RegExp|Function}
message {string}
Returns: {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.

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.

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.

If specified, error can be a [Class][], {RegExp} or a validation function. See [assert.throws()][] for more details.

Aside from asynchronously awaiting completion, it 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}

Asserts that the function fn does not throw an error.

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.

When assert.doesNotThrow() is called, it will immediately call the fn function.

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.

If specified, error can be a [Class][], {RegExp}, or a validation function. See [assert.throws()][] for more details.

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

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

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

actual {any}
expected {any}
message {string|Error|Function}

Strict assertion mode

An alias of [assert.strictEqual()][].

Legacy assertion mode

Stability: 3 - Legacy: Use [assert.strictEqual()][] instead.

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

`assert.fail([message])`

message {string|Error} Default: 'Failed'

Throws an [AssertionError][] with the provided error message or a default error message. If the message parameter is an instance of {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.ifError(value)`

value {any}

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 {string}
regexp {RegExp}
message {string|Error|Function}

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

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 {Error} then it will be thrown instead of the [AssertionError][].

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

actual {any}
expected {any}
message {string|Error|Function}

Strict assertion mode

An alias of [assert.notDeepStrictEqual()][].

Legacy assertion mode

Stability: 3 - Legacy: Use [assert.notDeepStrictEqual()][] instead.

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

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 {Error} then it will be thrown instead of the AssertionError.

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

actual {any}
expected {any}
message {string|Error|Function}

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

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 {Error} then it will be thrown instead of the [AssertionError][].

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

actual {any}
expected {any}
message {string|Error|Function}

Strict assertion mode

An alias of [assert.notStrictEqual()][].

Legacy assertion mode

Stability: 3 - Legacy: Use [assert.notStrictEqual()][] instead.

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'

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 {Error} then it will be thrown instead of the AssertionError.

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

actual {any}
expected {any}
message {string|Error|Function}

Tests strict inequality between th

（本文超出站点单文档体积上限，已截断）

Assert

Assert

Strict assertion mode

Message parameter semantics

Legacy assertion mode

Class: assert.AssertionError

new assert.AssertionError(options)

Class: assert.Assert

new assert.Assert([options])

assert(value[, message])

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

Comparison details

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

Comparison details

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

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

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

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

assert.fail([message])

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

Class: `assert.AssertionError`

`new assert.AssertionError(options)`

Class: `assert.Assert`

`new assert.Assert([options])`

`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.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])`