const son1 = Object.create(obj1),
 son2 = Object.create(obj2);

son1.name="Summer";
son2.name="Summer";

assert.deepEqual(son1,son2,"actual unequal to expected");
// 斷言通過

上面代碼中 son1 和 son2 分別繼承與兩個不同的對象，都擁有 name 為 “Summer” 的屬性，最后的的結果是通過，說明【deepEqual()不測試對象的原型】

const ena = {}, 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,"actual unequal to expected") 
//ok,actual equal to expected

上面代碼中 ena 和 enb 用于相同的可枚舉屬性【name】，有著值不同的不可枚舉屬性【hobby】，說明【deepEqual()不測試對象的不可枚舉的屬性】

四. 判斷預期值和實際值全等（===）

這組測試函數(shù)是用于判斷預期值和實際值是否深度相等的，內(nèi)部使用的是（===），所以對象的原型也會進行比較，值得類型也是比較的范圍。這組也有兩個測試函數(shù)。

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

由于內(nèi)部使用的是全等（===），所以對象的原型也會計入比較的范圍

const obj1 = { name: "foo", gender: "men" },
 obj2 = { name: "bar", gender: "men" }
const son1 = Object.create(obj1),
 son2 = Object.create(obj2);
son1.name = "Summer";
son2.name = "Summer";
assert.deepEqual(son1, son2, "actual unequal to expected");
//斷言通過
assert.deepStrictEqual(son1, son2, "actual unequal to expected")
//AssertionError [ERR_ASSERTION]: actual unequal to expected

上面代碼使用了deepEqual()和deepStrictEqual()進行了斷言測試，son1 和 son2 分別繼承與兩個不同的對象，但是擁有相同的屬性值。可以看出【deepEqual()是不會考慮對象的原型的，deepStrictEqual()將原型對象列入了比較對象】

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

strictEqual()是equal()的加強，考慮了數(shù)據(jù)類型；如果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()】斷言測試

五. 判斷預期值和實際值不相等（!=）

上面總結到了判斷預期值和實際值相等，這兒總結一下判斷預期值和實際值不想等的兩個測試函數(shù)，實際上就是上面 （三） 的逆運算。

5.1 assert.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

上面代碼是對值類型進行的比較，第三個表達式的默認信息可以看出內(nèi)部使用的是（!=）

assert.notEqual({ a: "foo" }, { a: "foo" });

assert.notEqual(() => { }, () => { });

assert.notEqual([], []);

上面的代碼是對引用類型進行的斷言測試，【notEqual() 】對于兩個對象的測試通過是一個【恒成立】的結果。

5.2 assert.notDeepEqual(actual, expected[, message])

【notDeepEqual() 】為 【deepEqual() 】的逆運算，如果 actual!= expected 則斷言通過，不同于notEqual()的是對于引用類型是對值進行判斷，不比對原型、不可枚舉屬性,只比對自有可枚舉屬性,斷言通過。

const obj1 = { a: "foo" },
 obj2 = { b: "bar" },
 obj3 = Object.create(obj1);

assert.notDeepEqual(obj1,obj1,'actual equal to expected');
// AssertionError [ERR_ASSERTION]: actual equal to expected

assert.notDeepEqual(obj1,obj2,'actual equal to expected');
// 斷言通過

assert.notDeepEqual(obj1,obj3,'actual equal to expected');
// 斷言通過

上面代碼中最后一個表達式斷言通過，說明【不比對原型、不可枚舉屬性,只比對自有可枚舉屬性】

【注意！！】與notEqual的區(qū)別，也就是deepEqual和equal的區(qū)別，在引用數(shù)據(jù)類型的時候，deepEqual是比較的值而非引用，equal對比的是引用，所以引用類型在equal的時候是永遠無法通過斷言測試的，以此類推，引用類型在notEqual時是永遠否可以通過斷言測試的。

六. 判斷預期值和實際值嚴格不相等（!==）

上面總結到了判斷預期值和實際值嚴格相等，這兒總結一下判斷預期值和實際值嚴格不相等的兩個測試函數(shù)，實際上就是上面 （四） 的逆運算

6.1 assert.notStrictEqual(actual, expected[, message])

如果actual與expected不 !== 則斷言通過， 與 assert.deepStrictEqual() 相反

assert.notStrictEqual("1", 1);
// 斷言通過

assert.notStrictEqual("1", "1");
// AssertionError [ERR_ASSERTION]: '1' !== '1'

上面代碼是對值類型進行的斷言測試，可以看出【notStrictEqual() 】考慮了數(shù)據(jù)類型

assert.notStrictEqual({ a: "foo" }, { a: "foo" });
assert.notStrictEqual(() => { }, () => { });
assert.notStrictEqual([], []);

上面代碼是對引用類型的測試，全部通過，以上表達式是恒通過的。

6.2 assert.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' }

七. 斷言錯誤并拋出

這一組有 四 個（可以說是 三 個）測試函數(shù)，是對錯誤進行的處理。

7.1 assert.fail(message)

這個測試函數(shù)不多說，可以看錯是下一個函數(shù)的重載，用于主動拋出帶有【message】屬性的【AssertionError】對象

assert.fail("自定義錯誤信息");
// AssertionError [ERR_ASSERTION]: 自定義錯誤信息

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

該測試函數(shù)用于主動拋出自定義錯誤信息，拋出錯誤信息格式：【actual 參數(shù) + operator 參數(shù) + expected 參數(shù)】

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】等參數(shù)會被列入錯誤對象屬性中

assert.fail("BLUE","PINK",undefined);
// AssertionError [ERR_ASSERTION]: 'BLUE' undefined 'PINK'

assert.fail("BLUE","PINK",undefined,"?");
// AssertionError [ERR_ASSERTION]: 'BLUE' ? 'PINK'

上面代碼是【message】為 undefined 時，會檢測【operator】參數(shù)，【operator?operator:undefined 】

7.3 assert.throws(block,error, message)

參數(shù)說明：

block | Function

error | RegExp | Function

message | any

【說明??！】如果block拋出的錯誤滿足error參數(shù),也就是拋出錯誤與期望一致,則斷言通過，否則拋出block中的錯誤，如果block不拋出錯誤，則拋出【AssertionError 】。

【提示?。　縠rror 參數(shù)可以是構造函數(shù)、正則表達式、或自定義函數(shù)。

assert.throws(
 () => {
  throw new Error('錯誤信息');
 },
 Error
);

上面代碼中 error 參數(shù)為構造函數(shù)，【block】拋出的錯誤與預期的一致，所以斷言通過。

assert.throws(
 () => {
  throw new Error('錯誤信息');
 },
 /錯誤/
);

上面代碼中 error 參數(shù)為正則表達式，【block】拋出的錯誤滿足正則表達式，所以斷言通過。

【注意！！】error 參數(shù)不能是字符串。 如果第二個參數(shù)是字符串，則視為省略 error 參數(shù)，傳入的字符串會被用于 【message】 參數(shù)，

// 這是錯誤的！不要這么做！
assert.throws(myFunction, '錯誤信息', '沒有拋出期望的信息');

// 應該這么做。
assert.throws(myFunction, /錯誤信息/, '沒有拋出期望的信息');

下面代碼，【error】 參數(shù)為自定義函數(shù)

assert.throws(
 () => {
  throw new Error('錯誤信息');
 },
 function (err) {
  if ((err instanceof Error) && /錯誤/.test(err)) {
   return true;
  }
 },
 '不是期望的錯誤'
);

7.4 assert.doesNotThrow(block, error, message)

【說明?。　款A期的錯誤和實際的錯誤一致時，不拋出實際錯誤，拋出AssertionError，不一致則拋出實際錯誤信息

assert.doesNotThrow(
 () => {
 throw new TypeError('錯誤信息');
 },
 SyntaxError
);

以上例子會拋出 TypeError，因為在斷言中沒有匹配的錯誤類型

assert.doesNotThrow(
 () => {
 throw new TypeError('錯誤信息');
 },
 TypeError
);

以上例子會拋出一個帶有 Got unwanted exception (TypeError).. 信息的 AssertionError

assert.doesNotThrow(
 () => {
 throw new TypeError('錯誤信息');
 },
 TypeError,
 '拋出錯誤'
);
// 拋出 AssertionError: Got unwanted exception (TypeError). 拋出錯誤

上面代碼說明：如果拋出了 AssertionError 且有給 message 參數(shù)傳值，則 message 參數(shù)的值會被附加到 AssertionError 的信息中

八. 判斷值是否為真

這兒只有一個測試函數(shù)了

8.1 assert.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(new Error());
//拋出 Error,對象名稱

上面代碼中全部是通過 Boolean(value) 轉換之后再進行的測試，利用這個特性我們可以將此測試函數(shù)用于測試回調(diào)函數(shù)的 error 參數(shù)。

總結

以上就是這篇文章的全部內(nèi)容了，希望本文的內(nèi)容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對腳本之家的支持。