Assert — Node.js 24 LTS

Утверждения

Исходный код: lib/assert.js

Модуль node:assert предоставляет набор функций проверки утверждений для проверки инвариантов.

Режим строгих утверждений

История

Версия	Изменения
v15.0.0	Экспортирован как `require('node:assert/strict')`.
v13.9.0, v12.16.2	«Строгий режим» переименован в «режим строгих утверждений», а «устаревший режим» — в «режим устаревших утверждений», чтобы избежать путаницы с более распространённым значением термина «строгий режим».
v9.9.0	В режим строгих утверждений добавлены различия между ошибками.
v9.9.0	В модуль assert добавлен режим строгих утверждений.
v9.9.0	Добавлено в: v9.9.0

В режиме строгих утверждений нестрогие методы ведут себя так же, как соответствующие им строгие методы. Например, assert.deepEqual() будет вести себя как assert.deepStrictEqual().

В режиме строгих утверждений сообщения об ошибках для объектов отображают различия. В режиме устаревших утверждений сообщения об ошибках отображают объекты, часто в усечённом виде.

Чтобы использовать режим строгих утверждений:

Модули JavaScript

import { strict as assert } from 'node:assert';

CommonJS

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

Модули JavaScript

import assert from 'node:assert/strict';

CommonJS

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

Пример различий в ошибке:

Модули JavaScript

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

CommonJS

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. Это также отключит цвета в REPL. Подробнее о поддержке цветов в терминальных средах см. в документации tty getColorDepth().

Режим устаревших утверждений

В режиме устаревших утверждений оператор == используется в следующих методах:

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

Чтобы использовать режим устаревших утверждений:

Модули JavaScript

import assert from 'node:assert';

CommonJS

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

Режим устаревших утверждений может приводить к неожиданным результатам, особенно при использовании assert.deepEqual():

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

Класс: `assert.AssertionError`

Наследует: <errors.Error>

Указывает на сбой утверждения. Все ошибки, выбрасываемые модулем node:assert, будут экземплярами класса AssertionError.

`new assert.AssertionError(options)`

Добавлено в: v0.1.21

options <Object>
- message <string> Если указано, сообщение об ошибке устанавливается в это значение.
- actual <any> Свойство actual экземпляра ошибки.
- expected <any> Свойство expected экземпляра ошибки.
- operator <string> Свойство operator экземпляра ошибки.
- stackStartFn <Function> Если указано, в созданную трассировку стека не включаются кадры до этой функции.
- diff <string> Если задано значение 'full', в ошибках утверждений отображаются полные различия. По умолчанию используется 'simple'. Допустимые значения: 'simple', 'full'.

Подкласс <Error>, указывающий на сбой утверждения.

Все экземпляры содержат встроенные свойства Error (message и name), а также:

actual <any> Устанавливается в аргумент actual для таких методов, как assert.strictEqual().
expected <any> Устанавливается в значение expected для таких методов, как assert.strictEqual().
generatedMessage <boolean> Указывает, было ли сообщение сгенерировано автоматически (true).
code <string> Значение всегда равно ERR_ASSERTION, что указывает на то, что ошибка является ошибкой утверждения.
operator <string> Устанавливается в переданное значение оператора.

Модули JavaScript

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

CommonJS

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.Assert`

Добавлено в: v24.6.0

Класс Assert позволяет создавать независимые экземпляры проверки утверждений с пользовательскими параметрами.

`new assert.Assert([options])`

История

Версия	Изменения
v24.9.0	Добавлен параметр `skipPrototype`.

options <Object>
- diff <string> Если задано значение 'full', в ошибках утверждений отображаются полные различия. По умолчанию используется 'simple'. Допустимые значения: 'simple', 'full'.
- strict <boolean> Если задано значение true, нестрогие методы ведут себя так же, как соответствующие им строгие методы. По умолчанию используется true.
- skipPrototype <boolean> Если задано значение true, при проверке глубокого равенства пропускается сравнение прототипов и конструкторов. По умолчанию используется false.

Создаёт новый экземпляр проверки утверждений. Параметр diff определяет подробность различий в сообщениях об ошибках утверждений.

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

Важно: при деструктуризации методов проверки утверждений из экземпляра Assert они теряют связь с параметрами конфигурации экземпляра (например, настройками diff, strict и skipPrototype). Вместо этого деструктурированные методы будут использовать поведение по умолчанию.

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

Параметр skipPrototype влияет на все методы проверки глубокого равенства:

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 copy

После деструктуризации методы теряют доступ к контексту экземпляра this и возвращаются к поведению проверки утверждений по умолчанию (различия: 'simple', нестрогий режим). Чтобы сохранить пользовательские параметры при использовании деструктурированных методов, не выполняйте деструктуризацию и вызывайте методы непосредственно у экземпляра.

Класс: `assert.CallTracker`

История

Версия	Изменения
v20.1.0	Класс `assert.CallTracker` объявлен устаревшим и будет удалён в будущей версии.
v14.2.0, v12.19.0	Добавлено в: v14.2.0, v12.19.0

Стабильность: 0 - Устаревший

Эта функция объявлена устаревшей и будет удалена в будущей версии. Рассмотрите возможность использования альтернатив, таких как вспомогательная функция mock.

`new assert.CallTracker()`

Добавлено в: v14.2.0, v12.19.0

Создаёт новый объект CallTracker, который можно использовать для отслеживания того, вызывались ли функции заданное количество раз. Для выполнения проверки необходимо вызвать tracker.verify(). Обычно его вызывают в обработчике process.on('exit').

Модули JavaScript

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

CommonJS

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

Добавлено в: v14.2.0, v12.19.0

fn <Function> По умолчанию: функция, ничего не выполняющая.
exact <number> По умолчанию: 1.
Возвращает: <Function> Функцию-обёртку для fn.

Предполагается, что функция-обёртка будет вызвана ровно exact раз. Если к моменту вызова tracker.verify() функция не была вызвана ровно exact раз, tracker.verify() выбросит ошибку.

Модули JavaScript

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

CommonJS

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

Добавлено в: v18.8.0, v16.18.0

fn <Function>
Возвращает: <Array> Массив всех вызовов отслеживаемой функции.
Объект <Object>

thisArg <Object>
arguments <Array> аргументы, переданные отслеживаемой функции

Модули JavaScript

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

CommonJS

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

Добавлено в: v14.2.0, v12.19.0

Возвращает: <Array> Массив объектов с информацией о функциях-обёртках, возвращённых методом tracker.calls().
Объект <Object>
- message <string>
- actual <number> Фактическое количество вызовов функции.
- expected <number> Ожидаемое количество вызовов функции.
- operator <string> Имя обёрнутой функции.
- stack <Object> Трассировка стека функции.

Массивы содержат сведения об ожидаемом и фактическом количестве вызовов функций, которые не вызывались ожидаемое число раз.

Модули JavaScript

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

CommonJS

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

Добавлено в: v18.8.0, v16.18.0

fn <Function> отслеживаемая функция для сброса.

Сбрасывает данные о вызовах в трекере вызовов. Если аргументом передана отслеживаемая функция, данные о вызовах будут сброшены для неё. Если аргументы не переданы, будут сброшены данные для всех отслеживаемых функций.

Модули JavaScript

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

CommonJS

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

Добавлено в: v14.2.0, v12.19.0

Перебирает список функций, переданных в tracker.calls(), и выбрасывает ошибку для функций, которые не были вызваны ожидаемое количество раз.

Модули JavaScript

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

CommonJS

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

Добавлено в: v0.5.9

value <any> Входное значение, проверяемое на истинность.
message <string> | <Error>

Псевдоним assert.ok().

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

История

Версия	Изменения
v24.0.0	Рекурсия теперь прекращается, когда на любой из сторон встречается циклическая ссылка.
v22.2.0, v20.15.0	Теперь также сравниваются причина ошибки и свойства errors.
v18.0.0	Теперь также сравнивается свойство lastIndex регулярных выражений.
v16.0.0, v14.18.0	В режиме устаревших утверждений статус изменён с «Устаревший» на «Наследуемый».
v14.0.0	Теперь NaN считается идентичным самому себе, если обе стороны имеют значение NaN.
v12.0.0	Теперь теги типов сравниваются надлежащим образом; также внесены некоторые небольшие изменения в сравнение, чтобы проверка была менее неожиданной.
v9.0.0	Теперь имена и сообщения `Error` сравниваются надлежащим образом.
v8.0.0	Теперь также сравнивается содержимое `Set` и `Map`.
v6.4.0, v4.7.1	Срезы типизированных массивов теперь обрабатываются корректно.
v6.1.0, v4.5.0	Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v5.10.1, v4.4.3	Корректная обработка типизированных массивов, не относящихся к `Uint8Array`.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Режим строгих утверждений

Псевдоним assert.deepStrictEqual().

Режим устаревших утверждений

Стабильность: 3 - Наследуемый: используйте вместо него assert.deepStrictEqual().

Проверяет глубокое равенство параметров actual и expected. Рассмотрите возможность использования вместо него assert.deepStrictEqual(). Результаты работы assert.deepEqual() могут быть неожиданными.

Глубокое равенство означает, что перечисляемые «собственные» свойства дочерних объектов также рекурсивно проверяются по следующим правилам.

Подробности сравнения

Примитивные значения сравниваются с помощью оператора ==, за исключением <NaN>. Он считается идентичным самому себе, если обе стороны имеют значение <NaN>.
Теги типов объектов должны совпадать.
Учитываются только перечисляемые «собственные» свойства.
При наличии сравниваются конструкторы объектов.
Имена, сообщения, причины и ошибки <Error> всегда сравниваются, даже если они не являются перечисляемыми свойствами.
Обёртки объектов сравниваются как объекты и как развёрнутые значения.
Свойства Object сравниваются без учёта порядка.
Ключи <Map> и элементы <Set> сравниваются без учёта порядка.
Рекурсия прекращается, когда стороны различаются или на любой из сторон встречается циклическая ссылка.
Реализация не проверяет [[Prototype]] объектов.
Свойства <Symbol> не сравниваются.
При сравнении <WeakMap> и <WeakSet> учитываются не их значения, а только экземпляры.
Свойства lastIndex, flags и source <RegExp> всегда сравниваются, даже если они не являются перечисляемыми свойствами.

Следующий пример не выбрасывает AssertionError, поскольку примитивы сравниваются с помощью оператора ==.

Модули JavaScript

import assert from 'node:assert';
// WARNING: This does not throw an AssertionError!

assert.deepEqual('+00000000', false);

CommonJS

const assert = require('node:assert');
// WARNING: This does not throw an AssertionError!

assert.deepEqual('+00000000', false);

«Глубокое» равенство означает, что также проверяются перечисляемые «собственные» свойства дочерних объектов:

Модули JavaScript

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

CommonJS

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.

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

История

Версия	Изменения
v24.0.0	Рекурсия теперь прекращается, когда на любой из сторон встречается циклическая ссылка.
v22.2.0, v20.15.0	Теперь также сравниваются причина ошибки и свойства errors.
v18.0.0	Теперь также сравнивается свойство lastIndex регулярных выражений.
v9.0.0	Теперь также сравниваются перечисляемые свойства-символы.
v9.0.0	Теперь `NaN` сравнивается с использованием сравнения SameValueZero.
v8.5.0	Теперь имена и сообщения `Error` сравниваются надлежащим образом.
v8.0.0	Теперь также сравнивается содержимое `Set` и `Map`.
v6.1.0	Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v6.4.0, v4.7.1	Срезы типизированных массивов теперь обрабатываются корректно.
v5.10.1, v4.4.3	Корректная обработка типизированных массивов, не относящихся к `Uint8Array`.
v1.2.0	Добавлено в: v1.2.0

actual <any>
expected <any>
message <string> | <Error>

Проверяет глубокое равенство параметров actual и expected. «Глубокое» равенство означает, что перечисляемые «собственные» свойства дочерних объектов также рекурсивно проверяются по следующим правилам.

Подробности сравнения

Примитивные значения сравниваются с помощью Object.is().
Теги типов объектов должны совпадать.
[[Prototype]] объектов сравниваются с помощью оператора ===.
Учитываются только перечисляемые «собственные» свойства.
Имена, сообщения, причины и ошибки <Error> всегда сравниваются, даже если они не являются перечисляемыми свойствами. Также сравнивается errors.
Также сравниваются перечисляемые собственные свойства <Symbol>.
Обёртки объектов сравниваются как объекты и как развёрнутые значения.
Свойства Object сравниваются без учёта порядка.
Ключи <Map> и элементы <Set> сравниваются без учёта порядка.
Рекурсия прекращается, когда стороны различаются или на любой из сторон встречается циклическая ссылка.
Экземпляры <WeakMap> и <WeakSet> не сравниваются структурно. Они считаются равными, только если ссылаются на один и тот же объект. Любое сравнение разных экземпляров WeakMap или WeakSet приводит к неравенству, даже если они содержат одинаковые записи.
Свойства lastIndex, flags и source <RegExp> всегда сравниваются, даже если они не являются перечисляемыми свойствами.

Модули JavaScript

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

CommonJS

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

История

Версия	Изменения
v16.0.0	Этот API больше не является экспериментальным.
v13.6.0, v12.16.0	Добавлено в: v13.6.0, v12.16.0

string <string>
regexp <RegExp>
message <string> | <Error>

Ожидается, что входные данные string не будут соответствовать регулярному выражению.

Модули JavaScript

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

CommonJS

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.

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

Добавлено в: v10.0.0

asyncFn <Function> | <Promise>
error <RegExp> | <Function>
message <string>
Возвращает: <Promise>

Ожидает выполнения промиса asyncFn или, если asyncFn является функцией, немедленно вызывает эту функцию и ожидает завершения возвращённого промиса. Затем проверяется, что промис не отклонён.

Если asyncFn является функцией и синхронно выбрасывает ошибку, assert.doesNotReject() вернёт отклонённый Promise с этой ошибкой. Если функция не возвращает промис, assert.doesNotReject() вернёт отклонённый Promise с ошибкой ERR_INVALID_RETURN_VALUE. В обоих случаях обработчик ошибок пропускается.

Использовать assert.doesNotReject() на самом деле бесполезно, поскольку мало смысла перехватывать отклонение, а затем снова отклонять промис. Вместо этого рассмотрите возможность добавить комментарий рядом с конкретным путём выполнения кода, который не должен приводить к отклонению, и сделать сообщения об ошибках как можно более информативными.

Если указан, error может быть Class, <RegExp> или функцией проверки. Дополнительные сведения см. в разделе assert.throws().

За исключением асинхронного ожидания завершения, функция ведёт себя так же, как assert.doesNotThrow().

Модули JavaScript

import assert from 'node:assert/strict';

await assert.doesNotReject(
  async () => {
    throw new TypeError('Wrong value');
  },
  SyntaxError,
);

CommonJS

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

(async () => {
  await assert.doesNotReject(
    async () => {
      throw new TypeError('Wrong value');
    },
    SyntaxError,
  );
})();

Модули JavaScript

import assert from 'node:assert/strict';

assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
  .then(() => {
    // ...
  });

CommonJS

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

assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
  .then(() => {
    // ...
  });

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

История

Версия	Изменения
v5.11.0, v4.4.5	Теперь учитывается параметр `message`.
v4.2.0	Теперь параметр `error` может быть стрелочной функцией.
v0.1.21	Добавлено в: v0.1.21

fn <Function>
error <RegExp> | <Function>
message <string>

Проверяет, что функция fn не выбрасывает ошибку.

Использовать assert.doesNotThrow() на самом деле бесполезно, поскольку нет смысла перехватывать ошибку, а затем выбрасывать её снова. Вместо этого рассмотрите возможность добавить комментарий рядом с конкретным путём выполнения кода, который не должен приводить к выбросу ошибки, и сделать сообщения об ошибках как можно более информативными.

При вызове assert.doesNotThrow() немедленно вызывает функцию fn.

Если выброшенная ошибка имеет тот же тип, что и указанный параметром error, выбрасывается AssertionError. Если ошибка имеет другой тип или параметр error не определён, ошибка передаётся вызывающему коду.

Если указан, error может быть Class, <RegExp> или функцией проверки. Дополнительные сведения см. в разделе assert.throws().

Например, следующий код выбросит <TypeError>, поскольку в утверждении нет соответствующего типа ошибки:

Модули JavaScript

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  SyntaxError,
);

CommonJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  SyntaxError,
);

Однако следующий код приведёт к выбросу AssertionError с сообщением «Получено нежелательное исключение...»:

Модули JavaScript

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  TypeError,
);

CommonJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  TypeError,
);

Если выбрасывается AssertionError и для параметра message задано значение, значение message будет добавлено к сообщению AssertionError:

Модули JavaScript

import assert from 'node:assert/strict';

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

CommonJS

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

История

Версия	Изменения
v16.0.0, v14.18.0	В режиме устаревших утверждений статус изменён с «Устаревший» на «Устаревший режим».
v14.0.0	Теперь NaN считается идентичным, если с обеих сторон находится NaN.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Режим строгих утверждений

Псевдоним assert.strictEqual().

Режим устаревших утверждений

Стабильность: 3 — Устаревший режим: вместо него используйте assert.strictEqual().

Проверяет поверхностное равенство с приведением типов между параметрами actual и expected с помощью оператора ==. NaN обрабатывается особым образом и считается идентичным, если с обеих сторон находится NaN.

Модули JavaScript

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

CommonJS

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.

`assert.fail([message])`

Добавлено в: v0.1.21

message <string> | <Error> По умолчанию: 'Failed'

Выбрасывает AssertionError с указанным сообщением об ошибке или сообщением по умолчанию. Если параметр message является экземпляром <Error>, он будет выброшен вместо AssertionError.

Модули JavaScript

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

CommonJS

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() с более чем двумя аргументами возможно, но объявлено устаревшим. Дополнительные сведения см. ниже.

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

История

Версия	Изменения
v10.0.0	Вызов `assert.fail()` более чем с одним аргументом объявлен устаревшим и вызывает предупреждение.
v0.1.21	Добавлено в: v0.1.21

Стабильность: 0 — Устарело: вместо этого используйте assert.fail([message]) или другие функции assert.

actual <any>
expected <any>
message <string> | <Error>
operator <string> По умолчанию: '!='
stackStartFn <Function> По умолчанию: assert.fail

Если message имеет ложное значение, сообщение об ошибке формируется из значений actual и expected, разделённых указанным operator. Если переданы только два аргумента actual и expected, для operator по умолчанию используется '!='. Если message передан в качестве третьего аргумента, он будет использован как сообщение об ошибке, а остальные аргументы будут сохранены в виде свойств выброшенного объекта. Если указан stackStartFn, все кадры стека выше этой функции будут удалены из трассировки стека (см. Error.captureStackTrace). Если аргументы не переданы, будет использовано сообщение по умолчанию Failed.

Модули JavaScript

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

CommonJS

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 не влияют на сообщение об ошибке.

Пример использования stackStartFn для усечения трассировки стека исключения:

Модули JavaScript

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

CommonJS

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

История

Версия	Изменения
v10.0.0	Теперь вместо исходной ошибки выбрасывается обёрнутая ошибка [`AssertionError`][], содержащая полную трассировку стека.
v10.0.0	Теперь значением может быть только `undefined` или `null`. Ранее все ложные значения обрабатывались так же, как `null`, и не приводили к выбросу ошибки.
v0.1.97	Добавлено в: v0.1.97

value <any>

Выбрасывает value, если value не является undefined или null. Это полезно для проверки аргумента error в функциях обратного вызова. Трассировка стека содержит все кадры из ошибки, переданной в ifError(), включая возможные новые кадры самой функции ifError().

Модули JavaScript

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

CommonJS

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

История

Версия	Изменения
v16.0.0	Этот API больше не является экспериментальным.
v13.6.0, v12.16.0	Добавлено в: v13.6.0, v12.16.0

string <string>
regexp <RegExp>
message <string> | <Error>

Ожидается, что входные данные string будут соответствовать регулярному выражению.

Модули JavaScript

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

CommonJS

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.

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

История

Версия	Изменения
v16.0.0, v14.18.0	В режиме устаревших утверждений статус изменён с «Устаревший» на «Устаревший режим».
v14.0.0	Теперь NaN считается идентичным, если с обеих сторон находится NaN.
v9.0.0	Теперь имена и сообщения `Error` сравниваются корректно.
v8.0.0	Теперь также сравнивается содержимое `Set` и `Map`.
v6.4.0, v4.7.1	Теперь срезы типизированных массивов обрабатываются корректно.
v6.1.0, v4.5.0	Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v5.10.1, v4.4.3	Корректная обработка типизированных массивов, не являющихся `Uint8Array`.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Режим строгих утверждений

Псевдоним assert.notDeepStrictEqual().

Режим устаревших утверждений

Стабильность: 3 — Устаревший режим: вместо него используйте assert.notDeepStrictEqual().

Проверяет наличие любого глубокого неравенства. Противоположность assert.deepEqual().

Модули JavaScript

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

CommonJS

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.

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

История

Версия	Изменения
v9.0.0	`-0` и `+0` больше не считаются равными.
v9.0.0	Теперь `NaN` сравнивается с использованием сравнения SameValueZero.
v9.0.0	Теперь имена и сообщения `Error` сравниваются корректно.
v8.0.0	Теперь также сравнивается содержимое `Set` и `Map`.
v6.1.0	Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v6.4.0, v4.7.1	Теперь срезы типизированных массивов обрабатываются корректно.
v5.10.1, v4.4.3	Корректная обработка типизированных массивов, не являющихся `Uint8Array`.
v1.2.0	Добавлено в: v1.2.0

actual <any>
expected <any>
message <string> | <Error>

Проверяет глубокое строгое неравенство. Противоположность assert.deepStrictEqual().

Модули JavaScript

import assert from 'node:assert/strict';

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

CommonJS

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

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

Если значения глубоко и строго равны, выбрасывается AssertionError со свойством message, равным значению параметра message. Если параметр message не определён, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром <Error>, он будет выброшен вместо AssertionError.

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

История

Версия	Изменения
v16.0.0, v14.18.0	В режиме устаревших утверждений статус изменён с «Устаревший» на «Устаревший режим».
v14.0.0	Теперь NaN считается идентичным, если с обеих сторон находится NaN.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Режим строгих утверждений

Псевдоним assert.notStrictEqual().

Режим устаревших утверждений

Стабильность: 3 — Устаревший режим: вместо него используйте assert.notStrictEqual().

Проверяет поверхностное неравенство с приведением типов с помощью оператора !=. NaN обрабатывается особым образом и считается идентичным, если с обеих сторон находится NaN.

Модули JavaScript

import assert from 'node:assert';

assert.notEqual(1, 2);
// OK

assert.notEqual(1, 1);
// AssertionError: 1 != 1

assert.notEqual(1, '1');
// AssertionError: 1 != '1'

CommonJS

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.

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

История

Версия	Изменения
v10.0.0	Используемое сравнение изменено со строгого равенства на `Object.is()`.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Проверяет строгое неравенство параметров actual и expected, определяемое функцией Object.is().

Модули JavaScript

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

CommonJS

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.

`assert.ok(value[, message])`

История

Версия	Изменения
v10.0.0	Теперь `assert.ok()` (без аргументов) будет использовать предопределенное сообщение об ошибке.
v0.1.21	Добавлено в: v0.1.21

value <any>
message <string> | <Error>

Проверяет, имеет ли 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) copy

CommonJS

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)

Модули JavaScript

import assert from 'node:assert/strict';

// Using `assert()` works the same:
assert(2 + 2 > 5);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(2 + 2 > 5)

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

// Using `assert()` works the same:
assert(2 + 2 > 5);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(2 + 2 > 5) copy

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

Добавлено в: v10.0.0

asyncFn <Function> | <Promise>
error <RegExp> | <Function> | <Object> | <Error>
message <string>
Возвращает: <Promise>

Ожидает выполнения промиса asyncFn или, если asyncFn является функцией, немедленно вызывает функцию и ожидает завершения возвращенного промиса. Затем проверяется, что промис был отклонен.

Если asyncFn является функцией и она синхронно выбрасывает ошибку, assert.rejects() вернет отклоненный Promise с этой ошибкой. Если функция не возвращает промис, assert.rejects() вернет отклоненный Promise с ошибкой ERR_INVALID_RETURN_VALUE. В обоих случаях обработчик ошибок пропускается.

За исключением асинхронного ожидания завершения, поведение идентично assert.throws().

Если указан, error может быть Class, <RegExp>, функцией проверки, объектом, для которого будет проверено каждое свойство, или экземпляром ошибки, для которого будут проверены все свойства, включая неперечисляемые свойства message и name.

Если указан, message будет сообщением, предоставленным AssertionError, если asyncFn не будет отклонен.

Модули JavaScript

import assert from 'node:assert/strict';

await assert.rejects(
  async () => {
    throw new TypeError('Wrong value');
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
  },
);

CommonJS

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

(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Wrong value');
    },
    {
      name: 'TypeError',
      message: 'Wrong value',
    },
  );
})();

Модули JavaScript

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

CommonJS

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

Модули JavaScript

import assert from 'node:assert/strict';

assert.rejects(
  Promise.reject(new Error('Wrong value')),
  Error,
).then(() => {
  // ...
});

CommonJS

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

assert.rejects(
  Promise.reject(new Error('Wrong value')),
  Error,
).then(() => {
  // ...
});

error не может быть строкой. Если в качестве второго аргумента передана строка, считается, что error не указан, а строка будет использована вместо message. Это может привести к ошибкам, которые легко не заметить. Если вы рассматриваете возможность использования строки в качестве второго аргумента, внимательно прочитайте пример в assert.throws().

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

История

Версия	Изменения
v10.0.0	Используемый способ сравнения изменен со строгого равенства на `Object.is()`.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Проверяет строгое равенство параметров actual и expected, определяемое с помощью Object.is().

Модули JavaScript

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

CommonJS

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.

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

История

Версия	Изменения
v10.2.0	Теперь параметр `error` может быть объектом, содержащим регулярные выражения.
v9.9.0	Теперь параметр `error` также может быть объектом.
v4.2.0	Теперь параметр `error` может быть стрелочной функцией.
v0.1.21	Добавлено в: v0.1.21

fn <Function>
error <RegExp> | <Function> | <Object> | <Error>
message <string>

Ожидает, что функция fn выбросит ошибку.

Если указан, error может быть Class, <RegExp>, функцией проверки, объектом проверки, каждое свойство которого будет проверено на строгое глубокое равенство, или экземпляром ошибки, каждое свойство которого будет проверено на строгое глубокое равенство, включая неперечисляемые свойства message и name. При использовании объекта можно также использовать регулярное выражение для проверки строкового свойства. Примеры см. ниже.

Если указан, message будет добавлено к сообщению, предоставленному AssertionError, если вызов fn не выбросит ошибку или проверка ошибки завершится неудачно.

Пользовательский объект проверки/экземпляр ошибки:

Модули JavaScript

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

CommonJS

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 с помощью конструктора:

Модули JavaScript

import assert from 'node:assert/strict';

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  Error,
);

CommonJS

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

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  Error,
);

Проверка сообщения об ошибке с помощью <RegExp>:

Использование регулярного выражения выполняет .toString над объектом ошибки, поэтому также учитывается имя ошибки.

Модули JavaScript

import assert from 'node:assert/strict';

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  /^Error: Wrong value$/,
);

CommonJS

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

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  /^Error: Wrong value$/,
);

Пользовательская проверка ошибки:

Функция должна вернуть true, чтобы указать, что все внутренние проверки пройдены. В противном случае проверка завершится ошибкой AssertionError.

Модули JavaScript

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

CommonJS

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. Если вы рассматриваете возможность использования строки в качестве второго аргумента, внимательно прочитайте пример ниже:

Модули JavaScript

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]

CommonJS

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]

Из-за запутанного синтаксиса, склонного к ошибкам, не используйте строку в качестве второго аргумента.

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

История

Версия	Изменения
v24.0.0	partialDeepStrictEqual теперь имеет статус стабильного API. Ранее он был экспериментальным.
v23.4.0, v22.13.0	Добавлено в: v23.4.0, v22.13.0

actual <any>
expected <any>
message <string> | <Error>

Проверяет частичное глубокое равенство параметров actual и expected. «Глубокое» равенство означает, что перечисляемые собственные свойства дочерних объектов также рекурсивно проверяются в соответствии со следующими правилами. «Частичное» равенство означает, что сравниваются только свойства, существующие у параметра expected.

Этот метод всегда проходит те же тестовые случаи, что и assert.deepStrictEqual(), и является его надмножеством.

Подробности сравнения

Примитивные значения сравниваются с помощью Object.is().
Теги типов объектов должны совпадать.
[[Prototype]] объектов не сравниваются.
Учитываются только перечисляемые собственные свойства.
Имена, сообщения, причины и ошибки <Error> сравниваются всегда, даже если они не являются перечисляемыми свойствами. Также сравнивается errors.
Перечисляемые собственные свойства <Symbol> также сравниваются.
Обертки объектов сравниваются и как объекты, и как развернутые значения.
Свойства Object сравниваются без учета порядка.
Ключи <Map> и элементы <Set> сравниваются без учета порядка.
Рекурсия останавливается, когда обе стороны различаются или обе стороны обнаруживают циклическую ссылку.
Экземпляры <WeakMap> и <WeakSet> не сравниваются структурно. Они равны, только если ссылаются на один и тот же объект. Любое сравнение разных экземпляров WeakMap или WeakSet даст неравенство, даже если они содержат одинаковые элементы.
Свойства lastIndex, flags и source у <RegExp> всегда сравниваются, даже если они не являются перечисляемыми свойствами.
Пропуски в разреженных массивах игнорируются.

Модули JavaScript

import assert from 'node:assert';

assert.partialDeepStrictEqual(
  { a: { b: { c: 1 } } },
  { a: { b: { c: 1 } } },
);
// OK

assert.partialDeepStrictEqual(
  { a: 1, b: 2, c: 3 },
  { b: 2 },
);
// OK

assert.partialDeepStrictEqual(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  [4, 5, 8],
);
// OK

assert.partialDeepStrictEqual(
  new Set([{ a: 1 }, { b: 1 }]),
  new Set([{ a: 1 }]),
);
// OK

assert.partialDeepStrictEqual(
  new Map([['key1', 'value1'], ['key2', 'value2']]),
  new Map([['key2', 'value2']]),
);
// OK

assert.partialDeepStrictEqual(123n, 123n);
// OK

assert.partialDeepStrictEqual(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  [5, 4, 8],
);
// AssertionError

assert.partialDeepStrictEqual(
  { a: 1 },
  { a: 1, b: 2 },
);
// AssertionError

assert.partialDeepStrictEqual(
  { a: { b: 2 } },
  { a: { b: '2' } },
);
// AssertionError

CommonJS

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

assert.partialDeepStrictEqual(
  { a: { b: { c: 1 } } },
  { a: { b: { c: 1 } } },
);
// OK

assert.partialDeepStrictEqual(
  { a: 1, b: 2, c: 3 },
  { b: 2 },
);
// OK

assert.partialDeepStrictEqual(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  [4, 5, 8],
);
// OK

assert.partialDeepStrictEqual(
  new Set([{ a: 1 }, { b: 1 }]),
  new Set([{ a: 1 }]),
);
// OK

assert.partialDeepStrictEqual(
  new Map([['key1', 'value1'], ['key2', 'value2']]),
  new Map([['key2', 'value2']]),
);
// OK

assert.partialDeepStrictEqual(123n, 123n);
// OK

assert.partialDeepStrictEqual(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  [5, 4, 8],
);
// AssertionError

assert.partialDeepStrictEqual(
  { a: 1 },
  { a: 1, b: 2 },
);
// AssertionError

assert.partialDeepStrictEqual(
  { a: { b: 2 } },
  { a: { b: '2' } },
);
// AssertionError

© Joyent, Inc. and other Node contributors
Licensed under the MIT License.
Node.js is a trademark of Joyent, Inc. and is used with its permission.
We are not endorsed by or affiliated with Joyent.
https://nodejs.org/dist/latest-v24.x/docs/api/assert.html

Утверждения

Режим строгих утверждений

Режим устаревших утверждений

Класс: assert.AssertionError

new assert.AssertionError(options)

Класс: assert.Assert

new assert.Assert([options])

Класс: assert.CallTracker

new assert.CallTracker()

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

tracker.getCalls(fn)

tracker.report()

tracker.reset([fn])

tracker.verify()

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.partialDeepStrictEqual(actual, expected[, message])

Подробности сравнения

Класс: `assert.AssertionError`

`new assert.AssertionError(options)`

Класс: `assert.Assert`

`new assert.Assert([options])`

Класс: `assert.CallTracker`

`new assert.CallTracker()`

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

`tracker.getCalls(fn)`

`tracker.report()`

`tracker.reset([fn])`

`tracker.verify()`

`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.partialDeepStrictEqual(actual, expected[, message])`