assert模块提供了断言测试的函数，用于测试不变式
有strict和legacy两种模式，建议只使用strict模式
assert.AssertionError类
error的一个子类，表明断言的失败。assert模块跑出的所有错误都是AssertionError类的实例
strict模式
当使用strict模式时，任何assert函数都会使用严格函数模式的等式，所以assert.deepEqual()会等同于assert.deepStrictEqual()
除此以外，涉及对象的错误信息会产生一个错误差异比较，而不是展示对方的对象，legacy模式则不会这样
assert(value[,message])
ssert.ok() 的别名。
assert.deepEqual(actual,expected[,message])
strict 模式
assert.deepStrictEqual() 的别名。
If the values are not equal, an AssertionError is thrown with a message property set equal to the value of the message parameter. If the message parameter is undefined, a default error message is assigned. If the message parameter is an instance of an Error then it will be thrown instead of the AssertionError.
如果值不相等，则会抛出一个AssertionError，该消息属性集等于消息参数的值。如果消息参数未定义，则指定一个默认的错误消息。如果消息参数是一个错误的实例，那么它将被抛出而不是AssertionError。
assert.deepStrictEqual(actual,expected[,message])
测试 actual 参数与 expected 参数是否深度相等。 深度相等意味着子对象中可枚举的自身属性也会按以下规则递归地比较
比较的详细说明
原始值运用 SameValue比较法进行比较，使用 Object.is() 函数。
对象的类型标签应该相同。
对象的原型使用全等运算符比较。
只比较可枚举的自身属性。
Error 的名称与信息也会比较，即使不是可枚举的属性。
可枚举的自身 Symbol 属性也会比较。
对象封装器 会同时比较对象与解封装后的值。
Object 属性的比较是无序的。
Map 键名与 Set 子项的比较是无序的。
当两边的值不相同或遇到循环引用时，递归会停止。
WeakMap 与 WeakSet 的比较不依赖于它们的值。
assert.doesNotReject(block[, error][, message])
等待 block 的 promise 完成，如果 block 是一个函数，则立即调用该函数并等待返回的 promise 完成，然后检查 promise 是否被 reject。
如果 block 是一个函数且同步地抛出一个错误，则 assert.doesNotReject() 会返回一个被 reject 的 Promise 并传入该错误。 如果该函数没有返回一个 promise，则 assert.doesNotReject() 会返回一个被 reject 的 Promise 并传入 ERR_INVALID_RETURN_VALUE 错误。 以上两种情况都会跳过错误处理函数。
error 可以是 Class、RegExp 或校验函数
assert.doesNotThrow(block[, error][, message])
断言 block 函数不会抛出错误。
当 assert.doesNotThrow() 被调用时，它会立即调用 block 函数。
如果抛出错误且错误类型与 error 参数指定的相同，则抛出 AssertionError。 如果错误类型不相同，或 error 参数为 undefined，则抛出错误。
error 可以是 Class、RegExp 或校验函数。
assert.equal(actual,expected[,message])
strict 模式
assert.strictEqual() 的别名
如果值不相等，则用与消息参数的值相等的消息属性集抛出断言错误。如果消息参数未定义，则分配默认错误消息。如果消息参数是错误的实例，那么它将被抛出而不是断言错误。
assert.fail([message])
抛出 AssertionError，并带上提供的错误信息或默认的错误信息。 如果 message 参数是 Error 的实例，则会抛出它而不是 AssertionError
assert.fail(actual,expected[,message[, operator[,stackStartFunction]]])
如果消息是伪造的，则将错误消息设置为所提供的操作符所分离的实际值和期望值。如果只提供两个实际的和预期的参数，操作员将默认为“！”=。如果消息被提供为第三个参数，它将被用作错误消息，其他参数将作为抛出对象上的属性存储。如果提供了StActStaskFufft，则该函数之上的所有堆栈帧将从SttTrace中删除（参见Error .CoprTestStAc迹）。如果未给出参数，则将使用默认消息失败。
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
在最后三种情况下，实际的、预期的和操作员对错误消息没有影响。StActStaskFor用于截断异常STACKTrace:
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)
如果 value 不为 undefined 或 null，则抛出 value。 可用于测试回调函数的 error 参数。 堆栈踪迹会包含传入 ifError() 的错误的所有帧，包括潜在的 ifError() 自身新增的帧。
const assert = require('assert').strict;
assert.ifError(null);
// 通过。
assert.ifError(0);
// 抛出 AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('错误信息');
// 抛出 AssertionError [ERR_ASSERTION]: ifError got unwanted exception: '错误信息'
assert.ifError(new Error());
// 抛出 AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error
// 添加一些错误帧。
let err;
(function errorFrame() {
err = new Error('错误信息');
})();
(function ifErrorFrame() {
assert.ifError(err);
})();
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 错误信息
// at ifErrorFrame
// at errorFrame
assert.notDeepEqual(actual,expected[,message])
任何深度不等式的检验。与Advest.DeqQualQualor相反。
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
如果值是深度相等的，则抛出一个断言错误，其消息属性集等于消息参数的值。如果消息参数未定义，则分配默认错误消息。如果消息参数是错误的实例，那么它将被抛出而不是断言错误。
assert.notDeepStrictEqual(actual,expected[,message])
测试 actual 参数与 expected 参数是否不深度全等。 与 assert.deepStrictEqual() 相反
const assert = require('assert').strict;
assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// 测试通过。
如果两个值深度全等，则抛出一个带有 message 属性的 AssertionError，其中 message 属性的值等于传入的 message 参数的值。 如果 message 参数为 undefined，则赋予默认的错误信息。 如果 message 参数是 Error 的实例，则会抛出它而不是 AssertionError。
assert.notEqual(actual,expected[,message])
测试浅、强制不等式与抽象相等的比较!=
const assert = require('assert');
assert.notEqual(1, 2);
// OK
assert.notEqual(1, 1);
// AssertionError: 1 != 1
assert.notEqual(1, '1');
// AssertionError: 1 != '1'
如果值相等，则用与消息参数的值相等的消息属性集抛出断言错误。如果消息参数未定义，则分配默认错误消息。如果消息参数是错误的实例，那么它将被抛出而不是断言错误。
assert.notStrictEqual(actual,expected[,message])
使用 SameValue比较法测试 actual 参数与 expected 参数是否不全等
const assert = require('assert').strict;
assert.notStrictEqual(1, 2);
// 测试通过。
assert.notStrictEqual(1, 1);
// 抛出 AssertionError [ERR_ASSERTION]: Identical input passed to notStrictEqual: 1
assert.notStrictEqual(1, '1');
// 测试通过。
如果两个值全等，则抛出一个带有 message 属性的 AssertionError，其中 message 属性的值等于传入的 message 参数的值。 如果 message 参数为 undefined，则赋予默认的错误信息。 如果 message 参数是 Error 的实例，则会抛出它而不是 AssertionError。
assert.ok(vaule[,message])
测试 value 是否为真值。 相当于 assert.equal(!!value, true, message)。
如果 value 不为真值，则抛出一个带有 message 属性的 AssertionError，其中 message 属性的值等于传入的 message 参数的值。 如果 message 参数为 undefined，则赋予默认的错误信息。 如果 message 参数是 Error 的实例，则会抛出它而不是 AssertionError。 如果没有传入参数，则 message 会被设为字符串 'No value argument passed to `assert.ok()`'。
const assert = require('assert').strict;
assert.ok(true);// 测试通过。
assert.ok(1);// 测试通过。
assert.ok();// 抛出 AssertionError: No value argument passed to `assert.ok()`
assert.ok(false, '不是真值');// 抛出 AssertionError: 不是真值
// 在 repl 中：
assert.ok(typeof 123 === 'string');// 抛出 AssertionError: false == true
// 在文件中（例如 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)
// 等同于 `assert()`：
assert(0);// 抛出 AssertionError: The expression evaluated to a falsy value://// assert(0)
assert.rejects(block[,error][,message])
等待 block 的 promise 完成，如果 block 是一个函数，则立即调用该函数并等待返回的 promise 完成，然后检查 promise 是否被 reject。
如果 block 是一个函数且同步地抛出一个错误，则 assert.rejects() 会返回一个被 reject 的 Promise 并传入该错误。 如果该函数没有返回一个 promise，则 assert.rejects() 会返回一个被 reject 的 Promise 并传入 ERR_INVALID_RETURN_VALUE 错误。 以上两种情况都会跳过错误处理函数。
该函数相当于 assert.throws()，除了需要等待完成的异步特性。
error 可以是 Class、RegExp、校验函数、每个属性都会被测试的对象、或每个属性（包括不可枚举的 message 和 name 属性）都会被测试的错误实例。
如果指定了 message，则当 block 没被 reject 时，message 参数会作为 AssertionError 的错误信息。
(async () => {
await assert.rejects(
async () => {
throw new TypeError('错误信息'); },
{
name: 'TypeError',
message: '错误信息'
}
);
})();
assert.rejects(
Promise.reject(new Error('错误信息')),
Error).then(() => {
// ...
});
注意，error 不能是字符串。 如果第二个参数是字符串，则视为不传入 error，且字符串会用于 message。 这可能会造成误解。 如果需要使用字符串作为第二个参数，请仔细阅读 assert.throws() 中的例子。
assert.strictEqual(actual,expected{,message])
使用 SameValue比较法测试 actual 参数与 expected 参数是否全等。
const assert = require('assert').strict;
assert.strictEqual(1, 2);
// 抛出 AssertionError [ERR_ASSERTION]: Input A expected to strictly equal input B:
// + expected - actual
// - 1
// + 2
assert.strictEqual(1, 1);
// 测试通过。
assert.strictEqual(1, '1');
// 抛出 AssertionError [ERR_ASSERTION]: Input A expected to strictly equal input B:
// +
expected - actual
// - 1
// + '1'
如果两个值不全等，则抛出一个带有 message 属性的 AssertionError，其中 message 属性的值等于传入的 message 参数的值。 如果 message 参数为 undefined，则赋予默认的错误信息。 如果 message 参数是 Error 的实例，则会抛出它而不是 AssertionError。
assert.throws(block[,error][,message])
断言 block 函数会抛出错误。
error 可以是 Class、RegExp、校验函数、每个属性都会被测试是否深度全等的校验对象、或每个属性（包括不可枚举的 message 和 name 属性）都会被测试是否深度全等的错误实例。 当使用对象时，可以使用正则表达式来校验字符串属性。 详见下面的例子。
如果指定了 message 参数，则当 block 函数不抛出错误时，message 参数会作为 AssertionError 的错误信息。
例子，error 参数为自定义的校验对象或错误实例：
const err = new TypeError('错误信息');
err.code = 404;
err.foo = 'bar';
err.info = {
nested: true,
baz: 'text'
};
err.reg = /abc/i;
assert.throws(
() => {
throw err;
}, {
name: 'TypeError',
message: '错误信息'
info: {
nested: true,
baz: 'text' }
// 注意，只有校验对象的属性会被测试。
// 使用嵌套的对象必须提供全部属性，否则校验会失败。
});
// 使用正则表达式来校验错误属性：
assert.throws(
() => {
throw err;
},
{
// `name` 和 `message` 属性为字符串，对它们使用正则表达式进行匹配。
// 如果校验失败，则抛出错误。
name: /^TypeError$/,
message: /错误信息/,
foo: 'bar',
info: {
nested: true,
// 嵌套的属性不可以使用正则表达式！
baz: 'text' },
// `reg` 属性包含了一个正则表达式，只有校验对象也包含一个完全相同的正则表达式时，校验才会通过。
reg: /abc/i
});
// 失败，因为 `message` 属性与 `name` 属性不同：
assert.throws(
() => {
const otherErr = new Error('未找到');
otherErr.code = 404;
throw otherErr;
},
err // 会测试 `message`、`name` 和 `code`。
);
例子，error 参数为构造函数：
assert.throws(
() => {
throw new Error('错误信息');
},
Error );
例子，error 参数为 RegExp：
使用正则表达式运行错误对象的 .toString， 且包括错误的名称
assert.throws(
() => {
throw new Error('错误信息');
},
/^Error: 错误信息$/
);
例子，error 参数为自定义函数：
assert.throws(
() => {
throw new Error('错误信息');
}, function(err) {
if ((err instanceof Error) && /错误/.test(err)) {
return true;
}
},
'不是期望的错误' );
注意，error 不能是字符串。 如果第二个参数是字符串，则视为不传入 error，且字符串会用于 message。 这可能会造成误解。 使用与抛出的错误信息相同的信息，会导致 ERR_AMBIGUOUS_ARGUMENT 错误。 如果需要使用字符串作为第二个参数，请仔细阅读下面的例子。
function throwingFirst() {
throw new Error('错误一');
}
function throwingSecond() {
throw new Error('错误二');
}
function notThrowing() {}
// 第二个参数为字符串，且输入函数抛出了错误。
// 第一个例子不会抛出错误，因为它没有匹配到输入函数抛出的错误信息！
assert.throws(throwingFirst, '错误二');
// 第二个例子中，传入的信息接近错误信息，
// 且没有表述清楚用户是否有意匹配错误信息，
// 所以 Node.js 会抛出 `ERR_AMBIGUOUS_ARGUMENT` 错误。
assert.throws(throwingSecond, '错误二');
// 抛出错误：
// TypeError [ERR_AMBIGUOUS_ARGUMENT]
// 当函数没有抛出错误时，字符串可用于错误信息：
assert.throws(notThrowing, '错误二');
// 抛出 AssertionError [ERR_ASSERTION]: Missing expected exception: 错误二
// 如果想要匹配到错误信息，可以如下：
assert.throws(throwingSecond, /错误二$/);
// 没有抛出错误，因为错误信息匹配。
assert.throws(throwingFirst, /错误二$/);
// 抛出错误：
// Error: 错误一
// at throwingFirst (repl:2:9)
鉴于会混淆语句，建议不要使用字符串作为第二个参数。 这可能会导致不易定位的错误。