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)//測試通過