Assert

assert 模块提供了一系列的断言测试函数，设计这些辅助函数的初衷是服务于 Node.js 自身的开发。当然，开发者可以通过 require('assert') 将其应用到第三方模块的开发中。不过，assert 模块并不是一个测试框架，不建议将其用作通用的断言库。

assert 模块当前的 API 已处于锁定状态，这意味着该模块将不再轻易新增或修改 API。

assert(value[, message])

等同于 assert.ok():

const assert = require('assert');

assert(true);
// OK
assert(1);
// OK
assert(false);
// throws "AssertionError: false == true"
assert(0);
// throws "AssertionError: 0 == true"
assert(false, 'it\'s false');
// throws "AssertionError: it's false"

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

比较参数 actual 和 expected 是否深度相等。对于参数中的原始值（primitive value）使用 == 进行比较。

deepEqual() 只会遍历比较对象自身可枚举的属性，不会比较对象的原型、symbol 和不可枚举的属性，所以在某些情况下结果可能会出人意料。比如在下面的示例中就不会抛出 AssertionError，这是因为 Error 对象的属性是不可枚举的：

// WARNING: This does not throw an AssertionError!
assert.deepEqual(Error('a'), Error('b'));

方法名中的 Deep 一词意指会对传入的两个对象进行深度比较，包括对对象子级可枚举属性的比较：

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, object is equal to itself

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

assert.deepEqual(obj1, obj3);
// OK, objects are equal

assert.deepEqual(obj1, obj4);
// AssertionError: { a: { b: 1 } } deepEqual {}
// 原型继承而来的属性不计入比较范围

如果 actual 和 expected 不相等，则抛出 AssertionError 错误和 message 错误信息。如果未定义 message 参数，Node.js 会提供默认的错误信息。

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

assert.deepStrictEqual() 与 assert.deepEqual() 存在两点不同，一是使用 === 判断原始值是否相等，二是会比较 actual 和 expected 的原型对象是否严格相等（即指向同一内存地址的原型对象）：

const assert = require('assert');

assert.deepEqual({a:1}, {a:'1'});
// OK, because 1 == '1'

assert.deepStrictEqual({a:1}, {a:'1'});
// AssertionError: { a: 1 } deepStrictEqual { a: '1' }
// because 1 !== '1' using strict equality

如果 actual 和 expected 不相等，则抛出 AssertionError 错误和 message 错误信息。如果未定义 message 参数，Node.js 会提供默认的错误信息。

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

assert.doesNotThrow() 期望传入的 block 函数不会抛出错误，更多信息请查看 assert.thorws()。

执行 assert.doesNotThrow() 的同时会立即执行 block 函数。

如果 block 函数抛出了错误，且错误类型与 error 参数指定的类型相符，就会抛出 AssertionError 错误；如果 block 函数抛出的错误类型与 error 参数指定的类型不符，或者未传入可选参数 error，则错误会被抛出给调用者（caller）。

在下面的示例中，由于传入的 error 参数为 SyntaxError 与 block 函数的错误不匹配，所以会抛出 block 函数产生的 TypeError：

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

在下面的示例中，error 参数指定的错误与 block 函数抛出的错误匹配，所以抛出 AssertionError：

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

如果提供了可选参数 message，那么该字符串会被添加到 AssertionError 信息之后：

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

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

使用 == 比较 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 } }

如果 actual 和 expected 不相等，则抛出 AssertionError 错误和 message 错误信息。如果未定义 message 参数，Node.js 会提供默认的错误信息。

assert.fail(actual, expected, message, operator)

抛出 AssertionError 错误和 message 错误信息，如果 message 为假值（falsy），则系统自动生成格式为 actual #{operator} expected 的错误信息：

const assert = require('assert');

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

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

assert.ifError(value)

如果 value 为真值（truthy），则抛出 value，这对于测试回调函数中的 error 参数很有用：

const assert = require('assert');

assert.ifError(0);
// OK
assert.ifError(1);
// Throws 1
assert.ifError('error');
// Throws 'error'
assert.ifError(new Error());
// Throws Error

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

与 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, obj1 and obj2 are not deeply equal

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

assert.notDeepEqual(obj1, obj4);
// OK, obj1 and obj2 are not deeply equal

如果 actual 和 expected 深度相等，则抛出 AssertionError 错误和 message 错误信息。如果未定义 message 参数，Node.js 会提供默认的错误信息。

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

与 assert.notDeepStrictEqual() 的功能相反：

const assert = require('assert');

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

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

如果 actual 和 expected 深度严格相等，则抛出 AssertionError 错误和 message 错误信息。如果未定义 message 参数，Node.js 会提供默认的错误信息。

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

使用 != 比较 actual 参数和 expected 参数是否不相等：

const assert = require('assert');

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

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

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

如果 actual 和 expected 相等，则抛出 AssertionError 错误和 message 错误信息。如果未定义 message 参数，Node.js 会提供默认的错误信息。

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

使用 !== 比较 actual 参数和 expected 参数是否不严格相等：

const assert = require('assert');

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

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

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

如果 actual 和 expected 严格相等，则抛出 AssertionError 错误和 message 错误信息。如果未定义 message 参数，Node.js 会提供默认的错误信息。

assert.ok(value[, message])

检验参数 value 是否为真值（truthy），等同于 assert.equal(!!value, true, message):

const assert = require('assert');

assert.ok(true);
// OK
assert.ok(1);
// OK
assert.ok(false);
// throws "AssertionError: false == true"
assert.ok(0);
// throws "AssertionError: 0 == true"
assert.ok(false, 'it\'s false');
// throws "AssertionError: it's false"

如果 value 不是真值，则抛出 AssertionError 错误和 message 错误信息。如果未定义 message 参数，Node.js 会提供默认的错误信息。

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

使用 === 比较 actual 参数和 expected 参数是否严格相等：

const assert = require('assert');

assert.strictEqual(1, 2);
// AssertionError: 1 === 2

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

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

如果 actual 和 expected 不严格相等，则抛出 AssertionError 错误和 message 错误信息。如果未定义 message 参数，Node.js 会提供默认的错误信息。

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

assert.throws() 期望传入的 block 函数会抛出错误（译者注：如果 block 函数抛出错误，assert.throws() 无返回值，表示正常；如果未抛出错误，则 assert.throws() 抛出 AssertionError 错误），可选参数 error 可以是构造函数、正则表达式和自定义的检验函数。

使用构造函数校验错误实例：

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

使用正则表达式校验错误信息：

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

使用自定义函数校验错误实例和错误信息：

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  function(err) {
    if ( (err instanceof Error) && /value/.test(err) ) {
      return true;
    }
  },
  'unexpected error'
);

注意，error 参数不能是字符串。如果该参数是字符串，则会被识别为 message 参数继而导致错误的结果，这是非常容易被忽略的错误用法：

// THIS IS A MISTAKE! DO NOT DO THIS!
assert.throws(myFunction, 'missing foo', 'did not throw with expected message');

// Do this instead.
assert.throws(myFunction, /missing foo/, 'did not throw with expected message');