node.js官方文档解析 01—assert 断言

assert-------断言

new assert.AssertionError(options)

Error 的一个子类，表明断言的失败。

options(选项)有下列对象

• message <string> 如果有值，则错误信息会被设为该值。
• actual （实际）<any> 错误实例的 actual 属性会被设为该值。用于 actual 错误输入，例如使用 assert.strictEqual()。
• expected （期望值）<any> 错误实例的 expected 属性会被设为该值。用于 expected 错误输入，例如使用 assert.strictEqual()。
• operator（运算符） <string> 错误实例的 operator 属性会被设为该值。用于表明比较时使用的是哪个操作（或触发错误的是哪个断言函数）。
• stackStartFn <Function> 如果有值，则由提供的函数生成堆栈踪迹。

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

doesNotReject(不能拒结）

• block<Function> | <Promise>（责任）
• error<RegExp> | <Function>
• message<string> | <Error>

error 可以是 Class、RegExp 或校验函数。

assert.doesNotThrow

.doesNotThrow(抛)

• block<Function>
• error<RegExp> | <Function>
• message <string> | <Error>

断言 block 函数不会抛出错误。

//  SyntaxError（语法错误）

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

.equal(相等)

或者 assert.strictEqual().（和上面的意思相同，表示一个别名）

eg：使用抽象的相等比较（==）测试实际和预期参数之间的浅、强制的相等性。

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

.fail(失败)

• message <string> | <Error> 默认为 'Failed'。

抛出 AssertionError，并带上提供的错误信息或默认的错误信息。 如果 message 参数是 Error 的实例，则会抛出它而不是 AssertionError。

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

assert.fail();//没有提供错误信息
// 抛出 AssertionError [ERR_ASSERTION]: Failed

assert.fail('失败');//字符串
// 抛出 AssertionError [ERR_ASSERTION]: 失败

assert.fail(new TypeError('失败'));
// 抛出 TypeError: 失败

　　

assert.ifError(value)

• value（值）<any>

如果 value 不为 undefined 或 null，则抛出 value。可用于测试回调函数的 error 参数。 堆栈踪迹会包含传入 ifError() 的错误的所有帧，包括潜在的 ifError() 自身新增的帧。

//errorFrame（错误帧）

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

assert.ifError(null);//使用了value规则的undefined和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

　//any类型可以赋值任意类型。

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

　　测试 actual 参数与 expected 参数是否不深度全等。 与 assert.deepStrictEqual() 相反。

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

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

actual 参数与 expected 参数是否不全等。

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

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(value[, message])

测试 value 是否为真值。

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

如果 value 不为真值，则抛出一个带有 message 属性的 AssertionError，其中 message 属性的值等于传入的 message 参数的值。 如果 message 参数为 undefined，则赋予默认的错误信息。 如果 message 参数是 Error 的实例，则会抛出它而不是 AssertionError。 如果没有传入参数，则 message 会被设为字符串 'No value argument passed to `assert.ok()`'。

eg:

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

assert.ok(true);
// 测试通过。
assert.ok(1);
// 测试通过。

assert.ok();//如果没有传入参数，则 message 会被设为字符串 'No value argument passed to `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)

//promise：表示异步操作的最终完成（或失败）及其产生的值。
assert.rejects(block[, error][, message])//不懂

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

测试 actual 参数与 expected 参数是否全等。

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

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。

 //nested（嵌套）

//info（信息）