assert断言(没有返回值，不需要console.log，断言未通过会抛出错误，通过不会抛出错误)

1.assert(value[, message])

    保证value是true就不会抛出错误

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

表达式：1.表示测试 actual 参数与 expected 参数是否深度相等。 原始值使用相等运算符（==）比较

             2.message参数是自定义的抛出错误信息。如果未设置，则抛出默认的错误信息

             3.只测试可枚举的自身属性，不测试对象的原型、连接符、或不可枚举的属性

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,obj2,'错误信息')
// AssertionError [ERR_ASSERTION]: 错误信息
assert.deepEqual(obj1,obj3,'错误信息')//通过
assert.deepEqual(obj1,obj1,'错误信息')//通过 

assert.deepEqual(obj1,obj4,'错误信息')//抛出错误
// obj4的原型是obj1，这个断言不比较原型

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

1. 原始值使用全等运算符（===）比较。
2. 对象的原型也会参与比较，使用全等运算符比较。
3. 对象的类型标签要求相同。
4. 比较对象包装器时，基本类型对象要求值相等，引用类型要求地址相等

assert.deepStrictEqual({a:1},{a:1})//验证通过
assert.deepStrictEqual({a:1},{a:'1'},'错误信息')//验证不通过
const date=new Date();
const object={};
const fateDate={};
Object.setPrototypeOf(fateDate,Date.prototype);//给对象设置原型
assert.deepStrictEqual(object, fateDate,'错误信息');//测试不通过，原型不一样
assert.deepStrictEqual(date, fateDate,'错误信息');//不通过，原型一样，但是标签不一样。一个是Date,一个是Object
assert.deepStrictEqual(new Number(1), new Number(2),'错误信息');//不通过，1.对象不一样，基本类型比较其值，一个是1，一个是2
assert.deepStrictEqual(new String('foo'), Object('foo'));//通过，基本类型比较的是值
assert.deepStrictEqual(new Function('a','b','console.log(a+b)'), new Function('a','b','console.log(a+b)'),'错误信息');//引用类型比较的是地址，new了两个function,地址不一样

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

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

    2..assert.deepEqual只测试可枚举的自身属性，assert.equal直接使用==运算符比较

assert.equal(1,'1','equal错误')//通过
assert.deepEqual(1,'1','deepEqual错误')//通过
assert.equal({ a: { b: 1 } }, { a: { b: 1 } },'equal错误');//断言不通过 相当于比较的是指针 Object类的两个子类
assert.deepEqual({ a: { b: 1 } }, { a: { b: 1 } },'deepEqual错误');//断言通过  只测试自身可枚举的自身属性  各个属性枚举出来是相等的
console.log('相等',{ a: { b: 1 } }=={ a: { b: 1 }})//false
// 相当于
var oo={ a: { b: 1 } };
// var oo=new Object({ a: { b: 1 }});
console.log(oo)
var ooo={ a: { b: 1 } };
// var ooo=new Object({ a: { b: 1 }});
console.log('aaaaaaaa',oo==ooo)//false

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

    1.用全等判断两个参数是否相等

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

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

    1.断言 block 函数不会抛出错误  而不是block函数运行不会出现错误，抛出错误是人为设定的

    2.参数：block：函数

                error:期望错误类型，如果抛出错误且错误类型与 error 参数指定的相同，则抛出 AssertionError。 如果错误类型不相同，或 error 参数为 undefined，则抛出错误

                 message:错误提示信息

    3.断言的函数会被立即调用

function err(){
 	throw new TypeError('错误信息')//抛出一个TypeError类型的错误信息 }
assert.doesNotThrow(err,TypeError,'这个错误表示提供的参数是一个不被允许的类型')//抛出了含有字符串说明的错误

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

    1.断言抛出错误

    2.参数意义

        block:函数

        error:参数可以是构造函数、正则表达式、或自定义函数。不能是字符串。抛出的错误类型得属于error. 如果第二个参数是字符串，则视为省略 error 参数，传入的字符串会被用于 message 参数

        message:函数不抛出错误信息时的信息

assert.throws(function (){throw new Error('函数会抛出错误信息')},Error,'函数不会抛出错误')//通过，函数会抛出错误
assert.throws(
  () => {
    throw new Error('错误信息');
  },
  /^a/g
);//错误信息 /^a/g这个正则与block函数抛出的错误毫无关联

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

    1. 功能：抛出 AssertionError（断言错误）

    2.参数含义： oprator:接受一个字符串，默认为！=   stackStartFunction 参数： 详见Error.captureStackTrace

    3.如果 message 参数为空，则错误信息为 actual 参数 + operator 参数 + expected 参数

assert.fail('参数1','参数2',undefined,'>')//AssertionError [ERR_ASSERTION]: '参数1' > '参数2'
assert.fail(1,2,'错误信息')//AssertionError [ERR_ASSERTION]: 错误信息
assert.fail('参数1','参数2','错误信息','>')//AssertionError [ERR_ASSERTION]: 错误信息
assert.fail(12,56)//AssertionError [ERR_ASSERTION]: 12 != 56

7.assert.ifError(value)

    1.功能：抛出错误参数

    2.参数含义：如果value为真，就抛出这个参数

assert.ifError(2)//将2抛出。并且打印出了ifError的函数体assert.ifError = function ifError(err) { if (err) throw err; };进一步说明了参数为真，就抛出

8.assert.ok(value[, message])

    1.功能：测试 value 是否为真值。value不是真值，抛出message错误

assert.ok(false)//AssertionError [ERR_ASSERTION]: false == true

assert.ok(6)//测试通过