nodejs断言模板(assert)的使用介绍

断言

稳定性：2-稳定

该assert模块提供了一组用于验证不变量的断言函数。

严格断言模式

历史版	变化
v13.9.0	将“严格模式”更改为“严格断言模式”，并将“传统模式”更改为“传统断言模式”，以避免与更常见的“严格模式”含义混淆。
v9.9.0	将错误差异添加到严格声明模式。
v9.9.0	向断言模块添加了严格的断言模式。
v9.9.0	在v9.9.0中添加在严格声明模式下，非严格方法的行为类似于其相应的严格方法。例如，`assert.deepEqual()`将表现为`assert.deepStrictEqual()`。

在严格声明模式下，对象的错误消息显示差异。在旧式断言模式下，对象的错误消息显示对象，通常将其截断。

要使用严格的断言模式：

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

示例错误差异：

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

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

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

传统断言模式＃

传统断言模式在以下方面使用抽象平等比较：

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

要使用旧式断言模式：

const assert = require('assert');

尽可能使用严格的断言模式。否则，抽象平等比较可能会导致令人惊讶的结果。对于assert.deepEqual()比较规则不严格的，尤其如此：

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

类：assert.AssertionError [src] ＃

扩展：<errors.Error>

指示断言失败。assert模块抛出的所有错误都是AssertionError该类的实例。

`new assert.AssertionError(options)`＃

在v0.1.21中添加

options <对象>
- message （如果提供），则错误消息设置为此值。
- actual <任何>的actual所述误差实例属性。
- expected <任何>的expected所述误差实例属性。
- operator <字符串>的operator所述误差实例属性。
- stackStartFn （如果提供），则生成的堆栈跟踪将忽略此函数之前的帧。

的子类Error表示断言失败。

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

actual 设置actual为方法的参数，例如 assert.strictEqual()。
expected 设置expected为方法的值，例如 assert.strictEqual()。
generatedMessage 指示消息是否是自动生成的（true）。
code 值始终ERR_ASSERTION表示该错误是断言错误。
operator 设置为传入的运算符值。

const assert = require(‘assert’);

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

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

`assert(value[, message])`

在v0.5.9中添加

value 被检查为真实的输入。
message | <错误>

的别名assert.ok()。

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

历史版	变化
v12.0.0	现在已正确比较了类型标签，并且进行了一些较小的比较调整，以使检查不那么令人惊讶。
v9.0.0	该`Error`姓名和消息现在比较正确
v8.0.0	该`Set`和`Map`内容也比较
v6.4.0，v4.7.1	类型化的数组切片现在可以正确处理。
v6.1.0，v4.5.0	具有循环引用的对象现在可以用作输入。
v5.10.1，v4.4.3	`Uint8Array`正确处理非类型数组。
v0.1.21	在v0.1.21中添加

actual <任何>
expected <任何>
message | <错误>

严格断言模式

的别名assert.deepStrictEqual()。

传统断言模式

稳定性：0-不建议使用：assert.deepStrictEqual()改为使用。

测试actual和expected参数之间的深度相等性。考虑assert.deepStrictEqual()改为使用。assert.deepEqual()会有令人惊讶的结果。

深度相等 意味着子对象的可枚举“自身”属性也将通过以下规则进行递归求值。

比较详情＃

将原始值与抽象相等比较（==）进行比较。
对象的类型标签应该相同。
仅考虑可枚举的“自有”属性。
Error 即使名称和消息不是不可枚举的属性，也始终对其进行比较。
将对象包装器作为对象和未包装的值进行比较。
Object 属性进行无序比较。
Map键和Set项目进行无序比较。
当双方不同或双方遇到圆形参考时，递归停止。
实现不测试[[Prototype]]对象。
Symbol 属性不进行比较。
WeakMap而WeakSet比较不依赖于它们的值。

以下示例不会抛出，AssertionError因为抽象平等比较（==）将这些原语视为相等。

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

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

const assert = require('assert');

const obj1 = {
a: {
b: 1
}
};
const obj2 = {
a: {
b: 2
}
};
const obj3 = {
a: {
b: 1
}
};
const obj4 = Object.create(obj1);

assert.deepEqual(obj1, obj1);
// OK

// Values of b are different:
assert.deepEqual(obj1, obj2);
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3);
// OK

// Prototypes are ignored:
assert.deepEqual(obj1, obj4);
// AssertionError: { a: { b: 1 } } deepEqual {}

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

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

历史版	变化
v9.0.0	现在比较了可枚举的符号属性。
v9.0.0	在`NaN`现在使用比较SameValueZero比较。
v8.5.0	该`Error`姓名和消息现在比较正确
v8.0.0	该`Set`和`Map`内容也比较
v6.4.0，v4.7.1	类型化的数组切片现在可以正确处理。
v6.1.0	具有循环引用的对象现在可以用作输入。
v5.10.1，v4.4.3	`Uint8Array`正确处理非类型数组。
v1.2.0	在v1.2.0中添加

actual <任何>
expected <任何>
message | <错误>

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

比较详情＃

原始值是使用比较SameValue比较，通过使用 Object.is()。
对象的类型标签应该相同。
[[Prototype]]使用严格相等比较对对象进行比较。
仅考虑可枚举的“自有”属性。
Error 即使名称和消息不是不可枚举的属性，也始终对其进行比较。
Symbol还比较了可枚举的自身属性。
将对象包装器作为对象和未包装的值进行比较。
Object 属性进行无序比较。
Map键和Set项目进行无序比较。
当双方不同或双方遇到圆形参考时，递归停止。
WeakMap而WeakSet比较不依赖于它们的值。有关更多详细信息，请参见下文。

const assert = require(‘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 of the SameValue comparison

// 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 using the SameValue Comparison:
assert.deepStrictEqual(0, -0);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol();
const symbol2 = Symbol();
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 });
// OK, because it is the same symbol on both objects.

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

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

assert.deepStrictEqual(weakMap1, weakMap2);
// OK, because it is impossible to compare the entries

// Fails because weakMap3 has a property that weakMap1 does not contain:
assert.deepStrictEqual(weakMap1, weakMap3);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// WeakMap {
// + [items unknown]
// - [items unknown],
// - unequal: true
// }

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

在v13.6.0中添加

string
regexp
message | <错误>

稳定性：1-实验

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

此功能目前处于试验阶段，名称可能会更改，或者可能会再次完全删除。

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

assert.doesNotMatch('I will fail', /fail/);
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

assert.doesNotMatch(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.doesNotMatch('I will pass', /different/);
// OK

如果值确实匹配，或者string参数是以外的其他类型
string，AssertionError则将抛出一个message属性设置等于message参数值的。如果message未定义参数，则会分配默认错误消息。如果message参数是的实例，Error则将抛出而不是
AssertionError。

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

在v10.0.0中添加

asyncFn <功能> | <承诺>
error | <功能>
message

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

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

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

如果指定，error可以是一个Class，RegExp或验证功能。请参阅assert.throws()以获取更多详细信息。

除了异步性质等待完成行为与 assert.doesNotThrow()。

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



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

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

历史版	变化
v5.11.0，v4.4.5	`message`现在尊重该参数。
v4.2.0	`error`现在，该参数可以是箭头功能。
v0.1.21	在v0.1.21中添加

fn <功能>
error | <功能>
message

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

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

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

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

如果指定，error可以是一个Class，RegExp或验证功能。请参阅assert.throws()以获取更多详细信息。

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

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

但是，以下内容将导致AssertionError并显示消息“出现不需要的异常…”：

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

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

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

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

在v0.1.21中添加

actual <任何>
expected <任何>
message | <错误>

严格断言模式

的别名assert.strictEqual()。

传统断言模式

稳定性：0-不建议使用：assert.strictEqual()改为使用。

使用“ 抽象相等比较”（）测试actual和expected参数之间的浅强制性相等。==

const assert = require('assert');

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

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

`assert.fail([message])`＃

在v0.1.21中添加

message | <错误> 默认值： 'Failed'

抛出一个AssertionError与所提供的错误消息或默认的错误消息。如果message参数是的实例，Error则将抛出而不是AssertionError。

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

assert.fail();
// AssertionError [ERR_ASSERTION]: Failed

assert.fail('boom');
// AssertionError [ERR_ASSERTION]: boom

assert.fail(new TypeError('need array'));
// TypeError: need array

可以使用assert.fail()两个以上的参数，但不建议使用。有关更多详细信息，请参见下文。

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

历史版	变化
v10.0.0	不建议`assert.fail()`使用多个参数进行调用，并发出警告。
v0.1.21	在v0.1.21中添加

稳定性：0-不推荐使用：改用assert.fail([message])或其他assert函数。

actual <任何>
expected <任何>
message | <错误>
operator 默认值： '!='
stackStartFn <功能> 默认值： assert.fail

如果message是falsy，错误消息被设置为的值actual和
expected通过所提供的分离operator。如果仅提供了两个actual和
expected参数，operator则默认为'!='。如果
message提供作为第三个参数，它将用作错误消息，而其他参数将作为属性存储在抛出的对象上。如果
stackStartFn提供，则该功能之上的所有堆栈框架都将从stacktrace中移除（请参阅参考资料Error.captureStackTrace）。如果未提供任何参数，Failed则将使用默认消息。

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

assert.fail('a', 'b');
// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>');
// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail');
// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>');
// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'));
// TypeError: need array

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

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

function suppressFrame() {
assert.fail('a', 'b', undefined, '!==', suppressFrame);
}
suppressFrame();
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
//     at repl:1:1
//     at ContextifyScript.Script.runInThisContext (vm.js:44:33)
//     ...

`assert.ifError(value)`＃

历史版	变化
v10.0.0	现在不再抛出原始错误，而是将其包装到`AssertionError`包含完整堆栈跟踪的[ ] []中。
v10.0.0	现在值只能是`undefined`或`null`。在对所有虚假值进行相同处理`null`且未抛出之前。
v0.1.97	在v0.1.97中添加

value <任何>

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

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

assert.ifError(null);
// OK
assert.ifError(0);
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('error');
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
assert.ifError(new Error());
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error

// Create some random error frames.
let err;
(function errorFrame() {
err = new Error('test error');
})();

(function ifErrorFrame() {
assert.ifError(err);
})();
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
//     at ifErrorFrame
//     at errorFrame

`assert.match(string, regexp[, message])`＃

在v13.6.0中添加

string
regexp
message | <错误>

稳定性：1-实验

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

此功能目前处于试验阶段，名称可能会更改，或者可能会再次完全删除。

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

assert.match('I will fail', /pass/);
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...

assert.match(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.match('I will pass', /pass/);
// OK

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

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

历史版	变化
v9.0.0	该`Error`姓名和消息现在比较正确
v8.0.0	该`Set`和`Map`内容也比较
v6.4.0，v4.7.1	类型化的数组切片现在可以正确处理。
v6.1.0，v4.5.0	具有循环引用的对象现在可以用作输入。
v5.10.1，v4.4.3	`Uint8Array`正确处理非类型数组。
v0.1.21	在v0.1.21中添加

actual <任何>
expected <任何>
message | <错误>

严格断言模式

的别名assert.notDeepStrictEqual()。

传统断言模式

稳定性：0-不建议使用：assert.notDeepStrictEqual()改为使用。

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

const assert = require('assert');

const obj1 = {
a: {
b: 1
}
};
const obj2 = {
a: {
b: 2
}
};
const obj3 = {
a: {
b: 1
}
};
const obj4 = Object.create(obj1);

assert.notDeepEqual(obj1, obj1);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2);
// OK

assert.notDeepEqual(obj1, obj3);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4);
// OK

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

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

历史版	变化
v9.0.0	该`-0`和`+0`是不相等了。
v9.0.0	在`NaN`现在使用比较SameValueZero比较。
v9.0.0	该`Error`姓名和消息现在比较正确
v8.0.0	该`Set`和`Map`内容也比较
v6.4.0，v4.7.1	类型化的数组切片现在可以正确处理。
v6.1.0	具有循环引用的对象现在可以用作输入。
v5.10.1，v4.4.3	`Uint8Array`正确处理非类型数组。
v1.2.0	在v1.2.0中添加

actual <任何>
expected <任何>
message | <错误>

测试是否存在严格的不平等现象。相反assert.deepStrictEqual()。

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

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

如果值严格相等，AssertionError则抛出一个具有message等于message参数值的属性的属性。如果message未定义参数，则会分配默认错误消息。如果message参数是的实例，Error则将抛出而不是AssertionError。

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

在v0.1.21中添加

actual <任何>
expected <任何>
message | <错误>

严格断言模式

的别名assert.notStrictEqual()。

传统断言模式

稳定性：0-不建议使用：assert.notStrictEqual()改为使用。

使用“ 抽象相等比较” （!=）测试浅的强制性不平等。

const assert = require('assert');

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

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

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

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

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

历史版	变化
v10.0.0	二手比较从严格平等改为 `Object.is()`
v0.1.21	在v0.1.21中添加

actual <任何>
expected <任何>
message | <错误>

测试Same参数比较确定的actual和之间的严格不等式。expected

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

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

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

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

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

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

历史版	变化
v10.0.0	的`assert.ok()`（无参数）现在将使用预定义的错误消息。
v0.1.21	在v0.1.21中添加

value <任何>
message | <错误>

测试是否value真实。等同于 assert.equal(!!value, true, message)。

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

请注意，repl错误消息中的错误消息将与文件中引发的错误消息不同！有关更多详细信息，请参见下文。

const assert = require('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)

// Using `assert()` works the same:
assert(0);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)

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

在v10.0.0中添加

asyncFn <功能> | <承诺>
error | <功能> | <对象> | <错误>
message

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

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

除了异步性质等待完成行为与 assert.throws()。

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

如果指定，message将通过所提供的消息AssertionError ，如果asyncFn没有拒绝。

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



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

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

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

历史版	变化
v10.0.0	二手比较从严格平等改为 `Object.is()`
v0.1.21	在v0.1.21中添加

actual <任何>
expected <任何>
message | <错误>

测试Same参数比较确定的actual和expected参数之间的严格相等性。

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

assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

assert.strictEqual(1, 1);
// OK

assert.strictEqual('Hello foobar', 'Hello World!');
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
//          ^

const apples = 1;
const oranges = 2;
assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

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

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

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

历史版	变化
v10.2.0	该`error`参数现在可以是包含正则表达式的对象。
v9.9.0	该`error`参数现在也可以是一个对象。
v4.2.0	`error`现在，该参数可以是箭头功能。
v0.1.21	在v0.1.21中添加

fn <功能>
error | <功能> | <对象> | <错误>
message

期望函数fn抛出错误。

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

如果指定，则在调用失败或错误验证失败的情况下，message将附加到所提供的消息上。AssertionError``fn

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

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

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

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

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

使用构造函数验证instanceof：

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

使用RegExp以下命令验证错误消息：

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

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

自定义错误验证：

该函数必须返回true以指示已通过所有内部验证。否则将失败并显示AssertionError。

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

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

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]

由于容易出错的符号引起的混淆，请避免将字符串作为第二个参数。

阅读原文

上一篇: npm-scope(scoped packages)范围包

下一篇: mac上解决chrome浏览器跨域问题

server

1.本站所有文章除特殊声明外均为原创，未经允许禁止转载!
2.站内文章如有侵权异议，请与我联系，我将在确实后处理！

liuyonghu.com

刘勇虎的官方网站

nodejs断言模板(assert)的使用介绍

断言

严格断言模式

传统断言模式＃

类：assert.AssertionError [src] ＃

`new assert.AssertionError(options)`＃

`assert(value[, message])`

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

比较详情＃

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

比较详情＃

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

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

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

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

`assert.fail([message])`＃

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

`assert.ifError(value)`＃

`assert.match(string, regexp[, message])`＃

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

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

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

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

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

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

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

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

热门文章

文章标签

liuyonghu.com

nodejs断言模板(assert)的使用介绍

断言

严格断言模式

传统断言模式＃

类：assert.AssertionError [src] ＃

new assert.AssertionError(options)＃

assert(value[, message])

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

比较详情＃

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

比较详情＃

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

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

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

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

assert.fail([message])＃

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

assert.ifError(value)＃

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

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

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

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

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

assert.ok(value[, message])＃

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

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

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

热门文章

文章标签

`new assert.AssertionError(options)`＃

`assert(value[, message])`

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

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

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

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

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

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

`assert.fail([message])`＃

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

`assert.ifError(value)`＃

`assert.match(string, regexp[, message])`＃

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

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

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

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

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

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

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

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