当前位置： 移动技术网 > IT编程>脚本编程>NodeJs > Node.js API详解之 assert模块用法实例分析

Node.js API详解之 assert模块用法实例分析

2020年06月18日  | 移动技术网IT编程  | 我要评论

本文实例讲述了node.js api详解之 assert模块用法。分享给大家供大家参考，具体如下：

node.js api详解之 assert

assert 模块提供了断言测试的函数，用于测试不变式。
断言是编程术语，表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真，
可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。
同样，程序投入运行后，最终用户在遇到问题时可以重新启用断言。
使用断言可以创建更稳定、品质更好且不易于出错的代码。
当需要在一个值为false时中断当前操作的话，可以使用断言。
单元测试必须使用断言（junit/junitx）。

使用方式：

const assert = require('assert');

assert.ok(value[, message])

说明：

测试 value 是否为真值。 相当于 assert.equal(!!value, true, message)。
如果 value 不为真值，则抛出一个带有 message 属性的 assertionerror，
其中 message 属性的值等于传入的 message 参数的值。
如果 message 参数为 undefined，则赋予默认的错误信息。

demo：

const assert = require('assert');
assert.ok(true);
// 测试通过。
assert.ok(1);
// 测试通过。
assert.ok(false);
// 抛出 "assertionerror: false == true"
assert.ok(0);
// 抛出 "assertionerror: 0 == true"
assert.ok(false, '不是真值');
// 抛出 "assertionerror: 不是真值"

assert(value[, message])

说明：

assert.ok() 的别名。
用法与 assert.ok() 相同。

demo：

const assert = require('assert');
assert(true);
// 测试通过。
assert(1);
// 测试通过。
assert(false);
// 抛出 "assertionerror: false == true"
assert(0);
// 抛出 "assertionerror: 0 == true"
assert(false, '不是真值');
// 抛出 "assertionerror: 不是真值"

assert.iferror(value)

说明：

如果 value 为真，则抛出 value。 可用于测试回调函数的 error 参数。
源码：function iferror(err) { if (err) throw err; };

demo：

const assert = require('assert');
assert.iferror(0);
// 通过。
assert.iferror(1);
// 抛出 1。
assert.iferror('error');
// 抛出 'error'。
assert.iferror(new error());
// 抛出 error。

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

说明：

使用相等运算符（==）测试 actual 参数与 expected 参数是否相等

demo：

const assert = require('assert');
assert.equal(1, 1);
// 测试通过，1 == 1。
assert.equal(1, '1');
// 测试通过，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.deepequal(actual, expected[, message])

说明：

测试 actual 参数与 expected 参数是否深度相等。 原始值使用相等运算符（==）比较。
只测试可枚举的自身属性，不测试对象的原型、连接符、或不可枚举的属性（这些情况使用 assert.deepstrictequal()）。
map 和 set 包含的子项也会被测试。
如果两个值不相等，则抛出一个带有 message 属性的 assertionerror，
其中 message 属性的值等于传入的 message 参数的值。
如果 message 参数为 undefined，则赋予默认的错误信息。

demo：

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(/a/gi, new date());
//测试通过，因为 regexp 对象的属性不是可枚举的：
assert.deepequal(obj1, obj1);
// 测试通过，对象与自身相等。
assert.deepequal(obj1, obj2);
// 抛出 assertionerror: { a: { b: 1 } } deepequal { a: { b: 2 } }
// 因为 b 属性的值不同。
assert.deepequal(obj1, obj3);
// 测试通过，两个对象相等。
assert.deepequal(obj1, obj4);
// 抛出 assertionerror: { a: { b: 1 } } deepequal {}
// 因为不测试原型。

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

说明：

与 assert.deepequal() 大致相同，但有一些区别：
1.原始值使用全等运算符（===）比较。set 的值与 map 的键使用 samevaluezero 比较。
2.对象的原型也使用全等运算符比较。
3.对象的类型标签要求相同。
4.比较[对象包装器][]时，其对象和里面的值要求相同。

demo：

const assert = require('assert');
assert.deepequal({ a: 1 }, { a: '1' });
// 测试通过，因为 1 == '1'。
assert.deepstrictequal({ a: 1 }, { a: '1' });
// 抛出 assertionerror: { a: 1 } deepstrictequal { a: '1' }
// 因为使用全等运算符 1 !== '1'。
// 以下对象都没有自身属性。
const date = new date();
const object = {};
const fakedate = {};
object.setprototypeof(fakedate, date.prototype);
assert.deepequal(object, fakedate);
// 测试通过，不测试原型。
assert.deepstrictequal(object, fakedate);
// 抛出 assertionerror: {} deepstrictequal date {}
// 因为原型不同。
assert.deepequal(date, fakedate);
// 测试通过，不测试类型标签。
assert.deepstrictequal(date, fakedate);
// 抛出 assertionerror: 2017-03-11t14:25:31.849z deepstrictequal date {}
// 因为类型标签不同。
assert.deepstrictequal(new number(1), new number(2));
// 测试不通过，因为数值对象包装器里面的数值也会被比较。
assert.deepstrictequal(new string('foo'), object('foo'));
// 测试通过，因为这两个对象和里面的字符串都是相同的

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

说明：

使用全等运算符（===）测试 actual 参数与 expected 参数是否全等。

demo：

onst assert = require('assert');
assert.strictequal(1, 2);
// 抛出 assertionerror: 1 === 2
assert.strictequal(1, 1);
// 测试通过。
assert.strictequal(1, '1');
// 抛出 assertionerror: 1 === '1'

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

说明：

使用不等运算符（!=）测试 actual 参数与 expected 参数是否不相等。

demo：

const assert = require('assert');
assert.notequal(1, 2);
// 测试通过。
assert.notequal(1, 1);
// 抛出 assertionerror: 1 != 1
assert.notequal(1, '1');
// 抛出 assertionerror: 1 != '1'

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

说明：

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

demo：

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);
// 测试通过，obj1 与 obj2 不深度相等。
assert.notdeepequal(obj1, obj3);
// 抛出 assertionerror: { a: { b: 1 } } notdeepequal { a: { b: 1 } }
assert.notdeepequal(obj1, obj4);
// 测试通过，obj1 与 obj4 不深度相等。

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

说明：

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

demo：

const assert = require('assert');
assert.notdeepequal({ a: 1 }, { a: '1' });
// 抛出 assertionerror: { a: 1 } notdeepequal { a: '1' }
assert.notdeepstrictequal({ a: 1 }, { a: '1' });
// 测试通过。

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

说明：

使用不全等运算符（!==）测试 actual 参数与 expected 参数是否不全等。

demo：

const assert = require('assert');
assert.notstrictequal(1, 2);
// 测试通过。
assert.notstrictequal(1, 1);
// 抛出 assertionerror: 1 !== 1
assert.notstrictequal(1, '1');
// 测试通过。
assert.fail(message)

assert.fail(actual, expected[, message[, operator[, stackstartfunction]]])

说明：

抛出 assertionerror。 如果 message 参数为空，则错误信息为 actual 参数 + operator 参数 + expected 参数。
如果只提供了 actual 参数与 expected 参数，则 operator 参数默认为 ‘!='。
如果提供了 message 参数，则它会作为错误信息，其他参数会保存在错误对象的属性中。
如果提供了 stackstartfunction 参数，则该函数上的栈帧都会从栈信息中移除

demo：

const assert = require('assert');
assert.fail(1, 2, undefined, '>');
// 抛出 assertionerror [err_assertion]: 1 > 2
assert.fail(1, 2, '错误信息');
// 抛出 assertionerror [err_assertion]: 错误信息
assert.fail(1, 2, '错误信息', '>');
// 抛出 assertionerror [err_assertion]: 错误信息
// 上面两个例子的 `actual` 参数、`expected` 参数与 `operator` 参数不影响错误消息。
assert.fail();
// 抛出 assertionerror [err_assertion]: failed
assert.fail('错误信息');
// 抛出 assertionerror [err_assertion]: 错误信息
assert.fail('a', 'b');
// 抛出 assertionerror [err_assertion]: 'a' != 'b'
//使用 stackstartfunction 参数拦截异常的栈信息：
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.throws(block[, error][, message])

说明：

断言 block 函数会抛出错误。
error 参数可以是构造函数、正则表达式、或自定义函数。
如果指定了 message 参数，则当 block 函数不抛出错误时，message 参数会作为 assertionerror 的错误信息。

demo：

const assert = require('assert');
assert.throws(
 () => {
  throw new error('错误信息');
 },
 /123/
);
// error: 错误信息
assert.throws(
 () => {
  throw new error('错误信息');
 },
 /错误/
);
// 通过
assert.throws(
 () => {
  throw new error('错误信息');
 },
 error
);
// 通过
assert.throws(
 () => {
  throw new error('错误信息');
 },
 function(err) {
  if ((err instanceof error) && /错误/.test(err)) {
   return true;
  }
 },
 '不是期望的错误'
);
// 通过
// error 参数不能是字符串。 如果第二个参数是字符串，则视为省略 error 参数，传入的字符串会被用于 message 参数。
// 这是错误的！不要这么做！
assert.throws(() => {
  throw new error('错误信息');
 }, '错误信息', '没有抛出期望的信息');
 
// 应该这么做。
assert.throws(() => {
  throw new error('错误信息');
 }, /错误信息/, '没有抛出期望的信息');

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

说明：

断言 block 函数不会抛出错误。
当 assert.doesnotthrow() 被调用时，它会立即调用 block 函数。
如果抛出错误且错误类型与 error 参数指定的相同，则抛出 assertionerror。
如果错误类型不相同，或 error 参数为 undefined，则抛出错误。

demo：

const assert = require('assert');
assert.doesnotthrow(
 () => {
  throw new typeerror('错误信息');
 },
 syntaxerror
);
// typeerror: 错误信息
assert.doesnotthrow(
 () => {
  throw new typeerror('错误信息');
 },
 typeerror
);
// assertionerror [err_assertion]: got unwanted exception.
// 错误信息
// 如果抛出了 assertionerror 且有给 message 参数传值，则 message 参数的值会被附加到 assertionerror 的信息中：
assert.doesnotthrow(
 () => {
  throw new typeerror('错误信息');
 },
 typeerror,
 '抛出错误'
);
// assertionerror [err_assertion]: got unwanted exception: 抛出错误
// 错误信息

注意事项

说明：

对于 samevaluezero 比较，建议使用 es2015 的 object.is()。

demo：

const a = 0;
const b = -a;
assert.notstrictequal(a, b);
// 抛出 assertionerror: 0 !== -0
// 因为全等运算符不区分 -0 与 +0。
assert(!object.is(a, b));
// 但 object.is() 可以区分。
const str1 = 'foo';
const str2 = 'foo';
assert.strictequal(str1 / 1, str2 / 1);
// 抛出 assertionerror: nan === nan
// 因为全等运算符不能用于测试 nan。
assert(object.is(str1 / 1, str2 / 1));
// 但 object.is() 可以测试。

samevaluezero

说明：

内部比较操作samevaluezero（x，y）
如果 type of x 不同于 type of y，返回false。
如果 type of x 是数字，那么
如果 x 为 nan， y 为 nan，返回 true。
如果 x 是 +0 而 y 是 -0，返回 true。
如果 x 是 -0 而 y 是 +0，返回 true。
如果 x 与 y 相同，则返回 true。
返回 假。

希望本文所述对大家node.js程序设计有所帮助。

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网