方法和属性

assert(value[, message])

assert.ok() 的别名。

  1. const assert = require('assert');
  3. assert(true);  // OK
  4. assert(1);     // OK
  5. assert(false);
  6.   // throws "AssertionError: false == true"
  7. assert(0);
  8.   // throws "AssertionError: 0 == true"
  9. assert(false, 'it\'s false');
  10.   // throws "AssertionError: it's false"

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

浅测试，使用等于比较运算符（==）来比较 actual 和 expected 参数。

  1. const assert = require('assert');
  3. assert.equal(1, 1);
  4.   // OK, 1 == 1
  5. assert.equal(1, '1');
  6.   // OK, 1 == '1'
  8. assert.equal(1, 2);
  9.   // AssertionError: 1 == 2
  10. assert.equal({a: {b: 1}}, {a: {b: 1}});
  11.   //AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

如果这两个值不相等，将会抛出一个带有 message 属性（等于该 message 参数的值）的 AssertionError。如果 message 参数为 undefined，将会分配一个默认的错误消息。

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

严格相等测试，由全等运算符确定（===）。

  1. const assert = require('assert');
  3. assert.strictEqual(1, 2);
  4.   // AssertionError: 1 === 2
  6. assert.strictEqual(1, 1);
  7.   // OK
  9. assert.strictEqual(1, '1');
  10.   // AssertionError: 1 === '1'

如果这两个值不是严格相等，将会抛出一个带有 message 属性（等于该 message 参数的值）的 AssertionError。如果 message 参数为 undefined，将会分配一个默认的错误消息。

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

浅测试，使用不等于比较运算符（!=）比较。

  1. const assert = require('assert');
  3. assert.notEqual(1, 2);
  4.   // OK
  6. assert.notEqual(1, 1);
  7.   // AssertionError: 1 != 1
  9. assert.notEqual(1, '1');
  10.   // AssertionError: 1 != '1'

如果这两个值相等，将会抛出一个带有 message 属性（等于该 message 参数的值）的 AssertionError。如果 message 参数为 undefined，将会分配一个默认的错误消息。

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

严格不相等测试，由不全等运算符确定（===）。

  1. const assert = require('assert');
  3. assert.notStrictEqual(1, 2);
  4.   // OK
  6. assert.notStrictEqual(1, 1);
  7.   // AssertionError: 1 != 1
  9. assert.notStrictEqual(1, '1');
  10.   // OK

如果这两个值严格相等，将会抛出一个带有 message 属性（等于该 message 参数的值）的 AssertionError。如果 message 参数为 undefined，将会分配一个默认的错误消息。

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

深度比较 actual 和 expected 参数，使用比较运算符（==）比较原始值。

只考虑可枚举的“自身”属性。deepEqual() 的实现不测试对象的原型，连接符号，或不可枚举的属性。这会导致一些潜在的出人意料的结果。例如，下面的例子不会抛出 AssertionError，因为 Error 对象的属性是不可枚举：

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

深度比较意味着子对象的可枚举“自身”的属性也会进行评估：

  1. const assert = require('assert');
  3. const obj1 = {
  4.     a: {
  5.         b: 1
  6.     }
  7. };
  8. const obj2 = {
  9.     a: {
  10.         b: 2
  11.     }
  12. };
  13. const obj3 = {
  14.     a: {
  15.         b: 1
  16.     }
  17. }
  18. const obj4 = Object.create(obj1);
  20. assert.deepEqual(obj1, obj1);
  21. // OK, object is equal to itself
  23. assert.deepEqual(obj1, obj2);
  24. // AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
  25. // values of b are different
  27. assert.deepEqual(obj1, obj3);
  28. // OK, objects are equal
  30. assert.deepEqual(obj1, obj4);
  31. // AssertionError: { a: { b: 1 } } deepEqual {}
  32. // Prototypes are ignored

如果这两个值不相等，将会抛出一个带有 message 属性（等于该 message 参数的值）的 AssertionError。如果 message 参数为 undefined，将会分配一个默认的错误消息。

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

一般情况下等同于 assert.deepEqual()，但有两个例外。首先，原始值是使用全等运算符（===）进行比较。其次，比较的对象包括严格比较他们的原型。

  1. const assert = require('assert');
  3. assert.deepEqual({a:1}, {a:'1'});
  4.   // OK, because 1 == '1'
  6. assert.deepStrictEqual({a:1}, {a:'1'});
  7.   // AssertionError: { a: 1 } deepStrictEqual { a: '1' }
  8.   // because 1 !== '1' using strict equality

如果这两个值不相等，将会抛出一个带有 message 属性（等于该 message 参数的值）的 AssertionError。如果 message 参数为 undefined，将会分配一个默认的错误消息。

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

深度地不相等比较测试，与 assert.deepEqual() 相反。

  1. const assert = require('assert');
  3. const obj1 = {
  4.     a: {
  5.         b: 1
  6.     }
  7. };
  8. const obj2 = {
  9.     a: {
  10.         b: 2
  11.     }
  12. };
  13. const obj3 = {
  14.     a: {
  15.         b: 1
  16.     }
  17. }
  18. const obj4 = Object.create(obj1);
  20. assert.notDeepEqual(obj1, obj1);
  21. // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
  23. assert.notDeepEqual(obj1, obj2);
  24. // OK, obj1 and obj2 are not deeply equal
  26. assert.notDeepEqual(obj1, obj3);
  27. // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
  29. assert.notDeepEqual(obj1, obj4);
  30. // OK, obj1 and obj2 are not deeply equal

如果这两个值深度相等，将会抛出一个带有 message 属性（等于该 message 参数的值）的 AssertionError。如果 message 参数为 undefined，将会分配一个默认的错误消息。

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

深度地严格不相等比较测试，与 assert.deepStrictEqual() 相反。

  1. const assert = require('assert');
  3. assert.notDeepEqual({a:1}, {a:'1'});
  4.   // AssertionError: { a: 1 } notDeepEqual { a: '1' }
  6. assert.notDeepStrictEqual({a:1}, {a:'1'});
  7.   // OK

如果这两个值深度严格相等，将会抛出一个带有 message 属性（等于该 message 参数的值）的 AssertionError。如果 message 参数为 undefined，将会分配一个默认的错误消息。

assert.ok(value[, message])

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

如果 value 不是真值，将会抛出一个带有 message 属性（等于该 message 参数的值）的 AssertionError。如果 message 参数为 undefined，将会分配一个默认的错误消息。

  1. const assert = require('assert');
  3. assert.ok(true);  // OK
  4. assert.ok(1);     // OK
  5. assert.ok(false);
  6.   // throws "AssertionError: false == true"
  7. assert.ok(0);
  8.   // throws "AssertionError: 0 == true"
  9. assert.ok(false, 'it\'s false');
  10.   // throws "AssertionError: it's false"

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

抛出一个 AssertionError。如果 message 是假值，错误信息会被设置为被 operator 分隔在两边 actual 和 expected 的值。否则，该错误信息会是 message 的值。

  1. const assert = require('assert');
  3. assert.fail(1, 2, undefined, '>');
  4.   // AssertionError: 1 > 2
  6. assert.fail(1, 2, 'whoops', '>');
  7.   // AssertionError: whoops

assert.ifError(value)

如果 value 为真值时，抛出 value。当测试在回调函数里的参数 error 时非常有用。

  1. const assert = require('assert');
  3. assert.ifError(0); // OK
  4. assert.ifError(1); // Throws 1
  5. assert.ifError('error') // Throws 'error'
  6. assert.ifError(new Error()); // Throws Error

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

期望 block 函数抛出一个错误。

如果指定 error，它可以是一个构造函数、正则表达式或验证函数。

如果指定 message，如果 block 因为失败而抛出错误，message 会是由 AssertionError 提供的值。

验证使用构造函数实例：

  1. assert.throws(
  2.     () => {
  3.         throw new Error('Wrong value');
  4.     },
  5.     Error
  6. );

使用 RegExp 验证错误信息：

  1. assert.throws(
  2.     () => {
  3.         throw new Error('Wrong value');
  4.     },
  5.     /value/
  6. );

自定义错误验证：

  1. assert.throws(
  2.     () => {
  3.         throw new Error('Wrong value');
  4.     },
  5.     function (err) {
  6.         if ((err instanceof Error) && /value/.test(err)) {
  7.             return true;
  8.         }
  9.     },
  10.     'unexpected error'
  11. );

请注意，Error 不能是字符串。如果字符串是作为第二个参数，那么 error 会被假定省略，字符串将会使用 message 替代。这很容易导致丢失错误：

  1. // THIS IS A MISTAKE! DO NOT DO THIS!
  2. assert.throws(myFunction, 'missing foo', 'did not throw with expected message');
  4. // Do this instead.
  5. assert.throws(myFunction, /missing foo/, 'did not throw with expected message');

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

断言 block 函数不会抛出错误。查阅 assert.throws() 了解更多详情。

当调用 assert.doesNotThrow() 时，它会立即调用 block 函数。

如果抛出错误，并且与 error 参数指定的类型相同，那么将会抛出一个 AssertionError。如果是不同类型的错误，或 error 参数是 undefined，那么错误会回传给调用者。

以下例子将会引发 TypeError，因为在断言中没有匹配的错误类型：

  1. assert.doesNotThrow(
  2.     () => {
  3.         throw new TypeError('Wrong value');
  4.     },
  5.     SyntaxError
  6. );

然而，以下将会导致一个带有 ‘Got unwanted exception (TypeError)..’ 信息的 AssertionError。

  1. assert.doesNotThrow(
  2.     () => {
  3.         throw new TypeError('Wrong value');
  4.     },
  5.     TypeError
  6. );

如果抛出了一个 AssertionError，并且一个值被作为 message 参数，message 的值会被追加到 AssertionError 的消息中：

  1. assert.doesNotThrow(
  2.     () => {
  3.         throw new TypeError('Wrong value');
  4.     },
  5.     TypeError,
  6.     'Whoops'
  7. );
  8. // Throws: AssertionError: Got unwanted exception (TypeError). Whoops