Assert

[Stabil: 2 - Stabil]

Stabil: 2 Stabilität: 2 - Stabil

Quellcode: lib/assert.js

Das Modul node:assert bietet eine Reihe von Assertionsfunktionen zur Überprüfung von Invarianten.

Strikter Assertionsmodus

[Verlauf]

Version	Änderungen
v15.0.0	Exportiert als require('node:assert/strict').
v13.9.0, v12.16.2	"Strikter Modus" in "Strikter Assertionsmodus" und "Legacy-Modus" in "Legacy-Assertionsmodus" umbenannt, um Verwechslungen mit der gebräuchlicheren Bedeutung von "Striktem Modus" zu vermeiden.
v9.9.0	Fehler-Diffs zum strikten Assertionsmodus hinzugefügt.
v9.9.0	Strikter Assertionsmodus zum assert-Modul hinzugefügt.
v9.9.0	Hinzugefügt in: v9.9.0

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

Im strikten Assertionsmodus zeigen Fehlermeldungen für Objekte einen Diff an. Im Legacy-Assertionsmodus zeigen Fehlermeldungen für Objekte die Objekte an, oft gekürzt.

So verwenden Sie den strikten Assertionsmodus:

ESM

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

CJS

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

ESM

import assert from 'node:assert/strict'

CJS

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

Beispiel für einen Fehler-Diff:

ESM

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 ... Zeilen übersprungen
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

CJS

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 ... Zeilen übersprungen
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

Um die Farben zu deaktivieren, verwenden Sie die Umgebungsvariablen NO_COLOR oder NODE_DISABLE_COLORS. Dies deaktiviert auch die Farben in der REPL. Weitere Informationen zur Farbunterstützung in Terminalumgebungen finden Sie in der tty getColorDepth() Dokumentation.

Legacy-Assertion-Modus

Der Legacy-Assertion-Modus verwendet den ==-Operator in:

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

So verwenden Sie den Legacy-Assertion-Modus:

ESM

import assert from 'node:assert'

CJS

const assert = require('node:assert')

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

// WARNUNG: Dies löst im Legacy-Assertion-Modus keinen AssertionError aus!
assert.deepEqual(/a/gi, new Date())

Klasse: assert.AssertionError

• Erweitert: <errors.Error>

Gibt das Scheitern einer Assertion an. Alle Fehler, die vom Modul node:assert ausgelöst werden, sind Instanzen der Klasse AssertionError.

new assert.AssertionError(options)

Hinzugefügt in: v0.1.21

• options <Object>
  • message <string> Wenn angegeben, wird die Fehlermeldung auf diesen Wert gesetzt.
  • actual <any> Die actual-Eigenschaft der Fehlerinstanz.
  • expected <any> Die expected-Eigenschaft der Fehlerinstanz.
  • operator <string> Die operator-Eigenschaft der Fehlerinstanz.
  • stackStartFn <Function> Wenn angegeben, werden die generierten Stack-Traces Frames vor dieser Funktion ausgelassen.

Eine Unterklasse von Error, die das Scheitern einer Assertion anzeigt.

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

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

ESM

import assert from 'node:assert'

// Generieren Sie einen AssertionError, um die Fehlermeldung später zu vergleichen:
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// Überprüfen Sie die Fehler-Ausgabe:
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)
}

CJS

const assert = require('node:assert')

// Generieren Sie einen AssertionError, um die Fehlermeldung später zu vergleichen:
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// Überprüfen Sie die Fehler-Ausgabe:
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)
}

Klasse: assert.CallTracker

[Historie]

Version	Änderungen
v20.1.0	Die Klasse assert.CallTracker wurde als veraltet markiert und wird in einer zukünftigen Version entfernt.
v14.2.0, v12.19.0	Hinzugefügt in: v14.2.0, v12.19.0

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet

Diese Funktion ist veraltet und wird in einer zukünftigen Version entfernt. Bitte verwenden Sie alternative Lösungen wie die Hilfsfunktion mock.

new assert.CallTracker()

Hinzugefügt in: v14.2.0, v12.19.0

Erstellt ein neues CallTracker-Objekt, mit dem verfolgt werden kann, ob Funktionen eine bestimmte Anzahl von Malen aufgerufen wurden. Die Methode tracker.verify() muss aufgerufen werden, damit die Überprüfung stattfindet. Das übliche Muster ist, sie in einem process.on('exit')-Handler aufzurufen.

ESM

import assert from 'node:assert'
import process from 'node:process'

const tracker = new assert.CallTracker()

function func() {}

// callsfunc() muss genau 1 Mal aufgerufen werden, bevor tracker.verify() aufgerufen wird.
const callsfunc = tracker.calls(func, 1)

callsfunc()

// Ruft tracker.verify() auf und überprüft, ob alle tracker.calls()-Funktionen die genaue Anzahl an Malen aufgerufen wurden.
process.on('exit', () => {
  tracker.verify()
})

CJS

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

const tracker = new assert.CallTracker()

function func() {}

// callsfunc() muss genau 1 Mal aufgerufen werden, bevor tracker.verify() aufgerufen wird.
const callsfunc = tracker.calls(func, 1)

callsfunc()

// Ruft tracker.verify() auf und überprüft, ob alle tracker.calls()-Funktionen die genaue Anzahl an Malen aufgerufen wurden.
process.on('exit', () => {
  tracker.verify()
})

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

Hinzugefügt in: v14.2.0, v12.19.0

• fn <Function> Standard: Eine No-op-Funktion.
• exact <number> Standard: 1.
• Rückgabewert: <Function> Eine Funktion, die fn umschließt.

Es wird erwartet, dass die Wrapper-Funktion genau exact-mal aufgerufen wird. Wenn die Funktion nicht genau exact-mal aufgerufen wurde, wenn tracker.verify() aufgerufen wird, dann löst tracker.verify() einen Fehler aus.

ESM

import assert from 'node:assert'

// Erstellt einen Call Tracker.
const tracker = new assert.CallTracker()

function func() {}

// Gibt eine Funktion zurück, die func() umschließt und die genau die angegebene Anzahl von Malen aufgerufen werden muss, bevor tracker.verify() aufgerufen wird.
const callsfunc = tracker.calls(func)

CJS

const assert = require('node:assert')

// Erstellt einen Call Tracker.
const tracker = new assert.CallTracker()

function func() {}

// Gibt eine Funktion zurück, die func() umschließt und die genau die angegebene Anzahl von Malen aufgerufen werden muss, bevor tracker.verify() aufgerufen wird.
const callsfunc = tracker.calls(func)

tracker.getCalls(fn)

Hinzugefügt in: v18.8.0, v16.18.0

• fn <Function>
• Gibt zurück: <Array> Ein Array mit allen Aufrufen einer verfolgten Funktion.
• Objekt <Object>
  • thisArg <Object>
  • arguments <Array> die an die verfolgte Funktion übergebenen Argumente

ESM

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

CJS

const assert = require('node:assert')

// Erstellt 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()

Hinzugefügt in: v14.2.0, v12.19.0

• Gibt zurück: <Array> Ein Array von Objekten, die Informationen über die von tracker.calls() zurückgegebenen Wrapper-Funktionen enthalten.
• Objekt <Object>
  • message <string>
  • actual <number> Die tatsächliche Anzahl der Aufrufe der Funktion.
  • expected <number> Die Anzahl der erwarteten Aufrufe der Funktion.
  • operator <string> Der Name der Funktion, die gewrappered ist.
  • stack <Object> Ein Stack Trace der Funktion.

Die Arrays enthalten Informationen über die erwartete und die tatsächliche Anzahl der Aufrufe der Funktionen, die nicht die erwartete Anzahl an Malen aufgerufen wurden.

ESM

import assert from 'node:assert'

// Erstellt Call Tracker.
const tracker = new assert.CallTracker()

function func() {}

// Gibt eine Funktion zurück, die func() wrappt und genau so oft aufgerufen werden muss,
// bevor tracker.verify() aufgerufen wird.
const callsfunc = tracker.calls(func, 2)

// Gibt ein Array zurück, das Informationen über callsfunc() enthält
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
//  }
// ]

CJS

const assert = require('node:assert')

// Erstellt Call Tracker.
const tracker = new assert.CallTracker()

function func() {}

// Gibt eine Funktion zurück, die func() wrappt und genau so oft aufgerufen werden muss,
// bevor tracker.verify() aufgerufen wird.
const callsfunc = tracker.calls(func, 2)

// Gibt ein Array zurück, das Informationen über callsfunc() enthält
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])

Hinzugefügt in: v18.8.0, v16.18.0

• fn <Function> eine verfolgte Funktion zum Zurücksetzen.

Setzt Aufrufe des Call Trackers zurück. Wenn eine verfolgte Funktion als Argument übergeben wird, werden die Aufrufe für diese zurückgesetzt. Wenn keine Argumente übergeben werden, werden alle verfolgten Funktionen zurückgesetzt.

ESM

import assert from 'node:assert'

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)

callsfunc()
// Tracker wurde einmal aufgerufen
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

tracker.reset(callsfunc)
assert.strictEqual(tracker.getCalls(callsfunc).length, 0)

CJS

const assert = require('node:assert')

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)

callsfunc()
// Tracker wurde einmal aufgerufen
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

tracker.reset(callsfunc)
assert.strictEqual(tracker.getCalls(callsfunc).length, 0)

tracker.verify()

Hinzugefügt in: v14.2.0, v12.19.0

Iteriert durch die Liste der Funktionen, die an tracker.calls() übergeben wurden, und löst einen Fehler für Funktionen aus, die nicht die erwartete Anzahl von Malen aufgerufen wurden.

ESM

import assert from 'node:assert'

// Erstellt Call Tracker.
const tracker = new assert.CallTracker()

function func() {}

// Gibt eine Funktion zurück, die func() umschließt und genau so oft aufgerufen werden muss,
// bevor tracker.verify() aufgerufen wird.
const callsfunc = tracker.calls(func, 2)

callsfunc()

// Löst einen Fehler aus, da callsfunc() nur einmal aufgerufen wurde.
tracker.verify()

CJS

const assert = require('node:assert')

// Erstellt Call Tracker.
const tracker = new assert.CallTracker()

function func() {}

// Gibt eine Funktion zurück, die func() umschließt und genau so oft aufgerufen werden muss,
// bevor tracker.verify() aufgerufen wird.
const callsfunc = tracker.calls(func, 2)

callsfunc()

// Löst einen Fehler aus, da callsfunc() nur einmal aufgerufen wurde.
tracker.verify()

assert(value[, message])

Hinzugefügt in: v0.5.9

• value <any> Der Eingabewert, der auf Wahrheitsgehalt geprüft wird.
• message <string> | <Error>

Ein Alias von assert.ok().

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

[Verlauf]

Version	Änderungen
v22.2.0, v20.15.0	Fehlerursache und Fehler-Eigenschaften werden nun ebenfalls verglichen.
v18.0.0	Die lastIndex-Eigenschaft regulärer Ausdrücke wird nun ebenfalls verglichen.
v16.0.0, v14.18.0	Im Legacy-Assertionsmodus wurde der Status von „Veraltet“ auf „Legacy“ geändert.
v14.0.0	NaN wird nun als identisch behandelt, wenn beide Seiten NaN sind.
v12.0.0	Die Typ-Tags werden nun korrekt verglichen, und es gibt einige kleinere Anpassungen beim Vergleich, um die Prüfung weniger überraschend zu gestalten.
v9.0.0	Die Namen und Meldungen von Error werden nun korrekt verglichen.
v8.0.0	Der Inhalt von Set und Map wird ebenfalls verglichen.
v6.4.0, v4.7.1	Abschnitte von Typisierten Arrays werden nun korrekt behandelt.
v6.1.0, v4.5.0	Objekte mit zirkulären Referenzen können nun als Eingaben verwendet werden.
v5.10.1, v4.4.3	Nicht-Uint8Array-Typisierte Arrays werden korrekt behandelt.
v0.1.21	Hinzugefügt in: v0.1.21

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

Strikter Assertionsmodus

Ein Alias von assert.deepStrictEqual().

Legacy-Assertionsmodus

[Stabil: 3 - Legacy]

Stabil: 3 Stabilität: 3 - Legacy: Verwenden Sie stattdessen assert.deepStrictEqual().

Testet auf tiefe Gleichheit zwischen den Parametern actual und expected. Verwenden Sie stattdessen assert.deepStrictEqual(). assert.deepEqual() kann zu überraschenden Ergebnissen führen.

Tiefe Gleichheit bedeutet, dass die aufzählbaren eigenen Eigenschaften von untergeordneten Objekten auch rekursiv nach den folgenden Regeln ausgewertet werden.

Vergleichsdetails

• Primitiven Werte werden mit dem ==-Operator verglichen, mit der Ausnahme von NaN. NaN wird als identisch behandelt, wenn beide Seiten NaN sind.
• Typ-Tags von Objekten sollten übereinstimmen.
• Nur aufzählbare eigene Eigenschaften werden berücksichtigt.
• Error-Namen, -Meldungen, -Ursachen und -Fehler werden immer verglichen, auch wenn diese keine aufzählbaren Eigenschaften sind.
• Objekt-Wrapper werden sowohl als Objekte als auch als ausgepackte Werte verglichen.
• Object-Eigenschaften werden ungeordnet verglichen.
• Map-Schlüssel und Set-Elemente werden ungeordnet verglichen.
• Die Rekursion stoppt, wenn beide Seiten unterschiedlich sind oder beide Seiten auf eine zirkuläre Referenz stoßen.
• Die Implementierung testet nicht den [[Prototype]] von Objekten.
• Symbol-Eigenschaften werden nicht verglichen.
• Der Vergleich von WeakMap und WeakSet beruht nicht auf ihren Werten, sondern nur auf ihren Instanzen.
• RegExp lastIndex, flags und source werden immer verglichen, auch wenn diese keine aufzählbaren Eigenschaften sind.

Das folgende Beispiel löst keinen AssertionError aus, da die primitiven Werte mit dem ==-Operator verglichen werden.

ESM

import assert from 'node:assert'
// WARNUNG: Dies löst keinen AssertionError aus!

assert.deepEqual('+00000000', false)

CJS

const assert = require('node:assert')
// WARNUNG: Dies löst keinen AssertionError aus!

assert.deepEqual('+00000000', false)

"Tiefe" Gleichheit bedeutet, dass die aufzählbaren eigenen Eigenschaften von untergeordneten Objekten ebenfalls ausgewertet werden:

ESM

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

// Werte von b sind unterschiedlich:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Prototypen werden ignoriert:
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}

CJS

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

// Werte von b sind unterschiedlich:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Prototypen werden ignoriert:
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}

Wenn die Werte nicht gleich sind, wird ein AssertionError mit einer message-Eigenschaft ausgelöst, die auf den Wert des message-Parameters gesetzt ist. Wenn der message-Parameter undefiniert ist, wird eine Standardfehlermeldung zugewiesen. Wenn der message-Parameter eine Instanz eines Error ist, wird dieser anstelle des AssertionError ausgelöst.

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

[Versionsverlauf]

Version	Änderungen
v22.2.0, v20.15.0	Fehlerursache und Fehler-Eigenschaften werden jetzt ebenfalls verglichen.
v18.0.0	Die Eigenschaft lastIndex regulärer Ausdrücke wird jetzt ebenfalls verglichen.
v9.0.0	Aufzählbare Symbol-Eigenschaften werden jetzt verglichen.
v9.0.0	NaN wird jetzt mit dem SameValueZero-Vergleich verglichen.
v8.5.0	Die Namen und Meldungen von Error werden jetzt korrekt verglichen.
v8.0.0	Der Inhalt von Set und Map wird ebenfalls verglichen.
v6.1.0	Objekte mit zirkulären Referenzen können jetzt als Eingabe verwendet werden.
v6.4.0, v4.7.1	Abschnitte von Typisierten Arrays werden jetzt korrekt behandelt.
v5.10.1, v4.4.3	Nicht-Uint8Array-Typisierte Arrays werden jetzt korrekt behandelt.
v1.2.0	Hinzugefügt in: v1.2.0

• actual <beliebig>
• expected <beliebig>
• message <string> | <Error>

Testet auf tiefe Gleichheit zwischen den Parametern actual und expected. "Tiefe" Gleichheit bedeutet, dass die aufzählbaren eigenen Eigenschaften von untergeordneten Objekten auch nach den folgenden Regeln rekursiv ausgewertet werden.

Vergleichsdetails

• Primitive Werte werden mit Object.is() verglichen.
• Typ-Tags von Objekten sollten gleich sein.
• [[Prototype]] von Objekten werden mit dem ===-Operator verglichen.
• Nur aufzählbare eigene Eigenschaften werden berücksichtigt.
• Error-Namen, -Meldungen, -Ursachen und -Fehler werden immer verglichen, auch wenn diese 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 entpackte Werte verglichen.
• Object-Eigenschaften werden ungeordnet verglichen.
• Map-Schlüssel und Set-Elemente werden ungeordnet verglichen.
• Die Rekursion stoppt, wenn beide Seiten unterschiedlich sind oder beide Seiten auf eine zirkuläre Referenz stoßen.
• Der Vergleich von WeakMap und WeakSet stützt sich nicht auf deren Werte. Siehe unten für weitere Details.
• RegExp lastIndex, Flags und Quelle werden immer verglichen, auch wenn diese keine aufzählbaren Eigenschaften sind.

ESM

import assert from 'node:assert/strict'

// Dies schlägt fehl, weil 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// Die folgenden Objekte haben keine eigenen Eigenschaften
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// Unterschiedliches [[Prototype]]:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// Unterschiedliche Typ-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, weil Object.is(NaN, NaN) true ist.

// Unterschiedliche entpackte Zahlen:
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, weil das Objekt und die Zeichenkette beim Entpacken identisch sind.

assert.deepStrictEqual(-0, -0)
// OK

// Unterschiedliche Nullen:
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, weil es das gleiche Symbol in beiden Objekten ist.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
//   [Symbol()]: 1
// }

const weakMap1 = new WeakMap()
const weakMap2 = new WeakMap([[{}, {}]])
const weakMap3 = new WeakMap()
weakMap3.unequal = true

assert.deepStrictEqual(weakMap1, weakMap2)
// OK, weil es unmöglich ist, die Einträge zu vergleichen

// Schlägt fehl, weil weakMap3 eine Eigenschaft hat, die weakMap1 nicht enthält:
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

CJS

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

// Dies schlägt fehl, weil 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// Die folgenden Objekte haben keine eigenen Eigenschaften
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// Unterschiedliches [[Prototype]]:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// Unterschiedliche Typ-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, weil Object.is(NaN, NaN) true ist.

// Unterschiedliche entpackte Zahlen:
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, weil das Objekt und die Zeichenkette beim Entpacken identisch sind.

assert.deepStrictEqual(-0, -0)
// OK

// Unterschiedliche Nullen:
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, weil es das gleiche Symbol in beiden Objekten ist.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
//   [Symbol()]: 1
// }

const weakMap1 = new WeakMap()
const weakMap2 = new WeakMap([[{}, {}]])
const weakMap3 = new WeakMap()
weakMap3.unequal = true

assert.deepStrictEqual(weakMap1, weakMap2)
// OK, weil es unmöglich ist, die Einträge zu vergleichen

// Schlägt fehl, weil weakMap3 eine Eigenschaft hat, die weakMap1 nicht enthält:
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

Sind die Werte nicht gleich, wird ein AssertionError mit einer message-Eigenschaft geworfen, die auf den Wert des message-Parameters gesetzt ist. Ist der message-Parameter undefiniert, wird eine Standardfehlermeldung zugewiesen. Ist der message-Parameter eine Instanz eines Error, wird dieser anstelle des AssertionError geworfen.

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

[Versionsgeschichte]

Version	Änderungen
v16.0.0	Diese API ist nicht mehr experimentell.
v13.6.0, v12.16.0	Hinzugefügt in: v13.6.0, v12.16.0

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

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

ESM

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

CJS

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

Wenn die Werte übereinstimmen oder wenn das Argument string einen anderen Typ als string hat, wird ein AssertionError mit einer Eigenschaft message geworfen, die auf den Wert des Parameters message gesetzt ist. Wenn der Parameter message undefiniert ist, wird eine Standardfehlermeldung zugewiesen. Wenn der Parameter message eine Instanz von Error ist, wird dieser anstelle des AssertionError geworfen.

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

Hinzugefügt in: v10.0.0

• asyncFn <Function> | <Promise>
• error <RegExp> | <Function>
• message <string>

Wartet auf das asyncFn-Promise oder, wenn asyncFn eine Funktion ist, ruft die Funktion sofort auf und wartet auf die Beendigung des zurückgegebenen Promises. Anschließend wird geprüft, ob das Promise nicht zurückgewiesen wird.

Wenn asyncFn eine Funktion ist und synchron einen Fehler auslöst, gibt assert.doesNotReject() ein zurückgewiesenes Promise mit diesem Fehler zurück. Wenn die Funktion kein Promise zurückgibt, gibt assert.doesNotReject() ein zurückgewiesenes Promise mit einem ERR_INVALID_RETURN_VALUE-Fehler zurück. In beiden Fällen wird der Fehlerhandler übersprungen.

Die Verwendung von assert.doesNotReject() ist eigentlich nicht sinnvoll, da es wenig Vorteile bringt, eine Zurückweisung abzufangen und dann erneut zurückzuweisen. Erwägen Sie stattdessen, einen Kommentar neben dem spezifischen Codepfad hinzuzufügen, der keine Zurückweisung erwarten sollte, und halten Sie Fehlermeldungen so aussagekräftig wie möglich.

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

Abgesehen von der asynchronen Natur, um die Fertigstellung abzuwarten, verhält sich die Funktion identisch zu assert.doesNotThrow().

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

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

[Verlauf]

Version	Änderungen
v5.11.0, v4.4.5	Der Parameter message wird jetzt berücksichtigt.
v4.2.0	Der Parameter error kann jetzt eine Arrow-Funktion sein.
v0.1.21	Hinzugefügt in: v0.1.21

• fn <Funktion>
• error <RegExp> | <Funktion>
• message <Zeichenkette>

Prüft, ob die Funktion fn keinen Fehler auslöst.

Die Verwendung von assert.doesNotThrow() ist eigentlich nicht sinnvoll, da das Abfangen eines Fehlers und dessen erneutes Auslösen keinen Vorteil bietet. Erwägen Sie stattdessen, einen Kommentar neben den spezifischen Codepfad hinzuzufügen, der keinen Fehler auslösen sollte, und halten Sie Fehlermeldungen so aussagekräftig wie möglich.

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

Wenn ein Fehler ausgelöst wird und dieser dem gleichen Typ entspricht, der durch den Parameter error angegeben ist, wird ein AssertionError ausgelöst. Wenn der Fehler einen anderen Typ hat oder der Parameter error undefiniert ist, wird der Fehler an den Aufrufer weitergegeben.

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

Das folgende Beispiel löst beispielsweise den TypeError aus, da kein übereinstimmender Fehlertyp in der Assertion vorhanden ist:

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Falscher Wert')
}, SyntaxError)

CJS

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

assert.doesNotThrow(() => {
  throw new TypeError('Falscher Wert')
}, SyntaxError)

Das folgende Beispiel führt jedoch zu einem AssertionError mit der Meldung "Unerwartete Ausnahme erhalten...":

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Falscher Wert')
}, TypeError)

CJS

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

assert.doesNotThrow(() => {
  throw new TypeError('Falscher Wert')
}, TypeError)

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

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(
  () => {
    throw new TypeError('Falscher Wert')
  },
  /Falscher Wert/,
  'Hoppla'
)
// Ausgelöst: AssertionError: Unerwartete Ausnahme erhalten: Hoppla

CJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Falscher Wert')
  },
  /Falscher Wert/,
  'Hoppla'
)
// Ausgelöst: AssertionError: Unerwartete Ausnahme erhalten: Hoppla

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

[Historie]

Version	Änderungen
v16.0.0, v14.18.0	Im Legacy-Assertionsmodus wurde der Status von „Veraltet“ in „Legacy“ geändert.
v14.0.0	NaN wird jetzt als identisch behandelt, wenn beide Seiten NaN sind.
v0.1.21	Hinzugefügt in: v0.1.21

• actual <beliebig>
• expected <beliebig>
• message <string> | <Error>

Strenger Assertionsmodus

Ein Alias von assert.strictEqual().

Legacy-Assertionsmodus

[Stabil: 3 - Legacy]

Stabil: 3 Stabilität: 3 - Legacy: Verwenden Sie stattdessen assert.strictEqual().

Testet die oberflächliche, zwanghafte Gleichheit zwischen den Parametern actual und expected mithilfe des Operators ==. NaN wird speziell behandelt und als identisch angesehen, wenn beide Seiten NaN sind.

ESM

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

CJS

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

Wenn die Werte nicht gleich sind, wird ein AssertionError mit einer message-Eigenschaft ausgelöst, die auf den Wert des message-Parameters gesetzt ist. Wenn der message-Parameter undefiniert ist, wird eine Standardfehlermeldung zugewiesen. Wenn der message-Parameter eine Instanz eines Error ist, wird dieser anstelle des AssertionError ausgelöst.

assert.fail([message])

Hinzugefügt in: v0.1.21

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

Wirft einen AssertionError mit der angegebenen Fehlermeldung oder einer Standardfehlermeldung. Wenn der Parameter message eine Instanz eines Error ist, wird dieser anstelle des AssertionError geworfen.

ESM

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

CJS

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

Die Verwendung von assert.fail() mit mehr als zwei Argumenten ist möglich, aber veraltet. Weitere Einzelheiten finden Sie unten.

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

[Verlauf]

Version	Änderungen
v10.0.0	Das Aufrufen von assert.fail() mit mehr als einem Argument ist veraltet und gibt eine Warnung aus.
v0.1.21	Hinzugefügt in: v0.1.21

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet: Verwenden Sie stattdessen assert.fail([message]) oder andere assert-Funktionen.

• actual <any>
• expected <any>
• message <string> | <Error>
• operator <string> Standardwert: '!='
• stackStartFn <Function> Standardwert: assert.fail

Wenn message falsch ist, wird die Fehlermeldung als die Werte von actual und expected getrennt durch den angegebenen operator festgelegt. Wenn nur die beiden Argumente actual und expected angegeben werden, wird operator standardmäßig auf '!=' gesetzt. Wenn message als drittes Argument angegeben wird, wird es als Fehlermeldung verwendet und die anderen Argumente werden als Eigenschaften des geworfenen Objekts gespeichert. Wenn stackStartFn angegeben wird, werden alle Stack-Frames über dieser Funktion aus der Stacktrace entfernt (siehe Error.captureStackTrace). Wenn keine Argumente angegeben werden, wird die Standardmeldung Failed verwendet.

ESM

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

CJS

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

In den letzten drei Fällen haben actual, expected und operator keinen Einfluss auf die Fehlermeldung.

Beispiel für die Verwendung von stackStartFn zum Kürzen des Stacktrace der Ausnahme:

ESM

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

CJS

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)

[Versionsgeschichte]

Version	Änderungen
v10.0.0	Anstatt den ursprünglichen Fehler auszugeben, wird er jetzt in einen [AssertionError][]-Fehler eingehüllt, der die vollständige Stack-Trace enthält.
v10.0.0	Der Wert darf jetzt nur noch undefined oder null sein. Zuvor wurden alle falsy Werte wie null behandelt und haben keinen Fehler ausgelöst.
v0.1.97	Hinzugefügt in: v0.1.97

• value <beliebig>

Gibt value aus, wenn value nicht undefined oder null ist. Dies ist nützlich beim Testen des error-Arguments in Callbacks. Der Stack-Trace enthält alle Frames aus dem an ifError() übergebenen Fehler, einschließlich der potenziellen neuen Frames für ifError() selbst.

ESM

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

// Erzeuge einige zufällige Fehler-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

CJS

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

// Erzeuge einige zufällige Fehler-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])

[Verlauf]

Version	Änderungen
v16.0.0	Diese API ist nicht mehr experimentell.
v13.6.0, v12.16.0	Hinzugefügt in: v13.6.0, v12.16.0

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

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

ESM

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

CJS

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

Wenn die Werte nicht übereinstimmen oder wenn das Argument string einen anderen Typ als string hat, wird ein AssertionError mit einer Eigenschaft message ausgelöst, die auf den Wert des Parameters message gesetzt ist. Ist der Parameter message undefiniert, wird eine Standardfehlermeldung zugewiesen. Ist der Parameter message eine Instanz eines Error, wird dieser anstelle des AssertionError ausgelöst.

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

[Verlauf]

Version	Änderungen
v16.0.0, v14.18.0	Im Legacy-Assertion-Modus wurde der Status von Veraltet auf Legacy geändert.
v14.0.0	NaN wird jetzt als identisch behandelt, wenn beide Seiten NaN sind.
v9.0.0	Die Namen und Meldungen von Error werden jetzt ordnungsgemäß verglichen.
v8.0.0	Der Inhalt von Set und Map wird ebenfalls verglichen.
v6.4.0, v4.7.1	Abschnitte von Typisierten Arrays werden jetzt korrekt behandelt.
v6.1.0, v4.5.0	Objekte mit zirkulären Referenzen können jetzt als Eingaben verwendet werden.
v5.10.1, v4.4.3	Nicht-Uint8Array-typisierte Arrays werden jetzt korrekt behandelt.
v0.1.21	Hinzugefügt in: v0.1.21

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

Strenger Assertionsmodus

Ein Alias von assert.notDeepStrictEqual().

Legacy-Assertionsmodus

[Stabil: 3 - Legacy]

Stabil: 3 Stabilität: 3 - Legacy: Verwenden Sie stattdessen assert.notDeepStrictEqual().

Testet auf beliebige tiefe Ungleichheit. Gegenteil von assert.deepEqual().

ESM

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

CJS

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

Wenn die Werte tief gleich sind, wird ein AssertionError mit einer Eigenschaft message ausgelöst, die auf den Wert des Parameters message gesetzt ist. Ist der Parameter message undefiniert, wird eine Standardfehlermeldung zugewiesen. Ist der Parameter message eine Instanz eines Error, wird dieser anstelle des AssertionError ausgelöst.

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

[Historie]

Version	Änderungen
v9.0.0	-0 und +0 werden nicht mehr als gleich betrachtet.
v9.0.0	NaN wird jetzt mit dem SameValueZero-Vergleich verglichen.
v9.0.0	Die Namen und Meldungen von Error werden jetzt korrekt verglichen.
v8.0.0	Der Inhalt von Set und Map wird ebenfalls verglichen.
v6.1.0	Objekte mit zirkulären Referenzen können jetzt als Eingaben verwendet werden.
v6.4.0, v4.7.1	Typisierte Array-Abschnitte werden jetzt korrekt behandelt.
v5.10.1, v4.4.3	Nicht-Uint8Array-typisierte Arrays werden korrekt behandelt.
v1.2.0	Hinzugefügt in: v1.2.0

• actual <beliebig>
• expected <beliebig>
• message <string> | <Error>

Testet auf tiefe strikte Ungleichheit. Das Gegenteil von assert.deepStrictEqual().

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

Wenn die Werte tief und strikt gleich sind, wird ein AssertionError mit einer message-Eigenschaft geworfen, die auf den Wert des message-Parameters gesetzt ist. Wenn der message-Parameter undefiniert ist, wird eine Standardfehlermeldung zugewiesen. Wenn der message-Parameter eine Instanz eines Error ist, wird dieser anstelle des AssertionError geworfen.

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

[Historie]

Version	Änderungen
v16.0.0, v14.18.0	Im Legacy-Assertion-Modus wurde der Status von Veraltet auf Legacy geändert.
v14.0.0	NaN wird jetzt als identisch behandelt, wenn beide Seiten NaN sind.
v0.1.21	Hinzugefügt in: v0.1.21

• actual <beliebig>
• expected <beliebig>
• message <string> | <Error>

Strikter Assertionsmodus

Ein Alias von assert.notStrictEqual().

Legacy-Assertionsmodus

[Stabil: 3 - Legacy]

Stabil: 3 Stabilität: 3 - Legacy: Verwenden Sie stattdessen assert.notStrictEqual().

Testet die oberflächliche, erzwungene Ungleichheit mit dem !=-Operator. NaN wird speziell behandelt und als identisch betrachtet, wenn beide Seiten NaN sind.

ESM

import assert from 'node:assert'

assert.notEqual(1, 2)
// OK

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

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

CJS

const assert = require('node:assert')

assert.notEqual(1, 2)
// OK

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

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

Wenn die Werte gleich sind, wird ein AssertionError mit einer message-Eigenschaft geworfen, die auf den Wert des message-Parameters gesetzt ist. Wenn der message-Parameter undefiniert ist, wird eine Standardfehlermeldung zugewiesen. Wenn der message-Parameter eine Instanz eines Error ist, wird dieser anstelle des AssertionError geworfen.

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

[Versionsgeschichte]

Version	Änderungen
v10.0.0	Der verwendete Vergleich wurde von Strenger Gleichheit auf Object.is() geändert.
v0.1.21	Hinzugefügt in: v0.1.21

• actual <beliebig>
• expected <beliebig>
• message <string> | <Error>

Testet die strikte Ungleichheit zwischen den Parametern actual und expected, wie durch Object.is() bestimmt.

ESM

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

CJS

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

Wenn die Werte streng gleich sind, wird ein AssertionError mit einer message-Eigenschaft ausgelöst, die auf den Wert des message-Parameters gesetzt ist. Wenn der message-Parameter undefiniert ist, wird eine Standardfehlermeldung zugewiesen. Wenn der message-Parameter eine Instanz eines Error ist, wird dieser anstelle des AssertionError ausgelöst.

assert.ok(value[, message])

[Versionsgeschichte]

Version	Änderungen
v10.0.0	assert.ok() (ohne Argumente) verwendet jetzt eine vordefinierte Fehlermeldung.
v0.1.21	Hinzugefügt in: v0.1.21

• value <beliebig>
• message <string> | <Error>

Testet, ob value wahrheitsgemäß ist. Es ist äquivalent zu assert.equal(!!value, true, message).

Wenn value nicht wahrheitsgemäß ist, wird ein AssertionError mit einer message-Eigenschaft ausgelöst, die auf den Wert des message-Parameters gesetzt ist. Wenn der message-Parameter undefined ist, wird eine Standardfehlermeldung zugewiesen. Wenn der message-Parameter eine Instanz eines Error ist, wird dieser anstelle des AssertionError ausgelöst. Wenn überhaupt keine Argumente übergeben werden, wird message auf den String: 'No value argument passed to assert.ok()' gesetzt.

Beachten Sie, dass im repl die Fehlermeldung anders ist als die in einer Datei ausgelöste! Weitere Details finden Sie unten.

ESM

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 der repl:
assert.ok(typeof 123 === 'string')
// AssertionError: false == true

// In einer Datei (z.B. 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)

CJS

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 der repl:
assert.ok(typeof 123 === 'string')
// AssertionError: false == true

// In einer Datei (z.B. 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)

ESM

import assert from 'node:assert/strict'

// Die Verwendung von `assert()` funktioniert genauso:
assert(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)

CJS

const assert = require('node:assert')

// Die Verwendung von `assert()` funktioniert genauso:
assert(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)

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

Hinzugefügt in: v10.0.0

• asyncFn <Function> | <Promise>
• error <RegExp> | <Function> | <Object> | <Error>
• message <string>

Wartet auf das asyncFn-Promise oder, falls asyncFn eine Funktion ist, ruft die Funktion sofort auf und wartet auf die Vervollständigung des zurückgegebenen Promises. Anschließend wird geprüft, ob das Promise abgelehnt wurde.

Wenn asyncFn eine Funktion ist und synchron einen Fehler auslöst, 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 Fehlerhandler übersprungen.

Abgesehen von der asynchronen Natur, um auf die Fertigstellung zu warten, verhält sich die Funktion identisch zu assert.throws().

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

Falls angegeben, ist message die Meldung, die von AssertionError bereitgestellt wird, wenn asyncFn nicht abgelehnt wird.

ESM

import assert from 'node:assert/strict'

await assert.rejects(
  async () => {
    throw new TypeError('Falscher Wert')
  },
  {
    name: 'TypeError',
    message: 'Falscher Wert',
  }
)

CJS

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

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

ESM

import assert from 'node:assert/strict'

await assert.rejects(
  async () => {
    throw new TypeError('Falscher Wert')
  },
  err => {
    assert.strictEqual(err.name, 'TypeError')
    assert.strictEqual(err.message, 'Falscher Wert')
    return true
  }
)

CJS

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

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

ESM

import assert from 'node:assert/strict'

assert.rejects(Promise.reject(new Error('Falscher Wert')), Error).then(() => {
  // ...
})

CJS

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

assert.rejects(Promise.reject(new Error('Falscher Wert')), Error).then(() => {
  // ...
})

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

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

[Historie]

Version	Änderungen
v10.0.0	Der verwendete Vergleich wurde von Strenger Gleichheit zu Object.is() geändert.
v0.1.21	Hinzugefügt in: v0.1.21

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

Testet die strikte Gleichheit zwischen den Parametern actual und expected, wie von Object.is() bestimmt.

ESM

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

CJS

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

Wenn die Werte nicht strikt gleich sind, wird ein AssertionError mit einer message-Eigenschaft geworfen, die auf den Wert des message-Parameters gesetzt ist. Wenn der message-Parameter undefiniert ist, wird eine Standardfehlermeldung zugewiesen. Wenn der message-Parameter eine Instanz eines Error ist, wird dieser anstelle des AssertionError geworfen.

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

[Verlauf]

Version	Änderungen
v10.2.0	Der Parameter error kann nun auch ein Objekt mit regulären Ausdrücken sein.
v9.9.0	Der Parameter error kann nun auch ein Objekt sein.
v4.2.0	Der Parameter error kann nun auch eine Arrow-Funktion sein.
v0.1.21	Hinzugefügt in: v0.1.21

• fn <Funktion>
• error <RegExp> | <Funktion> | <Objekt> | <Error>
• message <String>

Erwartet, dass die Funktion fn einen Fehler auslöst.

Falls angegeben, kann error eine Klasse, RegExp, eine Validierungsfunktion, ein Validierungsobjekt, dessen jede Eigenschaft auf strikte tiefe Gleichheit geprüft wird, oder eine Fehlerinstanz sein, wobei 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 gegen eine Zeichenfolgeneigenschaft validiert wird. Siehe unten für Beispiele.

Falls angegeben, wird message an die von AssertionError bereitgestellte Nachricht angehängt, falls der Aufruf von fn keinen Fehler auslöst oder die Fehlervalidierung fehlschlägt.

Benutzerdefiniertes Validierungsobjekt/Fehlerinstanz:

ESM

import assert from 'node:assert/strict'

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

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Falscher Wert',
    info: {
      nested: true,
      baz: 'text',
    },
    // Es werden nur Eigenschaften des Validierungsobjekts geprüft.
    // Bei verschachtelten Objekten müssen alle Eigenschaften vorhanden sein. Andernfalls
    // schlägt die Validierung fehl.
  }
)

// Verwendung regulärer Ausdrücke zur Validierung von Fehlereigenschaften:
assert.throws(
  () => {
    throw err
  },
  {
    // Die Eigenschaften `name` und `message` sind Zeichenketten und die Verwendung regulärer
    // Ausdrücke dafür wird gegen die Zeichenkette abgeglichen. Bei Fehlern wird ein
    // Fehler ausgegeben.
    name: /^TypeError$/,
    message: /Falsch/,
    foo: 'bar',
    info: {
      nested: true,
      // Es ist nicht möglich, reguläre Ausdrücke für verschachtelte Eigenschaften zu verwenden!
      baz: 'text',
    },
    // Die Eigenschaft `reg` enthält einen regulären Ausdruck und nur wenn das
    // Validierungsobjekt einen identischen regulären Ausdruck enthält, wird es
    // erfolgreich sein.
    reg: /abc/i,
  }
)

// Fehlschlag aufgrund der unterschiedlichen Eigenschaften `message` und `name`:
assert.throws(
  () => {
    const otherErr = new Error('Nicht gefunden')
    // Kopiere alle aufzählbaren Eigenschaften von `err` nach `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // Die Eigenschaften `message` und `name` des Fehlers werden auch geprüft, wenn ein
  // Fehler als Validierungsobjekt verwendet wird.
  err
)

CJS

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

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

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Falscher Wert',
    info: {
      nested: true,
      baz: 'text',
    },
    // Es werden nur Eigenschaften des Validierungsobjekts geprüft.
    // Bei verschachtelten Objekten müssen alle Eigenschaften vorhanden sein. Andernfalls
    // schlägt die Validierung fehl.
  }
)

// Verwendung regulärer Ausdrücke zur Validierung von Fehlereigenschaften:
assert.throws(
  () => {
    throw err
  },
  {
    // Die Eigenschaften `name` und `message` sind Zeichenketten und die Verwendung regulärer
    // Ausdrücke dafür wird gegen die Zeichenkette abgeglichen. Bei Fehlern wird ein
    // Fehler ausgegeben.
    name: /^TypeError$/,
    message: /Falsch/,
    foo: 'bar',
    info: {
      nested: true,
      // Es ist nicht möglich, reguläre Ausdrücke für verschachtelte Eigenschaften zu verwenden!
      baz: 'text',
    },
    // Die Eigenschaft `reg` enthält einen regulären Ausdruck und nur wenn das
    // Validierungsobjekt einen identischen regulären Ausdruck enthält, wird es
    // erfolgreich sein.
    reg: /abc/i,
  }
)

// Fehlschlag aufgrund der unterschiedlichen Eigenschaften `message` und `name`:
assert.throws(
  () => {
    const otherErr = new Error('Nicht gefunden')
    // Kopiere alle aufzählbaren Eigenschaften von `err` nach `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // Die Eigenschaften `message` und `name` des Fehlers werden auch geprüft, wenn ein
  // Fehler als Validierungsobjekt verwendet wird.
  err
)

Instanzüberprüfung mit Konstruktor:

ESM

import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Falscher Wert')
}, Error)

CJS

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

assert.throws(() => {
  throw new Error('Falscher Wert')
}, Error)

Fehlermeldung mit RegExp validieren:

Die Verwendung eines regulären Ausdrucks führt .toString auf dem Fehlerobjekt aus und enthält daher auch den Fehlernamen.

ESM

import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Falscher Wert')
}, /^Error: Falscher Wert$/)

CJS

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

assert.throws(() => {
  throw new Error('Falscher Wert')
}, /^Error: Falscher Wert$/)

Benutzerdefinierte Fehlervalidierung:

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

ESM

import assert from 'node:assert/strict'

assert.throws(
  () => {
    throw new Error('Falscher Wert')
  },
  err => {
    assert(err instanceof Error)
    assert(/Wert/.test(err))
    // Vermeiden Sie die Rückgabe von etwas anderem als `true` aus Validierungsfunktionen.
    // Andernfalls ist nicht klar, welcher Teil der Validierung fehlgeschlagen ist. Stattdessen,
    // geben Sie einen Fehler über die spezifische Validierung aus, die fehlgeschlagen ist (wie in diesem
    // Beispiel) und fügen Sie diesem Fehler so viele hilfreiche Debugging-Informationen wie
    // möglich hinzu.
    return true
  },
  'unerwarteter Fehler'
)

CJS

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

assert.throws(
  () => {
    throw new Error('Falscher Wert')
  },
  err => {
    assert(err instanceof Error)
    assert(/Wert/.test(err))
    // Vermeiden Sie die Rückgabe von etwas anderem als `true` aus Validierungsfunktionen.
    // Andernfalls ist nicht klar, welcher Teil der Validierung fehlgeschlagen ist. Stattdessen,
    // geben Sie einen Fehler über die spezifische Validierung aus, die fehlgeschlagen ist (wie in diesem
    // Beispiel) und fügen Sie diesem Fehler so viele hilfreiche Debugging-Informationen wie
    // möglich hinzu.
    return true
  },
  'unerwarteter Fehler'
)

error kann kein String sein. Wenn ein String als zweites Argument angegeben wird, wird angenommen, dass error ausgelassen wurde und der String stattdessen für message verwendet wird. Dies kann zu leicht zu übersehenden Fehlern führen. Die Verwendung der gleichen Nachricht wie die ausgegebene Fehlermeldung führt zu einem ERR_AMBIGUOUS_ARGUMENT-Fehler. Bitte lesen Sie das folgende Beispiel sorgfältig durch, wenn ein String als zweites Argument in Betracht gezogen wird:

ESM

import assert from 'node:assert/strict'

function throwingFirst() {
  throw new Error('Erster')
}

function throwingSecond() {
  throw new Error('Zweiter')
}

function notThrowing() {}

// Das zweite Argument ist ein String und die Eingabefunktion hat einen Error geworfen.
// Der erste Fall wird nicht geworfen, da er nicht mit der Fehlermeldung übereinstimmt,
// die von der Eingabefunktion geworfen wurde!
assert.throws(throwingFirst, 'Zweiter')
// Im nächsten Beispiel hat die Nachricht keinen Vorteil gegenüber der Nachricht aus dem
// Fehler und da nicht klar ist, ob der Benutzer tatsächlich gegen die Fehlermeldung prüfen wollte,
// wirft Node.js einen `ERR_AMBIGUOUS_ARGUMENT`-Fehler.
assert.throws(throwingSecond, 'Zweiter')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// Der String wird nur (als Nachricht) verwendet, falls die Funktion keinen Fehler wirft:
assert.throws(notThrowing, 'Zweiter')
// AssertionError [ERR_ASSERTION]: Fehlende erwartete Ausnahme: Zweiter

// Wenn beabsichtigt war, die Fehlermeldung abzugleichen, tun Sie dies stattdessen:
// Es wird nichts geworfen, da die Fehlermeldungen übereinstimmen.
assert.throws(throwingSecond, /Zweiter$/)

// Wenn die Fehlermeldung nicht übereinstimmt, wird ein AssertionError geworfen.
assert.throws(throwingFirst, /Zweiter$/)
// AssertionError [ERR_ASSERTION]

CJS

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

function throwingFirst() {
  throw new Error('Erster')
}

function throwingSecond() {
  throw new Error('Zweiter')
}

function notThrowing() {}

// Das zweite Argument ist ein String und die Eingabefunktion hat einen Error geworfen.
// Der erste Fall wird nicht geworfen, da er nicht mit der Fehlermeldung übereinstimmt,
// die von der Eingabefunktion geworfen wurde!
assert.throws(throwingFirst, 'Zweiter')
// Im nächsten Beispiel hat die Nachricht keinen Vorteil gegenüber der Nachricht aus dem
// Fehler und da nicht klar ist, ob der Benutzer tatsächlich gegen die Fehlermeldung prüfen wollte,
// wirft Node.js einen `ERR_AMBIGUOUS_ARGUMENT`-Fehler.
assert.throws(throwingSecond, 'Zweiter')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// Der String wird nur (als Nachricht) verwendet, falls die Funktion keinen Fehler wirft:
assert.throws(notThrowing, 'Zweiter')
// AssertionError [ERR_ASSERTION]: Fehlende erwartete Ausnahme: Zweiter

// Wenn beabsichtigt war, die Fehlermeldung abzugleichen, tun Sie dies stattdessen:
// Es wird nichts geworfen, da die Fehlermeldungen übereinstimmen.
assert.throws(throwingSecond, /Zweiter$/)

// Wenn die Fehlermeldung nicht übereinstimmt, wird ein AssertionError geworfen.
assert.throws(throwingFirst, /Zweiter$/)
// AssertionError [ERR_ASSERTION]

Aufgrund der verwirrenden und fehleranfälligen Schreibweise sollte ein String als zweites Argument vermieden werden.

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

Hinzugefügt in: v23.4.0

[Stabil: 1 - Experimentell]

Stabil: 1 Stabilität: 1.0 - Frühzeitige Entwicklung

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

assert.partialDeepStrictEqual() Prüft die Äquivalenz zwischen den Parametern actual und expected durch einen tiefen Vergleich. Dabei wird sichergestellt, dass alle Eigenschaften im Parameter expected im Parameter actual mit äquivalenten Werten vorhanden sind, wobei Typumwandlungen nicht zulässig sind. Der Hauptunterschied zu assert.deepStrictEqual() besteht darin, dass assert.partialDeepStrictEqual() nicht erfordert, dass alle Eigenschaften im Parameter actual im Parameter expected vorhanden sind. Diese Methode sollte immer die gleichen Testfälle wie assert.deepStrictEqual() bestehen und sich als Obermenge davon verhalten.

ESM

import assert from 'node:assert'

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

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

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

assert.partialDeepStrictEqual(new Set(['value1', 'value2']), new Set(['value1', 'value2']))
// OK

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

assert.partialDeepStrictEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]))
// OK

assert.partialDeepStrictEqual(/abc/, /abc/)
// OK

assert.partialDeepStrictEqual([{ a: 5 }, { b: 5 }], [{ a: 5 }])
// OK

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

assert.partialDeepStrictEqual(new Date(0), new Date(0))
// OK

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

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

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

CJS

const assert = require('node:assert')

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

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

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

assert.partialDeepStrictEqual([{ a: 5 }, { b: 5 }], [{ a: 5 }])
// OK

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

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

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

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