Node.js API详解之 assert模块用法实例分析
本文实例讲述了Node.jsAPI详解之assert模块用法。分享给大家供大家参考，具体如下：
Node.jsAPI详解之assert
assert模块提供了断言测试的函数，用于测试不变式。
断言是编程术语，表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真，
可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。
同样，程序投入运行后，最终用户在遇到问题时可以重新启用断言。
使用断言可以创建更稳定、品质更好且不易于出错的代码。
当需要在一个值为false时中断当前操作的话，可以使用断言。
单元测试必须使用断言（Junit/JunitX）。
使用方式：
constassert=require('assert');
assert.ok(value[,message])
说明：
测试value是否为真值。相当于assert.equal(!!value,true,message)。
如果value不为真值，则抛出一个带有message属性的AssertionError，
其中message属性的值等于传入的message参数的值。
如果message参数为undefined，则赋予默认的错误信息。
demo：
constassert=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：
constassert=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参数。
源码：functionifError(err){if(err)throwerr;};
demo：
constassert=require('assert');
assert.ifError(0);
//通过。
assert.ifError(1);
//抛出1。
assert.ifError('error');
//抛出'error'。
assert.ifError(newError());
//抛出Error。
assert.equal(actual,expected[,message])
说明：
使用相等运算符（==）测试actual参数与expected参数是否相等
demo：
constassert=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：
constassert=require('assert');
constobj1={
a:{
b:1
}
};
constobj2={
a:{
b:2
}
};
constobj3={
a:{
b:1
}
};
constobj4=Object.create(obj1);
assert.deepEqual(/a/gi,newDate());
//测试通过，因为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：
constassert=require('assert');
assert.deepEqual({a:1},{a:'1'});
//测试通过，因为1=='1'。
assert.deepStrictEqual({a:1},{a:'1'});
//抛出AssertionError:{a:1}deepStrictEqual{a:'1'}
//因为使用全等运算符1!=='1'。
//以下对象都没有自身属性。
constdate=newDate();
constobject={};
constfakeDate={};
Object.setPrototypeOf(fakeDate,Date.prototype);
assert.deepEqual(object,fakeDate);
//测试通过，不测试原型。
assert.deepStrictEqual(object,fakeDate);
//抛出AssertionError:{}deepStrictEqualDate{}
//因为原型不同。
assert.deepEqual(date,fakeDate);
//测试通过，不测试类型标签。
assert.deepStrictEqual(date,fakeDate);
//抛出AssertionError:2017-03-11T14:25:31.849ZdeepStrictEqualDate{}
//因为类型标签不同。
assert.deepStrictEqual(newNumber(1),newNumber(2));
//测试不通过，因为数值对象包装器里面的数值也会被比较。
assert.deepStrictEqual(newString('foo'),Object('foo'));
//测试通过，因为这两个对象和里面的字符串都是相同的
assert.strictEqual(actual,expected[,message])
说明：
使用全等运算符（===）测试actual参数与expected参数是否全等。
demo：
onstassert=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：
constassert=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：
constassert=require('assert');
constobj1={
a:{
b:1
}
};
constobj2={
a:{
b:2
}
};
constobj3={
a:{
b:1
}
};
constobj4=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：
constassert=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：
constassert=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：
constassert=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参数拦截异常的栈信息：
functionsuppressFrame(){
assert.fail('a','b',undefined,'!==',suppressFrame);
}
suppressFrame();
//AssertionError[ERR_ASSERTION]:'a'!=='b'
//atrepl:1:1
//atContextifyScript.Script.runInThisContext(vm.js:44:33)
//...
assert.throws(block[,error][,message])
说明：
断言block函数会抛出错误。
error参数可以是构造函数、正则表达式、或自定义函数。
如果指定了message参数，则当block函数不抛出错误时，message参数会作为AssertionError的错误信息。
demo：
constassert=require('assert');
assert.throws(
()=>{
thrownewError('错误信息');
},
/123/
);
//Error:错误信息
assert.throws(
()=>{
thrownewError('错误信息');
},
/错误/
);
//通过
assert.throws(
()=>{
thrownewError('错误信息');
},
Error
);
//通过
assert.throws(
()=>{
thrownewError('错误信息');
},
function(err){
if((errinstanceofError)&&/错误/.test(err)){
returntrue;
}
},
'不是期望的错误'
);
//通过
//error参数不能是字符串。如果第二个参数是字符串，则视为省略error参数，传入的字符串会被用于message参数。
//这是错误的！不要这么做！
assert.throws(()=>{
thrownewError('错误信息');
},'错误信息','没有抛出期望的信息');
//应该这么做。
assert.throws(()=>{
thrownewError('错误信息');
},/错误信息/,'没有抛出期望的信息');
assert.doesNotThrow(block[,error][,message])
说明：
断言block函数不会抛出错误。
当assert.doesNotThrow()被调用时，它会立即调用block函数。
如果抛出错误且错误类型与error参数指定的相同，则抛出AssertionError。
如果错误类型不相同，或error参数为undefined，则抛出错误。
demo：
constassert=require('assert');
assert.doesNotThrow(
()=>{
thrownewTypeError('错误信息');
},
SyntaxError
);
//TypeError:错误信息
assert.doesNotThrow(
()=>{
thrownewTypeError('错误信息');
},
TypeError
);
//AssertionError[ERR_ASSERTION]:Gotunwantedexception.
//错误信息
//如果抛出了AssertionError且有给message参数传值，则message参数的值会被附加到AssertionError的信息中：
assert.doesNotThrow(
()=>{
thrownewTypeError('错误信息');
},
TypeError,
'抛出错误'
);
//AssertionError[ERR_ASSERTION]:Gotunwantedexception:抛出错误
//错误信息
注意事项
说明：
对于SameValueZero比较，建议使用ES2015的Object.is()。
demo：
consta=0; constb=-a; assert.notStrictEqual(a,b); //抛出AssertionError:0!==-0 //因为全等运算符不区分-0与+0。 assert(!Object.is(a,b)); //但Object.is()可以区分。 conststr1='foo'; conststr2='foo'; assert.strictEqual(str1/1,str2/1); //抛出AssertionError:NaN===NaN //因为全等运算符不能用于测试NaN。 assert(Object.is(str1/1,str2/1)); //但Object.is()可以测试。
SameValueZero
说明：
内部比较操作SameValueZero（x，y）
如果typeofx不同于typeofy，返回false。
如果typeofx是数字，那么
如果x为NaN，y为NaN，返回true。
如果x是+0而y是-0，返回true。
如果x是-0而y是+0，返回true。
如果x与y相同，则返回true。
返回假。
希望本文所述对大家node.js程序设计有所帮助。