node.js官方文档解析 01

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（信息）