Node assert的用法

assert模塊提供了斷言測試的函數(shù)，用于測試不變式

有strict和legacy兩種模式，建議只使用strict模式

assert.AssertionError類

error的一個子類，表明斷言的失敗。assert模塊跑出的所有錯誤都是AssertionError類的實例

strict模式

當使用strict模式時，任何assert函數(shù)都會使用嚴格函數(shù)模式的等式，所以assert.deepEqual()會等同于assert.deepStrictEqual()

除此以外，涉及對象的錯誤信息會產(chǎn)生一個錯誤差異比較，而不是展示對方的對象，legacy模式則不會這樣

assert(value[,message])

ssert.ok()?的別名。

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

strict 模式

assert.deepStrictEqual()?的別名。


If the values are not equal, an?AssertionError?is thrown with a?message?property set equal to the value of the?message?parameter. If the?message?parameter is undefined, a default error message is assigned. If the?message?parameter is an instance of an?Error?then it will be thrown instead of the?AssertionError.

如果值不相等，則會拋出一個AssertionError，該消息屬性集等于消息參數(shù)的值。如果消息參數(shù)未定義，則指定一個默認的錯誤消息。如果消息參數(shù)是一個錯誤的實例，那么它將被拋出而不是AssertionError。

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

測試?actual?參數(shù)與?expected?參數(shù)是否深度相等。 深度相等意味著子對象中可枚舉的自身屬性也會按以下規(guī)則遞歸地比較

比較的詳細說明

原始值運用?SameValue比較法進行比較，使用?Object.is()?函數(shù)。

對象的類型標簽應該相同。

對象的原型使用全等運算符比較。

只比較可枚舉的自身屬性。

Error?的名稱與信息也會比較，即使不是可枚舉的屬性。

可枚舉的自身?Symbol?屬性也會比較。

對象封裝器?會同時比較對象與解封裝后的值。

Object?屬性的比較是無序的。

Map?鍵名與?Set?子項的比較是無序的。

當兩邊的值不相同或遇到循環(huán)引用時，遞歸會停止。

WeakMap?與?WeakSet?的比較不依賴于它們的值。

assert.doesNotReject(block[, error][, message])

等待?block?的 promise 完成，如果?block?是一個函數(shù)，則立即調(diào)用該函數(shù)并等待返回的 promise 完成，然后檢查 promise 是否被 reject。

如果?block?是一個函數(shù)且同步地拋出一個錯誤，則?assert.doesNotReject()?會返回一個被 reject 的?Promise?并傳入該錯誤。 如果該函數(shù)沒有返回一個 promise，則?assert.doesNotReject()?會返回一個被 reject 的?Promise?并傳入?ERR_INVALID_RETURN_VALUE?錯誤。 以上兩種情況都會跳過錯誤處理函數(shù)。

error?可以是?Class、RegExp?或校驗函數(shù)

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


斷言?block?函數(shù)不會拋出錯誤。

當?assert.doesNotThrow()?被調(diào)用時，它會立即調(diào)用?block?函數(shù)。

如果拋出錯誤且錯誤類型與?error?參數(shù)指定的相同，則拋出?AssertionError。 如果錯誤類型不相同，或?error?參數(shù)為?undefined，則拋出錯誤。

error?可以是?Class、RegExp?或校驗函數(shù)。

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


strict 模式

assert.strictEqual()?的別名

如果值不相等，則用與消息參數(shù)的值相等的消息屬性集拋出斷言錯誤。如果消息參數(shù)未定義，則分配默認錯誤消息。如果消息參數(shù)是錯誤的實例，那么它將被拋出而不是斷言錯誤。

assert.fail([message])

拋出?AssertionError，并帶上提供的錯誤信息或默認的錯誤信息。 如果?message?參數(shù)是?Error?的實例，則會拋出它而不是?AssertionError


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


如果消息是偽造的，則將錯誤消息設置為所提供的操作符所分離的實際值和期望值。如果只提供兩個實際的和預期的參數(shù)，操作員將默認為“！”=。如果消息被提供為第三個參數(shù)，它將被用作錯誤消息，其他參數(shù)將作為拋出對象上的屬性存儲。如果提供了StActStaskFufft，則該函數(shù)之上的所有堆棧幀將從SttTrace中刪除（參見Error .CoprTestStAc跡）。如果未給出參數(shù)，則將使用默認消息失敗。

const assert = require('assert').strict;

assert.fail('a', 'b');

// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>');

// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail');

// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>');

// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'));

// TypeError: need array

在最后三種情況下，實際的、預期的和操作員對錯誤消息沒有影響。StActStaskFor用于截斷異常STACKTrace:

function suppressFrame() {

assert.fail('a', 'b', undefined, '!==', suppressFrame);

}

suppressFrame();

// AssertionError [ERR_ASSERTION]: 'a' !== 'b'

// at repl:1:1

// at ContextifyScript.Script.runInThisContext (vm.js:44:33)

// ...

assert.ifError(value)

如果?value?不為?undefined?或?null，則拋出?value。 可用于測試回調(diào)函數(shù)的?error?參數(shù)。 堆棧蹤跡會包含傳入?ifError()?的錯誤的所有幀，包括潛在的?ifError()?自身新增的幀。

const assert = require('assert').strict;

assert.ifError(null);

// 通過。

assert.ifError(0);

// 拋出 AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0

assert.ifError('錯誤信息');

// 拋出 AssertionError [ERR_ASSERTION]: ifError got unwanted exception: '錯誤信息'

assert.ifError(new Error());

// 拋出 AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error

// 添加一些錯誤幀。

let err;

(function errorFrame() {

err = new Error('錯誤信息');

})();

(function ifErrorFrame() {

assert.ifError(err);

})();

// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 錯誤信息

// at ifErrorFrame

// at errorFrame

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


任何深度不等式的檢驗。與Advest.DeqQualQualor相反。

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.notDeepEqual(obj1, obj1);

// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2);

// OK

assert.notDeepEqual(obj1, obj3);

// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4);// OK

如果值是深度相等的，則拋出一個斷言錯誤，其消息屬性集等于消息參數(shù)的值。如果消息參數(shù)未定義，則分配默認錯誤消息。如果消息參數(shù)是錯誤的實例，那么它將被拋出而不是斷言錯誤。


assert.notDeepStrictEqual(actual,expected[,message])

測試?actual?參數(shù)與?expected?參數(shù)是否不深度全等。 與?assert.deepStrictEqual()?相反

const assert = require('assert').strict;

assert.notDeepStrictEqual({ a: 1 }, { a: '1' });

// 測試通過。

如果兩個值深度全等，則拋出一個帶有?message?屬性的?AssertionError，其中?message?屬性的值等于傳入的?message?參數(shù)的值。 如果?message?參數(shù)為?undefined，則賦予默認的錯誤信息。 如果?message?參數(shù)是?Error?的實例，則會拋出它而不是?AssertionError。

assert.notEqual(actual,expected[,message])


測試淺、強制不等式與抽象相等的比較!=

const assert = require('assert');

assert.notEqual(1, 2);

// OK

assert.notEqual(1, 1);

// AssertionError: 1 != 1

assert.notEqual(1, '1');

// AssertionError: 1 != '1'

如果值相等，則用與消息參數(shù)的值相等的消息屬性集拋出斷言錯誤。如果消息參數(shù)未定義，則分配默認錯誤消息。如果消息參數(shù)是錯誤的實例，那么它將被拋出而不是斷言錯誤。

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

使用?SameValue比較法測試?actual?參數(shù)與?expected?參數(shù)是否不全等

const assert = require('assert').strict;

assert.notStrictEqual(1, 2);

// 測試通過。

assert.notStrictEqual(1, 1);

// 拋出 AssertionError [ERR_ASSERTION]: Identical input passed to notStrictEqual: 1

assert.notStrictEqual(1, '1');

// 測試通過。

如果兩個值全等，則拋出一個帶有?message?屬性的?AssertionError，其中?message?屬性的值等于傳入的?message?參數(shù)的值。 如果?message?參數(shù)為?undefined，則賦予默認的錯誤信息。 如果?message?參數(shù)是?Error?的實例，則會拋出它而不是?AssertionError。

assert.ok(vaule[,message])


測試?value?是否為真值。 相當于?assert.equal(!!value, true, message)。

如果?value?不為真值，則拋出一個帶有?message?屬性的?AssertionError，其中?message?屬性的值等于傳入的?message?參數(shù)的值。 如果?message?參數(shù)為?undefined，則賦予默認的錯誤信息。 如果?message?參數(shù)是?Error?的實例，則會拋出它而不是?AssertionError。 如果沒有傳入?yún)?shù)，則?message?會被設為字符串?'No value argument passed to `assert.ok()`'。

const assert = require('assert').strict;

assert.ok(true);// 測試通過。

assert.ok(1);// 測試通過。

assert.ok();// 拋出 AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, '不是真值');// 拋出 AssertionError: 不是真值

// 在 repl 中：

assert.ok(typeof 123 === 'string');// 拋出 AssertionError: false == true

// 在文件中（例如 test.js）：

assert.ok(typeof 123 === 'string');// 拋出 AssertionError: The expression evaluated to a falsy value:

// assert.ok(typeof 123 === 'string')

assert.ok(false);

// 拋出 AssertionError: The expression evaluated to a falsy value:?

// assert.ok(false)

assert.ok(0);

// 拋出 AssertionError: The expression evaluated to a falsy value:

//

// assert.ok(0)

// 等同于 `assert()`：

assert(0);// 拋出 AssertionError: The expression evaluated to a falsy value://// assert(0)

assert.rejects(block[,error][,message])

等待?block?的 promise 完成，如果?block?是一個函數(shù)，則立即調(diào)用該函數(shù)并等待返回的 promise 完成，然后檢查 promise 是否被 reject。

如果?block?是一個函數(shù)且同步地拋出一個錯誤，則?assert.rejects()?會返回一個被 reject 的?Promise?并傳入該錯誤。 如果該函數(shù)沒有返回一個 promise，則?assert.rejects()?會返回一個被 reject 的?Promise?并傳入?ERR_INVALID_RETURN_VALUE?錯誤。 以上兩種情況都會跳過錯誤處理函數(shù)。

該函數(shù)相當于?assert.throws()，除了需要等待完成的異步特性。

error?可以是?Class、RegExp、校驗函數(shù)、每個屬性都會被測試的對象、或每個屬性（包括不可枚舉的?message?和?name?屬性）都會被測試的錯誤實例。

如果指定了?message，則當?block?沒被 reject 時，message?參數(shù)會作為?AssertionError?的錯誤信息。

(async () => {

await assert.rejects(

async () => {

throw new TypeError('錯誤信息'); },

{

name: 'TypeError',

message: '錯誤信息'

}

);

})();


assert.rejects(

Promise.reject(new Error('錯誤信息')),

Error).then(() => {

// ...

});

注意，error?不能是字符串。 如果第二個參數(shù)是字符串，則視為不傳入?error，且字符串會用于?message。 這可能會造成誤解。 如果需要使用字符串作為第二個參數(shù)，請仔細閱讀?assert.throws()?中的例子。

assert.strictEqual(actual,expected{,message])


使用?SameValue比較法測試?actual?參數(shù)與?expected?參數(shù)是否全等。

const assert = require('assert').strict;

assert.strictEqual(1, 2);

// 拋出 AssertionError [ERR_ASSERTION]: Input A expected to strictly equal input B:

// + expected - actual

// - 1

// + 2

assert.strictEqual(1, 1);

// 測試通過。

assert.strictEqual(1, '1');

// 拋出 AssertionError [ERR_ASSERTION]: Input A expected to strictly equal input B:

// +

expected - actual

// - 1

// + '1'

如果兩個值不全等，則拋出一個帶有?message?屬性的?AssertionError，其中?message?屬性的值等于傳入的?message?參數(shù)的值。 如果?message?參數(shù)為?undefined，則賦予默認的錯誤信息。 如果?message?參數(shù)是?Error?的實例，則會拋出它而不是?AssertionError。

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


斷言?block?函數(shù)會拋出錯誤。

error?可以是?Class、RegExp、校驗函數(shù)、每個屬性都會被測試是否深度全等的校驗對象、或每個屬性（包括不可枚舉的?message?和?name?屬性）都會被測試是否深度全等的錯誤實例。 當使用對象時，可以使用正則表達式來校驗字符串屬性。 詳見下面的例子。

如果指定了?message?參數(shù)，則當?block?函數(shù)不拋出錯誤時，message?參數(shù)會作為?AssertionError?的錯誤信息。

例子，error?參數(shù)為自定義的校驗對象或錯誤實例：

const err = new TypeError('錯誤信息');

err.code = 404;

err.foo = 'bar';

err.info = {

nested: true,

baz: 'text'

};

err.reg = /abc/i;

assert.throws(

() => {

throw err;

}, {

name: 'TypeError',

message: '錯誤信息'

info: {

nested: true,

baz: 'text' }

// 注意，只有校驗對象的屬性會被測試。

// 使用嵌套的對象必須提供全部屬性，否則校驗會失敗。

});

// 使用正則表達式來校驗錯誤屬性：

assert.throws(

() => {

throw err;

},

{

// `name` 和 `message` 屬性為字符串，對它們使用正則表達式進行匹配。

// 如果校驗失敗，則拋出錯誤。

name: /^TypeError$/,

message: /錯誤信息/,

foo: 'bar',

info: {

nested: true,

// 嵌套的屬性不可以使用正則表達式！

baz: 'text' },

// `reg` 屬性包含了一個正則表達式，只有校驗對象也包含一個完全相同的正則表達式時，校驗才會通過。

reg: /abc/i

});

// 失敗，因為 `message` 屬性與 `name` 屬性不同：

assert.throws(

() => {

const otherErr = new Error('未找到');

otherErr.code = 404;

throw otherErr;

},

err // 會測試 `message`、`name` 和 `code`。

);

例子，error?參數(shù)為構(gòu)造函數(shù)：

assert.throws(

() => {

throw new Error('錯誤信息');

},

Error );

例子，error?參數(shù)為?RegExp：

使用正則表達式運行錯誤對象的?.toString， 且包括錯誤的名稱

assert.throws(

() => {

throw new Error('錯誤信息');

},

/^Error: 錯誤信息$/

);

例子，error?參數(shù)為自定義函數(shù)：

assert.throws(

() => {

throw new Error('錯誤信息');

}, function(err) {

if ((err instanceof Error) && /錯誤/.test(err)) {

return true;

}

},

'不是期望的錯誤' );

注意，error?不能是字符串。 如果第二個參數(shù)是字符串，則視為不傳入?error，且字符串會用于?message。 這可能會造成誤解。 使用與拋出的錯誤信息相同的信息，會導致?ERR_AMBIGUOUS_ARGUMENT?錯誤。 如果需要使用字符串作為第二個參數(shù)，請仔細閱讀下面的例子。

function throwingFirst() {

throw new Error('錯誤一');

}

function throwingSecond() {

throw new Error('錯誤二');

}

function notThrowing() {}

// 第二個參數(shù)為字符串，且輸入函數(shù)拋出了錯誤。

// 第一個例子不會拋出錯誤，因為它沒有匹配到輸入函數(shù)拋出的錯誤信息！

assert.throws(throwingFirst, '錯誤二');

// 第二個例子中，傳入的信息接近錯誤信息，

// 且沒有表述清楚用戶是否有意匹配錯誤信息，

// 所以 Node.js 會拋出 `ERR_AMBIGUOUS_ARGUMENT` 錯誤。

assert.throws(throwingSecond, '錯誤二');

// 拋出錯誤：

// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// 當函數(shù)沒有拋出錯誤時，字符串可用于錯誤信息：

assert.throws(notThrowing, '錯誤二');

// 拋出 AssertionError [ERR_ASSERTION]: Missing expected exception: 錯誤二

// 如果想要匹配到錯誤信息，可以如下：

assert.throws(throwingSecond, /錯誤二$/);

// 沒有拋出錯誤，因為錯誤信息匹配。

assert.throws(throwingFirst, /錯誤二$/);

// 拋出錯誤：

// Error: 錯誤一

// at throwingFirst (repl:2:9)

鑒于會混淆語句，建議不要使用字符串作為第二個參數(shù)。 這可能會導致不易定位的錯誤。

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容