node.js学习之断言assert的使用示例
一.简介
断言是编程术语，表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真，可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。同样，程序投入运行后，最终用户在遇到问题时可以重新启用断言。
使用断言可以创建更稳定、品质更好且不易于出错的代码。当需要在一个值为FALSE时中断当前操作的话，可以使用断言。【单元测试】必须使用断言。
Node提供了10多个断言测试的函数，用于测试不变式，我在文章中中将这10多个函数进行了分组，方便理解记忆。
【提示】在本文章中，expected代表预期值，actual代表实际值，message代表自定义信息
二.判断值是否为真值
判断值是否为真值有以下两个断言测试函数
2.1assert(value[,message])
这个测试函数在【Boolean(value)】为【true】时通过断言测试，否则抛出【AssertionError】
constassert=require("assert");
assert("blue","第一个值为false时以我为错误信息抛出");
assert(true,"第一个值为false时以我为错误信息抛出");
上面一段代码由于【Boolean(value)】全部为true，所以全部通过断言测试
assert(false,"第一个值为false时以我为错误信息抛出"); //AssertionError[ERR_ASSERTION]:第一个值为false时以我为错误信息抛出
上面代码中value为false，则抛出一个带有message属性的【AssertionError】，其中message属性的值等于传入的message参数的值。【如果message参数为undefined，则赋予默认的错误信息】。
assert(false); //AssertionError[ERR_ASSERTION]:false==true
上面代码由于没有指定【message】参数，抛出的为默认错误信息的【AssertionError】
2.2assert.ok(value[,message])
assert.ok()与assert()的作用是一样的，都是测试【value】是否为真值。而且用法也一样，所以可以将assert()视为assert.ok()的语法糖
constassert=require("assert");
assert.ok(true);
assert.ok(1);
上面代码【Boolean(value)】全部为true，所以全部断言通过，下面是断言不通过的情况，分别列出了默认错误信息
assert.ok(0); //AssertionError[ERR_ASSERTION]:0==true assert.ok(false); //AssertionError[ERR_ASSERTION]:false==true assert.ok(false,"自定义错误信息"); //AssertionError[ERR_ASSERTION]:自定义错误信息
三.判断预期值和实际值相等（==）
这一组里面有两个测试函数，用于测试预期值与实际值是否相等，如果相等则断言通过，否则抛出【AssertionError】
3.1assert.equal(actual,expected[,message])
assert.equal()用于测试期望值和实际值是否相等，【在值类型的时候比较的是两个值是否相等，当预期值和实际值为引用类型的时候，比较的是值得引用】
assert.equal(1,1);
assert.equal("1",1);
上面代码是对值类型进行的比较，说明equal()在内部使用的是（==）,而非严格相等，待会儿我会总结到严格相等（===）
assert.equal({},{},"AssertionError");
assert.equal(()=>{},()=>{},"AssertionError");
assert.equal([],[],'AssertionError');
上面三个表达式都会抛出【message】属性值为'AssertionError'的【AssertionError】对象，【所以当值为引用类型的时候，equal（）比较的是值得引用，因此两个引用类型的值是没法通过equal（）断言的】
constobj={};
assert.equal(obj,obj);
//断言通过
上面代码由于比较的是同一个对象，两个值得引用相等，所以断言通过。
3.2assert.deepEqual(actual,expected[,message])
同样也是测试预期值和实际值是否相等，使用的仍然是（==），但是与equal不同的是，【deepEqual()在对引用类型进行比较的时候，不是对值的引用进行比较，而是比较的对象的属性值】
consta='Blue',b='Pink'; assert.deepEqual(a,a,'actualunequaltoexpected'); //断言通过 assert.deepEqual(a,b,'actualunequaltoexpected'); //AssertionError[ERR_ASSERTION]:actualunequaltoexpected
上面是对值类型进行的比较，和equal()没有任何的区别
constobj1={name:"foo",gender:"men"},
obj2={name:"foo",gender:"men"},
obj3={name:"bar",gender:"men"}
assert.deepEqual(obj1,obj2,'actualunequaltoexpected');
//断言通过
assert.deepEqual(obj1,obj3,'actualunequaltoexpected');
//AssertionError[ERR_ASSERTION]:actualunequaltoexpected
上面代码是对引用类型的比较，可以看出【deepEqual()】比较的是属性值，而非引用，这是与equal()不同的地方。
【注意！！】deepEqual()只测试可枚举的自身属性，不测试对象的原型、连接符、或不可枚举的属性（这些情况使用assert.deepStrictEqual()，稍后会总结到）
constson1=Object.create(obj1), son2=Object.create(obj2); son1.name="Summer"; son2.name="Summer"; assert.deepEqual(son1,son2,"actualunequaltoexpected"); //断言通过
上面代码中son1和son2分别继承与两个不同的对象，都拥有name为“Summer”的属性，最后的的结果是通过，说明【deepEqual()不测试对象的原型】
constena={},enb={};
Object.defineProperties(ena,{
name:{
value:"Blue"
},
hobby:{
value:"foo",
enumerable:false//可枚举性设置为false
}
});
Object.defineProperties(enb,{
name:{
value:"Blue"
},
hobby:{
value:"bar",
enumerable:false//可枚举性设置为false
}
})
assert.deepEqual(ena,enb,"actualunequaltoexpected")
//ok,actualequaltoexpected
上面代码中ena和enb用于相同的可枚举属性【name】，有着值不同的不可枚举属性【hobby】，说明【deepEqual()不测试对象的不可枚举的属性】
四.判断预期值和实际值全等（===）
这组测试函数是用于判断预期值和实际值是否深度相等的，内部使用的是（===），所以对象的原型也会进行比较，值得类型也是比较的范围。这组也有两个测试函数。
4.1assert.deepStrictEqual(actual,expected[,message])
由于内部使用的是全等（===），所以对象的原型也会计入比较的范围
constobj1={name:"foo",gender:"men"},
obj2={name:"bar",gender:"men"}
constson1=Object.create(obj1),
son2=Object.create(obj2);
son1.name="Summer";
son2.name="Summer";
assert.deepEqual(son1,son2,"actualunequaltoexpected");
//断言通过
assert.deepStrictEqual(son1,son2,"actualunequaltoexpected")
//AssertionError[ERR_ASSERTION]:actualunequaltoexpected
上面代码使用了deepEqual()和deepStrictEqual()进行了断言测试，son1和son2分别继承与两个不同的对象，但是拥有相同的属性值。可以看出【deepEqual()是不会考虑对象的原型的，deepStrictEqual()将原型对象列入了比较对象】
4.2assert.strictEqual(actual,expected[,message])
strictEqual()是equal()的加强，考虑了数据类型；如果actual===expected,则断言通过，否则抛出AssertionError，message?message:默认错误信息。
assert.strictEqual(1,2); //抛出AssertionError:1===2 assert.strictEqual(1,1); //测试通过。 assert.strictEqual(1,'1'); //抛出AssertionError:1==='1' assert.equal(1,'1'); //测试通过。
【提示！！】对引用类型还是永远通不过【strictEqual()】断言测试
五.判断预期值和实际值不相等（!=）
上面总结到了判断预期值和实际值相等，这儿总结一下判断预期值和实际值不想等的两个测试函数，实际上就是上面（三）的逆运算。
5.1assert.notEqual(actual,expected[,message])
【notEqual()】为【equal()】的逆运算，如果actual!=expected则断言通过，同样对于值类型是单纯对值进行比较，对应引用类型比较的是值得引用
assert.notEqual("1","2");
//断言通过
assert.notEqual("1",2);
//断言通过
assert.notEqual("1",1);
//AssertionError[ERR_ASSERTION]:'1'!=1
上面代码是对值类型进行的比较，第三个表达式的默认信息可以看出内部使用的是（!=）
assert.notEqual({a:"foo"},{a:"foo"});
assert.notEqual(()=>{},()=>{});
assert.notEqual([],[]);
上面的代码是对引用类型进行的断言测试，【notEqual()】对于两个对象的测试通过是一个【恒成立】的结果。
5.2assert.notDeepEqual(actual,expected[,message])
【notDeepEqual()】为【deepEqual()】的逆运算，如果actual!=expected则断言通过，不同于notEqual()的是对于引用类型是对值进行判断，不比对原型、不可枚举属性,只比对自有可枚举属性,断言通过。
constobj1={a:"foo"},
obj2={b:"bar"},
obj3=Object.create(obj1);
assert.notDeepEqual(obj1,obj1,'actualequaltoexpected');
//AssertionError[ERR_ASSERTION]:actualequaltoexpected
assert.notDeepEqual(obj1,obj2,'actualequaltoexpected');
//断言通过
assert.notDeepEqual(obj1,obj3,'actualequaltoexpected');
//断言通过
上面代码中最后一个表达式断言通过，说明【不比对原型、不可枚举属性,只比对自有可枚举属性】
【注意！！】与notEqual的区别，也就是deepEqual和equal的区别，在引用数据类型的时候，deepEqual是比较的值而非引用，equal对比的是引用，所以引用类型在equal的时候是永远无法通过断言测试的，以此类推，引用类型在notEqual时是永远否可以通过断言测试的。
六.判断预期值和实际值严格不相等（!==）
上面总结到了判断预期值和实际值严格相等，这儿总结一下判断预期值和实际值严格不相等的两个测试函数，实际上就是上面（四）的逆运算
6.1assert.notStrictEqual(actual,expected[,message])
如果actual与expected不!==则断言通过，与assert.deepStrictEqual()相反
assert.notStrictEqual("1",1);
//断言通过
assert.notStrictEqual("1","1");
//AssertionError[ERR_ASSERTION]:'1'!=='1'
上面代码是对值类型进行的断言测试，可以看出【notStrictEqual()】考虑了数据类型
assert.notStrictEqual({a:"foo"},{a:"foo"});
assert.notStrictEqual(()=>{},()=>{});
assert.notStrictEqual([],[]);
上面代码是对引用类型的测试，全部通过，以上表达式是恒通过的。
6.2assert.notDeepStrictEqual(actual,expected[,message])
notDeepStrictEqual()就是deepStrictEqual()的逆运算，如果actual！==expected则断言通过，否则抛出AssertionError。
assert.notDeepStrictEqual({a:'1'},{a:1});
//断言通过
assert.notDeepStrictEqual({a:'1'},{a:"1"});
//AssertionError[ERR_ASSERTION]:{a:'1'}notDeepStrictEqual{a:'1'}
七.断言错误并抛出
这一组有四个（可以说是三个）测试函数，是对错误进行的处理。
7.1assert.fail(message)
这个测试函数不多说，可以看错是下一个函数的重载，用于主动抛出带有【message】属性的【AssertionError】对象
assert.fail("自定义错误信息");
//AssertionError[ERR_ASSERTION]:自定义错误信息
7.2assert.fail(actual,expected[,message[,operator[,stackStartFunction]]])
该测试函数用于主动抛出自定义错误信息，抛出错误信息格式：【actual参数+operator参数+expected参数】
assert.fail("BLUE","PINK");
//AssertionError[ERR_ASSERTION]:'BLUE'!='PINK'
上面代码不提供【message】和【operator】,则【operator】默认为【!=】
assert.fail("BLUE","PINK","自定义的错误信息");
//AssertionError[ERR_ASSERTION]:自定义的错误信息
assert.fail("BLUE","PINK","自定义的错误信息","?",()=>{
console.log("hello");
});
//AssertionError[ERR_ASSERTION]:自定义的错误信息
上面代码提供【message】,这时候【actual】、【operator】、【expected】等参数会被列入错误对象属性中
assert.fail("BLUE","PINK",undefined);
//AssertionError[ERR_ASSERTION]:'BLUE'undefined'PINK'
assert.fail("BLUE","PINK",undefined,"?");
//AssertionError[ERR_ASSERTION]:'BLUE'?'PINK'
上面代码是【message】为undefined时，会检测【operator】参数，【operator?operator:undefined】
7.3assert.throws(block,error,message)
参数说明：
block|Function
error|RegExp|Function
message|any
【说明！！】如果block抛出的错误满足error参数,也就是抛出错误与期望一致,则断言通过，否则抛出block中的错误，如果block不抛出错误，则抛出【AssertionError】。
【提示！！】error参数可以是构造函数、正则表达式、或自定义函数。
assert.throws(
()=>{
thrownewError('错误信息');
},
Error
);
上面代码中error参数为构造函数，【block】抛出的错误与预期的一致，所以断言通过。
assert.throws(
()=>{
thrownewError('错误信息');
},
/错误/
);
上面代码中error参数为正则表达式，【block】抛出的错误满足正则表达式，所以断言通过。
【注意！！】error参数不能是字符串。如果第二个参数是字符串，则视为省略error参数，传入的字符串会被用于【message】参数，
//这是错误的！不要这么做！ assert.throws(myFunction,'错误信息','没有抛出期望的信息'); //应该这么做。 assert.throws(myFunction,/错误信息/,'没有抛出期望的信息');
下面代码，【error】参数为自定义函数
assert.throws(
()=>{
thrownewError('错误信息');
},
function(err){
if((errinstanceofError)&&/错误/.test(err)){
returntrue;
}
},
'不是期望的错误'
);
7.4assert.doesNotThrow(block,error,message)
【说明！！】预期的错误和实际的错误一致时，不抛出实际错误，抛出AssertionError，不一致则抛出实际错误信息
assert.doesNotThrow(
()=>{
thrownewTypeError('错误信息');
},
SyntaxError
);
以上例子会抛出TypeError，因为在断言中没有匹配的错误类型
assert.doesNotThrow(
()=>{
thrownewTypeError('错误信息');
},
TypeError
);
以上例子会抛出一个带有Gotunwantedexception(TypeError)..信息的AssertionError
assert.doesNotThrow(
()=>{
thrownewTypeError('错误信息');
},
TypeError,
'抛出错误'
);
//抛出AssertionError:Gotunwantedexception(TypeError).抛出错误
上面代码说明：如果抛出了AssertionError且有给message参数传值，则message参数的值会被附加到AssertionError的信息中
八.判断值是否为真
这儿只有一个测试函数了
8.1assert.ifError(value)
如果value的值为真或者可以转换成true，则抛出value，否则断言通过。
assert.ifError(true); //抛出true assert.ifError(false); //断言通过
上面代码中是直接给出的布尔类型的值，如果值为true则会将该值抛出，否则什么也不做
assert.ifError(0);
//断言通过
assert.ifError("0");
//抛出"0"
assert.ifError(1);
//抛出1
assert.ifError(newError());
//抛出Error,对象名称
上面代码中全部是通过Boolean(value)转换之后再进行的测试，利用这个特性我们可以将此测试函数用于测试回调函数的error参数。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对毛票票的支持。