Node.js v26.0.0 Dokumentation

Assert#

Das Modul node:assert stellt eine Reihe von Assert-Funktionen zur Überprüfung von Invarianten bereit.

Strikter Assert-Modus#

Im strikten Assert-Modus verhalten sich nicht-strikte Methoden wie ihre entsprechenden strikten Methoden. Beispielsweise verhält sich assert.deepEqual() wie assert.deepStrictEqual().

Im strikten Assert-Modus zeigen Fehlermeldungen für Objekte einen Diff (Unterschied) an. Im Legacy-Assert-Modus zeigen Fehlermeldungen für Objekte die Objekte an, oft abgeschnitten.

Semantik des Message-Parameters#

Für Assert-Methoden, die einen optionalen message-Parameter akzeptieren, kann die Nachricht in einer der folgenden Formen angegeben werden:

• string: Wird unverändert verwendet. Wenn zusätzliche Argumente nach der message-Zeichenkette übergeben werden, werden sie als printf-ähnliche Ersetzungen behandelt (siehe util.format()).
• Error: Wenn eine Error-Instanz als message übergeben wird, wird dieser Fehler direkt anstelle eines AssertionError geworfen.
• function: Eine Funktion der Form (actual, expected) => string. Sie wird nur aufgerufen, wenn die Zusicherung fehlschlägt, und sollte eine Zeichenkette zurückgeben, die als Fehlermeldung verwendet wird. Rückgabewerte, die keine Zeichenketten sind, werden ignoriert, und es wird stattdessen die Standardmeldung verwendet.

Wenn zusätzliche Argumente zusammen mit einem Error oder einer Funktion als message übergeben werden, wird der Aufruf mit ERR_AMBIGUOUS_ARGUMENT abgelehnt.

Wenn das erste Element weder eine Zeichenkette, ein Error noch eine Funktion ist, wird ERR_INVALID_ARG_TYPE geworfen.

Um den strikten Assert-Modus zu verwenden

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

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

Beispiel für einen Fehler-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
//   ]
copy

Um die Farben zu deaktivieren, verwenden Sie die Umgebungsvariablen NO_COLOR oder NODE_DISABLE_COLORS. Dadurch werden auch die Farben in der REPL deaktiviert. Weitere Informationen zur Farbunterstützung in Terminal-Umgebungen finden Sie in der Dokumentation für tty getColorDepth().

Legacy-Assert-Modus#

Der Legacy-Assert-Modus verwendet den ==-Operator in

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

Um den Legacy-Assert-Modus zu verwenden

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

Der Legacy-Assert-Modus kann zu überraschenden Ergebnissen führen, insbesondere bei Verwendung von assert.deepEqual()

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

Klasse: assert.AssertionError#

• Erweitert: <errors.Error>

Weist auf das Fehlschlagen einer Zusicherung hin. Alle vom Modul node:assert geworfenen Fehler sind Instanzen der Klasse AssertionError.

new assert.AssertionError(options)#

• options <Object>
  • message <string> Falls angegeben, wird die Fehlermeldung auf diesen Wert gesetzt.
  • actual <any> Die Eigenschaft actual der Fehlerinstanz.
  • expected <any> Die Eigenschaft expected der Fehlerinstanz.
  • operator <string> Die Eigenschaft operator der Fehlerinstanz.
  • stackStartFn <Function> Falls angegeben, lässt der generierte Stacktrace Frames vor dieser Funktion aus.
  • diff <string> Wenn auf 'full' gesetzt, wird der vollständige Diff bei Assert-Fehlern angezeigt. Standardwert ist 'simple'. Akzeptierte Werte: 'simple', 'full'.

Eine Unterklasse von <Error>, die das Fehlschlagen einer Zusicherung anzeigt.

Alle Instanzen enthalten die integrierten Error-Eigenschaften (message und name) sowie:

• actual <any> Auf das Argument actual gesetzt für Methoden wie assert.strictEqual().
• expected <any> Auf den Wert expected gesetzt für Methoden wie assert.strictEqual().
• generatedMessage <boolean> Gibt an, ob die Nachricht automatisch generiert wurde (true) oder nicht.
• code <string> Der Wert ist immer ERR_ASSERTION, um anzuzeigen, dass es sich um einen Assert-Fehler handelt.
• operator <string> Auf den übergebenen Operatorwert gesetzt.

import assert from 'node:assert';

// Generate an AssertionError to compare the error message later:
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
});

// Verify error output:
try {
  assert.strictEqual(1, 2);
} catch (err) {
  assert(err instanceof assert.AssertionError);
  assert.strictEqual(err.message, message);
  assert.strictEqual(err.name, 'AssertionError');
  assert.strictEqual(err.actual, 1);
  assert.strictEqual(err.expected, 2);
  assert.strictEqual(err.code, 'ERR_ASSERTION');
  assert.strictEqual(err.operator, 'strictEqual');
  assert.strictEqual(err.generatedMessage, true);
}
const assert = require('node:assert');

// Generate an AssertionError to compare the error message later:
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
});

// Verify error output:
try {
  assert.strictEqual(1, 2);
} catch (err) {
  assert(err instanceof assert.AssertionError);
  assert.strictEqual(err.message, message);
  assert.strictEqual(err.name, 'AssertionError');
  assert.strictEqual(err.actual, 1);
  assert.strictEqual(err.expected, 2);
  assert.strictEqual(err.code, 'ERR_ASSERTION');
  assert.strictEqual(err.operator, 'strictEqual');
  assert.strictEqual(err.generatedMessage, true);
}
copy

Klasse: assert.Assert#

Die Klasse Assert ermöglicht das Erstellen unabhängiger Assert-Instanzen mit benutzerdefinierten Optionen.

new assert.Assert([options])#

• options <Object>
  • diff <string> Wenn auf 'full' gesetzt, wird der vollständige Diff bei Assert-Fehlern angezeigt. Standardwert ist 'simple'. Akzeptierte Werte: 'simple', 'full'.
  • strict <boolean> Wenn auf true gesetzt, verhalten sich nicht-strikte Methoden wie ihre entsprechenden strikten Methoden. Standardwert ist true.
  • skipPrototype <boolean> Wenn auf true gesetzt, wird der Vergleich von Prototyp und Konstruktor bei tiefen Gleichheitsprüfungen übersprungen. Standardwert ist false.

Erstellt eine neue Assert-Instanz. Die Option diff steuert die Ausführlichkeit von Diffs in Assert-Fehlermeldungen.

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

Wichtig: Beim Destrukturieren von Assert-Methoden aus einer Assert-Instanz verlieren die Methoden ihre Verbindung zu den Konfigurationsoptionen der Instanz (wie den Einstellungen für diff, strict und skipPrototype). Die destrukturierten Methoden fallen stattdessen auf das Standardverhalten zurück.

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

Die Option skipPrototype betrifft alle Methoden zur tiefen Gleichheitsprüfung

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

Beim Destrukturieren verlieren die Methoden den Zugriff auf den this-Kontext der Instanz und kehren zum Standard-Assert-Verhalten zurück (Diff: 'simple', nicht-strikter Modus). Um benutzerdefinierte Optionen beizubehalten, wenn Sie destrukturierte Methoden verwenden, vermeiden Sie die Destrukturierung und rufen Sie Methoden direkt auf der Instanz auf.

assert(value[, message])#

• value <any> Die Eingabe, die auf einen wahrheitsgemäßen Wert (truthy) geprüft wird.
• message <string> | <Error> | <Function>

Ein Alias für assert.ok().

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

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

Strikter Assert-Modus

Ein Alias für assert.deepStrictEqual().

Legacy-Assert-Modus

Prüft auf tiefe Gleichheit zwischen den Parametern actual und expected. Erwägen Sie stattdessen die Verwendung von assert.deepStrictEqual(). assert.deepEqual() kann zu überraschenden Ergebnissen führen.

Tiefe Gleichheit bedeutet, dass die aufzählbaren „eigenen“ Eigenschaften von Kindobjekten ebenfalls rekursiv nach folgenden Regeln ausgewertet werden.

Details zum Vergleich#

• Primitive Werte werden mit dem ==-Operator verglichen, mit Ausnahme von <NaN>. Dieses wird als identisch behandelt, falls beide Seiten <NaN> sind.
• Die Typ-Tags von Objekten sollten übereinstimmen.
• Es werden nur aufzählbare „eigene“ Eigenschaften berücksichtigt.
• Objekt-Konstruktoren werden verglichen, sofern vorhanden.
• Die Namen, Meldungen, Ursachen (causes) und Fehler (errors) von <Error>-Objekten werden immer verglichen, selbst wenn dies keine aufzählbaren Eigenschaften sind.
• Objekt-Wrapper werden sowohl als Objekte als auch als ausgepackte Werte verglichen.
• Eigenschaften von Objects werden ungeordnet verglichen.
• Schlüssel von <Map> und Elemente von <Set> werden ungeordnet verglichen.
• Die Rekursion stoppt, wenn sich beide Seiten unterscheiden oder eine der beiden Seiten auf eine zirkuläre Referenz stößt.
• Die Implementierung prüft nicht den [[Prototype]] von Objekten.
• Eigenschaften vom Typ <Symbol> werden nicht verglichen.
• Instanzen von <WeakMap>, <WeakSet> und <Promise> werden nicht strukturell verglichen. Sie sind nur gleich, wenn sie dasselbe Objekt referenzieren. Jeder Vergleich zwischen verschiedenen WeakMap-, WeakSet- oder Promise-Instanzen führt zu Ungleichheit, selbst wenn sie denselben Inhalt haben.
• Die Eigenschaften „lastIndex“, „flags“ und „source“ von <RegExp> werden immer verglichen, selbst wenn dies keine aufzählbaren Eigenschaften sind.

Das folgende Beispiel wirft keinen AssertionError, da die primitiven Werte mit dem ==-Operator verglichen werden.

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

assert.deepEqual('+00000000', false);
const assert = require('node:assert');
// WARNING: This does not throw an AssertionError!

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

„Tiefe“ Gleichheit bedeutet, dass die aufzählbaren „eigenen“ Eigenschaften von Kindobjekten ebenfalls ausgewertet werden

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

Wenn die Werte nicht gleich sind, wird ein AssertionError geworfen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message nicht definiert ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

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

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

Prüft auf tiefe Gleichheit zwischen den Parametern actual und expected. „Tiefe“ Gleichheit bedeutet, dass die aufzählbaren „eigenen“ Eigenschaften von Kindobjekten ebenfalls rekursiv nach folgenden Regeln ausgewertet werden.

Details zum Vergleich#

• Primitive Werte werden mittels Object.is() verglichen.
• Die Typ-Tags von Objekten sollten übereinstimmen.
• Der [[Prototype]] von Objekten wird mittels ===-Operator verglichen.
• Es werden nur aufzählbare „eigene“ Eigenschaften berücksichtigt.
• Die Namen, Meldungen, Ursachen (causes) und Fehler (errors) von <Error>-Objekten werden immer verglichen, selbst wenn dies keine aufzählbaren Eigenschaften sind. errors wird ebenfalls verglichen.
• Aufzählbare eigene <Symbol>-Eigenschaften werden ebenfalls verglichen.
• Objekt-Wrapper werden sowohl als Objekte als auch als ausgepackte Werte verglichen.
• Eigenschaften von Objects werden ungeordnet verglichen.
• Schlüssel von <Map> und Elemente von <Set> werden ungeordnet verglichen.
• Die Rekursion stoppt, wenn sich beide Seiten unterscheiden oder eine der beiden Seiten auf eine zirkuläre Referenz stößt.
• Instanzen von <WeakMap>, <WeakSet> und <Promise> werden nicht strukturell verglichen. Sie sind nur gleich, wenn sie dasselbe Objekt referenzieren. Jeder Vergleich zwischen verschiedenen WeakMap-, WeakSet- oder Promise-Instanzen führt zu Ungleichheit, selbst wenn sie denselben Inhalt haben.
• Die Eigenschaften „lastIndex“, „flags“ und „source“ von <RegExp> werden immer verglichen, selbst wenn dies keine aufzählbaren Eigenschaften sind.

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
copy

Wenn die Werte nicht gleich sind, wird ein AssertionError geworfen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message nicht definiert ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

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

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

Erwartet, dass die string-Eingabe nicht mit dem regulären Ausdruck übereinstimmt.

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
copy

Wenn die Werte übereinstimmen oder das Argument string von einem anderen Typ als string ist, wird ein AssertionError geworwen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message nicht definiert ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

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

• asyncFn <Function> | <Promise>
• error <RegExp> | <Function>
• message <string>
• Rückgabewert: <Promise>

Wartet auf das Promise asyncFn oder ruft, wenn asyncFn eine Funktion ist, die Funktion sofort auf und wartet auf die Fertigstellung des zurückgegebenen Promises. Anschließend wird geprüft, dass das Promise nicht abgelehnt (rejected) wird.

Wenn asyncFn eine Funktion ist und diese synchron einen Fehler wirft, gibt assert.doesNotReject() ein abgelehntes Promise mit diesem Fehler zurück. Wenn die Funktion kein Promise zurückgibt, gibt assert.doesNotReject() ein abgelehntes Promise mit einem ERR_INVALID_RETURN_VALUE-Fehler zurück. In beiden Fällen wird der Error-Handler übersprungen.

Die Verwendung von assert.doesNotReject() ist eigentlich nicht sinnvoll, da es kaum Vorteile bringt, eine Rejection abzufangen und sie dann erneut abzulehnen. Erwägen Sie stattdessen, einen Kommentar neben dem spezifischen Codepfad hinzuzufügen, der nicht ablehnen soll, und halten Sie Fehlermeldungen so aussagekräftig wie möglich.

Falls angegeben, kann error eine Class, ein <RegExp> oder eine Validierungsfunktion sein. Siehe assert.throws() für weitere Details.

Abgesehen von der asynchronen Natur des Wartens auf die Fertigstellung verhält es sich identisch zu assert.doesNotThrow().

import assert from 'node:assert/strict';

await assert.doesNotReject(
  async () => {
    throw new TypeError('Wrong value');
  },
  SyntaxError,
);
const assert = require('node:assert/strict');

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

import assert from 'node:assert/strict';

assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
  .then(() => {
    // ...
  });
const assert = require('node:assert/strict');

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

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

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

Sichert zu, dass die Funktion fn keinen Fehler wirft.

Die Verwendung von assert.doesNotThrow() ist eigentlich nicht sinnvoll, da es keinen Vorteil bringt, einen Fehler abzufangen und ihn dann erneut zu werfen. Erwägen Sie stattdessen, einen Kommentar neben dem spezifischen Codepfad hinzuzufügen, der keinen Fehler werfen soll, und halten Sie Fehlermeldungen so aussagekräftig wie möglich.

Wenn assert.doesNotThrow() aufgerufen wird, ruft es die Funktion fn sofort auf.

Wenn ein Fehler geworfen wird und dieser vom gleichen Typ ist wie der durch den Parameter error angegebene, wird ein AssertionError geworfen. Wenn der Fehler von einem anderen Typ ist oder der Parameter error nicht definiert ist, wird der Fehler an den Aufrufer zurückgegeben.

Falls angegeben, kann error eine Class, ein <RegExp> oder eine Validierungsfunktion sein. Siehe assert.throws() für weitere Details.

Das Folgende wird beispielsweise den <TypeError> werfen, da in der Zusicherung kein passender Fehlertyp vorhanden ist:

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  SyntaxError,
);
const assert = require('node:assert/strict');

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

Das Folgende führt jedoch zu einem AssertionError mit der Meldung '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,
);
copy

Wenn ein AssertionError geworfen wird und ein Wert für den Parameter message angegeben ist, wird der Wert von message an die AssertionError-Meldung angehängt.

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
copy

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

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

Strikter Assert-Modus

Ein Alias für assert.strictEqual().

Legacy-Assert-Modus

Prüft auf flache, konvertierende Gleichheit zwischen den Parametern actual und expected unter Verwendung des ==-Operators. NaN wird speziell behandelt und als identisch betrachtet, wenn beide Seiten NaN sind.

import assert from 'node:assert';

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 1 == '1'
assert.equal(NaN, NaN);
// OK

assert.equal(1, 2);
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
const assert = require('node:assert');

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 1 == '1'
assert.equal(NaN, NaN);
// OK

assert.equal(1, 2);
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
copy

Wenn die Werte nicht gleich sind, wird ein AssertionError geworfen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message nicht definiert ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

assert.fail([message])#

• message <string> | <Error> Standardwert: 'Failed'

Wirft einen AssertionError mit der bereitgestellten Fehlermeldung oder einer Standard-Fehlermeldung. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

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
copy

assert.ifError(value)#

• value <any>

Wirft value, wenn value weder undefined noch null ist. Dies ist nützlich beim Testen des error-Arguments in Callbacks. Der Stacktrace enthält alle Frames des an ifError() übergebenen Fehlers, einschließlich der potenziellen neuen Frames für ifError() selbst.

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
copy

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

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

Erwartet, dass die string-Eingabe mit dem regulären Ausdruck übereinstimmt.

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
copy

Wenn die Werte nicht übereinstimmen oder das Argument string von einem anderen Typ als string ist, wird ein AssertionError geworfen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message nicht definiert ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

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

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

Strikter Assert-Modus

Ein Alias für assert.notDeepStrictEqual().

Legacy-Assert-Modus

Prüft auf jegliche tiefe Ungleichheit. Gegenteil von 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
copy

Wenn die Werte tiefengleich sind, wird ein AssertionError geworfen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message nicht definiert ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

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

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

Prüft auf tiefe strikte Ungleichheit. Gegenteil von 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
copy

Wenn die Werte tiefen- und striktgleich sind, wird ein AssertionError geworfen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message nicht definiert ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

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

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

Strikter Assert-Modus

Ein Alias für assert.notStrictEqual().

Legacy-Assert-Modus

Prüft auf flache, konvertierende Ungleichheit unter Verwendung des !=-Operators. NaN wird speziell behandelt und als identisch betrachtet, wenn beide Seiten NaN sind.

import assert from 'node:assert';

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

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

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

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

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

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

Wenn die Werte gleich sind, wird ein AssertionError geworwen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message nicht definiert ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

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

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

Prüft auf strikte Ungleichheit zwischen den Parametern actual und expected, wie durch Object.is() bestimmt.

import assert from 'node:assert/strict';

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

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

assert.notStrictEqual(1, '1');
// OK
const assert = require('node:assert/strict');

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

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

assert.notStrictEqual(1, '1');
// OK
copy

Wenn die Werte strikt gleich sind, wird ein AssertionError geworfen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message nicht definiert ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

assert.ok(value[, message])#

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

Prüft, ob value wahrheitsgemäß (truthy) ist. Dies entspricht assert.equal(!!value, true, message).

Wenn value nicht wahrheitsgemäß (truthy) ist, wird ein AssertionError geworfen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message undefined ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen. Wenn überhaupt keine Argumente übergeben werden, wird message auf die Zeichenkette 'No value argument passed to `assert.ok()`' gesetzt.

Beachten Sie, dass in der repl die Fehlermeldung eine andere ist als die, die in einer Datei geworfen wird! Siehe unten für weitere Details.

import assert from 'node:assert/strict';

assert.ok(true);
// OK
assert.ok(1);
// OK

assert.ok();
// AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, 'it\'s false');
// AssertionError: it's false

// In the repl:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true

// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(false)

assert.ok(0);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(0)
const assert = require('node:assert/strict');

assert.ok(true);
// OK
assert.ok(1);
// OK

assert.ok();
// AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, 'it\'s false');
// AssertionError: it's false

// In the repl:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true

// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(false)

assert.ok(0);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(0)
copy

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

• asyncFn <Function> | <Promise>
• error <RegExp> | <Function> | <Object> | <Error>
• message <string>
• Rückgabewert: <Promise>

Wartet auf das Promise asyncFn oder ruft, wenn asyncFn eine Funktion ist, die Funktion sofort auf und wartet auf die Fertigstellung des zurückgegebenen Promises. Anschließend wird geprüft, ob das Promise abgelehnt (rejected) wird.

Wenn asyncFn eine Funktion ist und diese synchron einen Fehler wirft, gibt assert.rejects() ein abgelehntes Promise mit diesem Fehler zurück. Wenn die Funktion kein Promise zurückgibt, gibt assert.rejects() ein abgelehntes Promise mit einem ERR_INVALID_RETURN_VALUE-Fehler zurück. In beiden Fällen wird der Error-Handler übersprungen.

Abgesehen von der asynchronen Natur des Wartens auf die Fertigstellung verhält es sich identisch zu assert.throws().

Falls angegeben, kann error eine Class, ein <RegExp>, eine Validierungsfunktion, ein Objekt, dessen Eigenschaften jeweils überprüft werden, oder eine Fehlerinstanz sein, bei der jede Eigenschaft überprüft wird, einschließlich der nicht-aufzählbaren Eigenschaften message und name.

Falls angegeben, wird message die vom AssertionError bereitgestellte Meldung sein, wenn das asyncFn nicht abgelehnt wird.

import assert from 'node:assert/strict';

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

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

import assert from 'node:assert/strict';

await assert.rejects(
  async () => {
    throw new TypeError('Wrong value');
  },
  (err) => {
    assert.strictEqual(err.name, 'TypeError');
    assert.strictEqual(err.message, 'Wrong value');
    return true;
  },
);
const assert = require('node:assert/strict');

(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Wrong value');
    },
    (err) => {
      assert.strictEqual(err.name, 'TypeError');
      assert.strictEqual(err.message, 'Wrong value');
      return true;
    },
  );
})();
copy

import assert from 'node:assert/strict';

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

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

error darf keine Zeichenkette sein. Wenn eine Zeichenkette als zweites Argument übergeben wird, wird angenommen, dass error weggelassen wurde, und die Zeichenkette wird stattdessen für message verwendet. Dies kann zu leicht zu übersehenden Fehlern führen. Bitte lesen Sie das Beispiel in assert.throws() sorgfältig durch, falls die Verwendung einer Zeichenkette als zweites Argument in Betracht gezogen wird.

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

• actual <any>
• expected <any>
• message <string> | <Error> | <Function> Postfix-Argumente im Stil von printf, falls es als Formatzeichenkette verwendet wird. Wenn message eine Funktion ist, wird sie im Falle eines fehlgeschlagenen Vergleichs aufgerufen. Die Funktion erhält die Argumente actual und expected und muss eine Zeichenkette zurückgeben, die als Fehlermeldung verwendet wird. printf-ähnliche Formatzeichenketten und Funktionen sind aus Performancegründen vorteilhaft, wenn Argumente durchgereicht werden. Darüber hinaus ermöglichen sie auf einfache Weise eine ansprechende Formatierung.

Prüft auf strikte Gleichheit zwischen den Parametern actual und expected, wie durch Object.is() bestimmt.

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(apples, oranges, 'apples %s !== oranges %s', apples, oranges);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
// TypeError: Inputs are not identical

assert.strictEqual(apples, oranges, (actual, expected) => {
  // Do 'heavy' computations
  return `I expected ${expected} but I got ${actual}`;
});
// AssertionError [ERR_ASSERTION]: I expected oranges but I got apples
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(apples, oranges, 'apples %s !== oranges %s', apples, oranges);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
// TypeError: Inputs are not identical

assert.strictEqual(apples, oranges, (actual, expected) => {
  // Do 'heavy' computations
  return `I expected ${expected} but I got ${actual}`;
});
// AssertionError [ERR_ASSERTION]: I expected oranges but I got apples
copy

Wenn die Werte nicht strikt gleich sind, wird ein AssertionError geworfen, dessen Eigenschaft message auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message nicht definiert ist, wird eine Standard-Fehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von <Error> ist, wird dieser anstelle des AssertionError geworfen.

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

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

Erwartet, dass die Funktion fn einen Fehler wirft.

Falls angegeben, kann error eine Class, ein <RegExp>, eine Validierungsfunktion, ein Validierungsobjekt, bei dem jede Eigenschaft auf strikte tiefe Gleichheit geprüft wird, oder eine Fehlerinstanz sein, bei der jede Eigenschaft auf strikte tiefe Gleichheit geprüft wird, einschließlich der nicht-aufzählbaren Eigenschaften message und name. Bei Verwendung eines Objekts ist es auch möglich, einen regulären Ausdruck zu verwenden, wenn eine Validierung gegen eine String-Eigenschaft erfolgt. Siehe unten für Beispiele.

Falls angegeben, wird message an die vom AssertionError bereitgestellte Meldung angehängt, wenn der Aufruf von fn keinen Fehler wirft oder die Fehlervalidierung fehlschlägt.

Benutzerdefiniertes Validierungsobjekt/Fehlerinstanz

import assert from 'node:assert/strict';

const err = new TypeError('Wrong value');
err.code = 404;
err.foo = 'bar';
err.info = {
  nested: true,
  baz: 'text',
};
err.reg = /abc/i;

assert.throws(
  () => {
    throw err;
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
    info: {
      nested: true,
      baz: 'text',
    },
    // Only properties on the validation object will be tested for.
    // Using nested objects requires all properties to be present. Otherwise
    // the validation is going to fail.
  },
);

// Using regular expressions to validate error properties:
assert.throws(
  () => {
    throw err;
  },
  {
    // The `name` and `message` properties are strings and using regular
    // expressions on those will match against the string. If they fail, an
    // error is thrown.
    name: /^TypeError$/,
    message: /Wrong/,
    foo: 'bar',
    info: {
      nested: true,
      // It is not possible to use regular expressions for nested properties!
      baz: 'text',
    },
    // The `reg` property contains a regular expression and only if the
    // validation object contains an identical regular expression, it is going
    // to pass.
    reg: /abc/i,
  },
);

// Fails due to the different `message` and `name` properties:
assert.throws(
  () => {
    const otherErr = new Error('Not found');
    // Copy all enumerable properties from `err` to `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value;
    }
    throw otherErr;
  },
  // The error's `message` and `name` properties will also be checked when using
  // an error as validation object.
  err,
);
const assert = require('node:assert/strict');

const err = new TypeError('Wrong value');
err.code = 404;
err.foo = 'bar';
err.info = {
  nested: true,
  baz: 'text',
};
err.reg = /abc/i;

assert.throws(
  () => {
    throw err;
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
    info: {
      nested: true,
      baz: 'text',
    },
    // Only properties on the validation object will be tested for.
    // Using nested objects requires all properties to be present. Otherwise
    // the validation is going to fail.
  },
);

// Using regular expressions to validate error properties:
assert.throws(
  () => {
    throw err;
  },
  {
    // The `name` and `message` properties are strings and using regular
    // expressions on those will match against the string. If they fail, an
    // error is thrown.
    name: /^TypeError$/,
    message: /Wrong/,
    foo: 'bar',
    info: {
      nested: true,
      // It is not possible to use regular expressions for nested properties!
      baz: 'text',
    },
    // The `reg` property contains a regular expression and only if the
    // validation object contains an identical regular expression, it is going
    // to pass.
    reg: /abc/i,
  },
);

// Fails due to the different `message` and `name` properties:
assert.throws(
  () => {
    const otherErr = new Error('Not found');
    // Copy all enumerable properties from `err` to `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value;
    }
    throw otherErr;
  },
  // The error's `message` and `name` properties will also be checked when using
  // an error as validation object.
  err,
);
copy

Überprüfung von instanceof mittels Konstruktor

import assert from 'node:assert/strict';

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  Error,
);
const assert = require('node:assert/strict');

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

Fehlermeldung validieren unter Verwendung von <RegExp>

Die Verwendung eines regulären Ausdrucks führt .toString auf dem Fehlerobjekt aus und schließt daher auch den Fehlernamen ein.

import assert from 'node:assert/strict';

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

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

Benutzerdefinierte Fehlervalidierung

Die Funktion muss true zurückgeben, um anzuzeigen, dass alle internen Validierungen erfolgreich waren. Andernfalls schlägt sie mit einem AssertionError fehl.

import assert from 'node:assert/strict';

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  (err) => {
    assert(err instanceof Error);
    assert(/value/.test(err));
    // Avoid returning anything from validation functions besides `true`.
    // Otherwise, it's not clear what part of the validation failed. Instead,
    // throw an error about the specific validation that failed (as done in this
    // example) and add as much helpful debugging information to that error as
    // possible.
    return true;
  },
  'unexpected error',
);
const assert = require('node:assert/strict');

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  (err) => {
    assert(err instanceof Error);
    assert(/value/.test(err));
    // Avoid returning anything from validation functions besides `true`.
    // Otherwise, it's not clear what part of the validation failed. Instead,
    // throw an error about the specific validation that failed (as done in this
    // example) and add as much helpful debugging information to that error as
    // possible.
    return true;
  },
  'unexpected error',
);
copy

error darf keine Zeichenkette sein. Wenn eine Zeichenkette als zweites Argument übergeben wird, wird angenommen, dass error weggelassen wurde, und die Zeichenkette wird stattdessen für message verwendet. Dies kann zu leicht zu übersehenden Fehlern führen. Die Verwendung derselben Meldung wie die des geworfenen Fehlers führt zu einem ERR_AMBIGUOUS_ARGUMENT-Fehler. Bitte lesen Sie das folgende Beispiel sorgfältig durch, falls die Verwendung einer Zeichenkette als zweites Argument in Betracht gezogen wird.

import assert from 'node:assert/strict';

function throwingFirst() {
  throw new Error('First');
}

function throwingSecond() {
  throw new Error('Second');
}

function notThrowing() {}

// The second argument is a string and the input function threw an Error.
// The first case will not throw as it does not match for the error message
// thrown by the input function!
assert.throws(throwingFirst, 'Second');
// In the next example the message has no benefit over the message from the
// error and since it is not clear if the user intended to actually match
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// The string is only used (as message) in case the function does not throw:
assert.throws(notThrowing, 'Second');
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// If it was intended to match for the error message do this instead:
// It does not throw because the error messages match.
assert.throws(throwingSecond, /Second$/);

// If the error message does not match, an AssertionError is thrown.
assert.throws(throwingFirst, /Second$/);
// AssertionError [ERR_ASSERTION]
const assert = require('node:assert/strict');

function throwingFirst() {
  throw new Error('First');
}

function throwingSecond() {
  throw new Error('Second');
}

function notThrowing() {}

// The second argument is a string and the input function threw an Error.
// The first case will not throw as it does not match for the error message
// thrown by the input function!
assert.throws(throwingFirst, 'Second');
// In the next example the message has no benefit over the message from the
// error and since it is not clear if the user intended to actually match
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// The string is only used (as message) in case the function does not throw:
assert.throws(notThrowing, 'Second');
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// If it was intended to match for the error message do this instead:
// It does not throw because the error messages match.
assert.throws(throwingSecond, /Second$/);

// If the error message does not match, an AssertionError is thrown.
assert.throws(throwingFirst, /Second$/);
// AssertionError [ERR_ASSERTION]
copy

Vermeiden Sie aufgrund der verwirrenden und fehleranfälligen Notation eine Zeichenkette als zweites Argument.

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

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

Prüft auf partielle tiefe Gleichheit zwischen den Parametern actual und expected. „Tiefe“ Gleichheit bedeutet, dass die aufzählbaren „eigenen“ Eigenschaften von Kindobjekten ebenfalls rekursiv nach folgenden Regeln ausgewertet werden. „Partielle“ Gleichheit bedeutet, dass nur Eigenschaften verglichen werden, die auf dem Parameter expected existieren.

Diese Methode besteht immer dieselben Testfälle wie assert.deepStrictEqual() und verhält sich wie eine Obermenge davon.

Details zum Vergleich#

• Primitive Werte werden mittels Object.is() verglichen.
• Die Typ-Tags von Objekten sollten übereinstimmen.
• Der [[Prototype]] von Objekten wird nicht verglichen.
• Es werden nur aufzählbare „eigene“ Eigenschaften berücksichtigt.
• Die Namen, Meldungen, Ursachen (causes) und Fehler (errors) von <Error>-Objekten werden immer verglichen, selbst wenn dies keine aufzählbaren Eigenschaften sind. errors wird ebenfalls verglichen.
• Aufzählbare eigene <Symbol>-Eigenschaften werden ebenfalls verglichen.
• Objekt-Wrapper werden sowohl als Objekte als auch als ausgepackte Werte verglichen.
• Eigenschaften von Objects werden ungeordnet verglichen.
• Schlüssel von <Map> und Elemente von <Set> werden ungeordnet verglichen.
• Die Rekursion stoppt, wenn sich beide Seiten unterscheiden oder beide Seiten auf eine zirkuläre Referenz stoßen.
• Instanzen von <WeakMap>, <WeakSet> und <Promise> werden nicht strukturell verglichen. Sie sind nur gleich, wenn sie dasselbe Objekt referenzieren. Jeder Vergleich zwischen verschiedenen WeakMap-, WeakSet- oder Promise-Instanzen führt zu Ungleichheit, selbst wenn sie denselben Inhalt haben.
• Die Eigenschaften „lastIndex“, „flags“ und „source“ von <RegExp> werden immer verglichen, selbst wenn dies keine aufzählbaren Eigenschaften sind.
• Lücken (Holes) in dünnbesetzten Arrays (Sparse Arrays) werden ignoriert.

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