斷言
assert 風格與 node.js 內建的 assert 模組非常相似，但多了一些額外的功能。在三種風格選項中，assert 是唯一不可鏈式的。請查看 風格指南 以進行比較。
API 參考
assert(expression, message)
撰寫你自己的測試表達式。
assert('foo' !== 'bar', 'foo is not bar');
assert(Array.isArray([]), 'empty arrays are arrays');
.fail([message])
.fail(actual, expected, [message], [operator])
拋出失敗。與 Node.js assert 模組相容。
assert.fail();
assert.fail("custom error message");
assert.fail(1, 2);
assert.fail(1, 2, "custom error message");
assert.fail(1, 2, "custom error message", ">");
assert.fail(1, 2, undefined, ">");
.isOk(object, [message])
斷言 object 為真值。
assert.isOk('everything', 'everything is ok');
assert.isOk(false, 'this will fail');
.isNotOk(object, [message])
斷言 object 為假值。
assert.isNotOk('everything', 'this will fail');
assert.isNotOk(false, 'this will pass');
.equal(actual, expected, [message])
斷言 actual 和 expected 非嚴格相等 (==)。
assert.equal(3, '3', '== coerces values to strings');
.notEqual(actual, expected, [message])
斷言 actual 和 expected 非嚴格不相等 (!=)。
assert.notEqual(3, 4, 'these numbers are not equal');
.strictEqual(actual, expected, [message])
斷言 actual 和 expected 嚴格相等 (===)。
assert.strictEqual(true, true, 'these booleans are strictly equal');
.notStrictEqual(actual, expected, [message])
斷言 actual 和 expected 嚴格不相等 (!==)。
assert.notStrictEqual(3, '3', 'no coercion for strict equality');
.deepEqual(actual, expected, [message])
斷言 actual 與 expected 深度相等。
assert.deepEqual({ tea: 'green' }, { tea: 'green' });
.notDeepEqual(actual, expected, [message])
斷言 actual 與 expected 深度不相等。
assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });
.isAbove(valueToCheck, valueToBeAbove, [message])
斷言 valueToCheck 嚴格大於 (>) valueToBeAbove。
assert.isAbove(5, 2, '5 is strictly greater than 2');
.isAtLeast(valueToCheck, valueToBeAtLeast, [message])
斷言 valueToCheck 大於或等於 (>=) valueToBeAtLeast。
assert.isAtLeast(5, 2, '5 is greater or equal to 2');
assert.isAtLeast(3, 3, '3 is greater or equal to 3');
.isBelow(valueToCheck, valueToBeBelow, [message])
斷言 valueToCheck 嚴格小於 (<) valueToBeBelow。
assert.isBelow(3, 6, '3 is strictly less than 6');
.isAtMost(valueToCheck, valueToBeAtMost, [message])
斷言 valueToCheck 小於或等於 (<=) valueToBeAtMost。
assert.isAtMost(3, 6, '3 is less than or equal to 6');
assert.isAtMost(4, 4, '4 is less than or equal to 4');
.isTrue(value, [message])
斷言 value 為 true。
var teaServed = true;
assert.isTrue(teaServed, 'the tea has been served');
.isNotTrue(value, [message])
斷言 value 不為 true。
var tea = 'tasty chai';
assert.isNotTrue(tea, 'great, time for tea!');
.isFalse(value, [message])
斷言 value 為 false。
var teaServed = false;
assert.isFalse(teaServed, 'no tea yet? hmm...');
.isNotFalse(value, [message])
斷言 value 不為 false。
var tea = 'tasty chai';
assert.isNotFalse(tea, 'great, time for tea!');
.isNull(value, [message])
斷言 value 為 null。
assert.isNull(err, 'there was no error');
.isNotNull(value, [message])
斷言 value 不為 null。
var tea = 'tasty chai';
assert.isNotNull(tea, 'great, time for tea!');
.isNaN
斷言值為 NaN。
assert.isNaN(NaN, 'NaN is NaN');
.isNotNaN
斷言值不為 NaN。
assert.isNotNaN(4, '4 is not NaN');
.exists
斷言目標既不是 null 也不是 undefined。
var foo = 'hi';
assert.exists(foo, 'foo is neither `null` nor `undefined`');
.notExists
斷言目標為 null 或 undefined 其中之一。
var bar = null
, baz;
assert.notExists(bar);
assert.notExists(baz, 'baz is either null or undefined');
.isUndefined(value, [message])
斷言 value 為 undefined。
var tea;
assert.isUndefined(tea, 'no tea defined');
.isDefined(value, [message])
斷言 value 不為 undefined。
var tea = 'cup of chai';
assert.isDefined(tea, 'tea has been defined');
.isFunction(value, [message])
斷言 value 為函式。
function serveTea() { return 'cup of tea'; };
assert.isFunction(serveTea, 'great, we can have tea now');
.isNotFunction(value, [message])
斷言 value 不為函式。
var serveTea = [ 'heat', 'pour', 'sip' ];
assert.isNotFunction(serveTea, 'great, we have listed the steps');
.isObject(value, [message])
斷言 value 是一個 ‘Object’ 類型的物件（由 Object.prototype.toString 顯示）。此斷言不匹配子類物件。
var selection = { name: 'Chai', serve: 'with spices' };
assert.isObject(selection, 'tea selection is an object');
.isNotObject(value, [message])
斷言 value 不是 ‘Object’ 類型的物件（由 Object.prototype.toString 顯示）。
var selection = 'chai'
assert.isNotObject(selection, 'tea selection is not an object');
assert.isNotObject(null, 'null is not an object');
.isArray(value, [message])
斷言 value 是一個陣列。
var menu = [ 'green', 'chai', 'oolong' ];
assert.isArray(menu, 'what kind of tea do we want?');
.isNotArray(value, [message])
斷言 value 不是一個陣列。
var menu = 'green|chai|oolong';
assert.isNotArray(menu, 'what kind of tea do we want?');
.isString(value, [message])
斷言 value 是一個字串。
var teaOrder = 'chai';
assert.isString(teaOrder, 'order placed');
.isNotString(value, [message])
斷言 value 不是一個字串。
var teaOrder = 4;
assert.isNotString(teaOrder, 'order placed');
.isNumber(value, [message])
斷言 value 是一個數字。
var cups = 2;
assert.isNumber(cups, 'how many cups');
.isNotNumber(value, [message])
斷言 value 不是一個數字。
var cups = '2 cups please';
assert.isNotNumber(cups, 'how many cups');
.isFinite(value, [message])
斷言 value 是一個有限的數字。與 .isNumber 不同，此斷言會針對 NaN 和 Infinity 失敗。
var cups = 2;
assert.isFinite(cups, 'how many cups');
assert.isFinite(NaN); // throws
.isBoolean(value, [message])
斷言 value 是一個布林值。
var teaReady = true
, teaServed = false;
assert.isBoolean(teaReady, 'is the tea ready');
assert.isBoolean(teaServed, 'has tea been served');
.isNotBoolean(value, [message])
斷言 value 不是一個布林值。
var teaReady = 'yep'
, teaServed = 'nope';
assert.isNotBoolean(teaReady, 'is the tea ready');
assert.isNotBoolean(teaServed, 'has tea been served');
.typeOf(value, name, [message])
斷言 value 的類型是 name，由 Object.prototype.toString 決定。
assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');
assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');
assert.typeOf('tea', 'string', 'we have a string');
assert.typeOf(/tea/, 'regexp', 'we have a regular expression');
assert.typeOf(null, 'null', 'we have a null');
assert.typeOf(undefined, 'undefined', 'we have an undefined');
.notTypeOf(value, name, [message])
斷言 value 的類型不是 name，由 Object.prototype.toString 決定。
assert.notTypeOf('tea', 'number', 'strings are not numbers');
.instanceOf(object, constructor, [message])
斷言 value 是 constructor 的一個實例。
var Tea = function (name) { this.name = name; }
, chai = new Tea('chai');
assert.instanceOf(chai, Tea, 'chai is an instance of tea');
.notInstanceOf(object, constructor, [message])
斷言 value 不是 constructor 的一個實例。
var Tea = function (name) { this.name = name; }
, chai = new String('chai');
assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea');
.include(haystack, needle, [message])
斷言 haystack 包含 needle。可以用來斷言一個值包含在陣列中、子字串包含在字串中，或者物件包含一組屬性。
assert.include([1,2,3], 2, 'array contains value');
assert.include('foobar', 'foo', 'string contains substring');
assert.include({ foo: 'bar', hello: 'universe' }, { foo: 'bar' }, 'object contains property');
使用嚴格相等 (===) 判斷。當斷言一個值包含在陣列中時，會搜尋陣列中是否有元素與給定值嚴格相等。當斷言物件包含一組屬性時，會搜尋物件中是否存在給定的屬性鍵，並檢查每個鍵是否存在且與給定的屬性值嚴格相等。例如：
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.include([obj1, obj2], obj1);
assert.include({foo: obj1, bar: obj2}, {foo: obj1});
assert.include({foo: obj1, bar: obj2}, {foo: obj1, bar: obj2});
.notInclude(haystack, needle, [message])
斷言 haystack 不包含 needle。可以用來斷言一個值不在陣列中、子字串不在字串中，或者物件不包含一組屬性。
assert.notInclude([1,2,3], 4, "array doesn't contain value");
assert.notInclude('foobar', 'baz', "string doesn't contain substring");
assert.notInclude({ foo: 'bar', hello: 'universe' }, { foo: 'baz' }, 'object doesn't contain property');
使用嚴格相等 (===) 判斷。當斷言一個值不在陣列中時，會搜尋陣列以確認沒有元素與給定值嚴格相等。當斷言物件不包含一組屬性時，會搜尋物件以確認至少有一個給定的屬性鍵不存在，或不與給定的屬性值嚴格相等。例如：
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.notInclude([obj1, obj2], {a: 1});
assert.notInclude({foo: obj1, bar: obj2}, {foo: {a: 1}});
assert.notInclude({foo: obj1, bar: obj2}, {foo: obj1, bar: {b: 2}});
.deepInclude(haystack, needle, [message])
斷言 haystack 包含 needle。可以用來斷言一個值包含在陣列中或物件包含一組屬性。使用深層相等判斷。
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.deepInclude([obj1, obj2], {a: 1});
assert.deepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}});
assert.deepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}, bar: {b: 2}});
.notDeepInclude(haystack, needle, [message])
斷言 haystack 不包含 needle。可以用來斷言一個值不在陣列中或物件不包含一組屬性。使用深層相等判斷。
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.notDeepInclude([obj1, obj2], {a: 9});
assert.notDeepInclude({foo: obj1, bar: obj2}, {foo: {a: 9}});
assert.notDeepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}, bar: {b: 9}});
.nestedInclude(haystack, needle, [message])
斷言 'haystack' 包含 'needle'。可以用來斷言物件中包含一組屬性。允許使用點號和方括號表示法來引用巢狀屬性。屬性名稱中的 '[]' 和 '.' 可以使用雙反斜線轉義。
assert.nestedInclude({'.a': {'b': 'x'}}, {'\\.a.[b]': 'x'});
assert.nestedInclude({'a': {'[b]': 'x'}}, {'a.\\[b\\]': 'x'});
.notNestedInclude(haystack, needle, [message])
斷言 'haystack' 不包含 'needle'。可以用來斷言物件中不包含一組屬性。允許使用點號和方括號表示法來引用巢狀屬性。屬性名稱中的 '[]' 和 '.' 可以使用雙反斜線轉義。
assert.notNestedInclude({'.a': {'b': 'x'}}, {'\\.a.b': 'y'});
assert.notNestedInclude({'a': {'[b]': 'x'}}, {'a.\\[b\\]': 'y'});
.deepNestedInclude(haystack, needle, [message])
斷言 'haystack' 包含 'needle'。可以用來斷言物件中包含一組屬性，同時檢查深層相等性。允許使用點號和方括號表示法來引用巢狀屬性。屬性名稱中的 '[]' 和 '.' 可以使用雙反斜線轉義。
assert.deepNestedInclude({a: {b: [{x: 1}]}}, {'a.b[0]': {x: 1}});
assert.deepNestedInclude({'.a': {'[b]': {x: 1}}}, {'\\.a.\\[b\\]': {x: 1}});
.notDeepNestedInclude(haystack, needle, [message])
斷言 'haystack' 不包含 'needle'。可以用來斷言物件中不包含一組屬性，同時檢查深層相等性。允許使用點號和方括號表示法來引用巢狀屬性。屬性名稱中的 '[]' 和 '.' 可以使用雙反斜線轉義。
assert.notDeepNestedInclude({a: {b: [{x: 1}]}}, {'a.b[0]': {y: 1}})
assert.notDeepNestedInclude({'.a': {'[b]': {x: 1}}}, {'\\.a.\\[b\\]': {y: 2}});
.ownInclude(haystack, needle, [message])
斷言 'haystack' 包含 'needle'。可以用來斷言物件中包含一組屬性，同時忽略繼承的屬性。
assert.ownInclude({ a: 1 }, { a: 1 });
.notOwnInclude(haystack, needle, [message])
斷言 'haystack' 包含 'needle'。可以用來斷言物件中不包含一組屬性，同時忽略繼承的屬性。
Object.prototype.b = 2;
assert.notOwnInclude({ a: 1 }, { b: 2 });
.deepOwnInclude(haystack, needle, [message])
斷言 'haystack' 包含 'needle'。可以用來斷言物件中包含一組屬性，同時忽略繼承的屬性並檢查深層相等性。
assert.deepOwnInclude({a: {b: 2}}, {a: {b: 2}});
.notDeepOwnInclude(haystack, needle, [message])
斷言 'haystack' 包含 'needle'。可以用來斷言物件中不包含一組屬性，同時忽略繼承的屬性並檢查深層相等性。
assert.notDeepOwnInclude({a: {b: 2}}, {a: {c: 3}});
.match(value, regexp, [message])
斷言 value 匹配正規表示式 regexp。
assert.match('foobar', /^foo/, 'regexp matches');
.notMatch(value, regexp, [message])
斷言 value 不匹配正規表示式 regexp。
assert.notMatch('foobar', /^foo/, 'regexp does not match');
.property(object, property, [message])
斷言 object 具有一個名為 property 的直接或繼承屬性。
assert.property({ tea: { green: 'matcha' }}, 'tea');
assert.property({ tea: { green: 'matcha' }}, 'toString');
.notProperty(object, property, [message])
斷言 object 不具有一個名為 property 的直接或繼承屬性。
assert.notProperty({ tea: { green: 'matcha' }}, 'coffee');
.propertyVal(object, property, value, [message])
斷言 object 具有一個名為 property 的直接或繼承屬性，且其值由 value 給定。使用嚴格相等檢查 (===)。
assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');
.notPropertyVal(object, property, value, [message])
斷言 object 不具有一個名為 property 的直接或繼承屬性，且其值由 value 給定。使用嚴格相等檢查 (===)。
assert.notPropertyVal({ tea: 'is good' }, 'tea', 'is bad');
assert.notPropertyVal({ tea: 'is good' }, 'coffee', 'is good');
.deepPropertyVal(object, property, value, [message])
斷言 object 具有一個名為 property 的直接或繼承屬性，且其值由 value 給定。使用深層相等檢查。
assert.deepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'matcha' });
.notDeepPropertyVal(object, property, value, [message])
斷言 object 不具有一個名為 property 的直接或繼承屬性，且其值由 value 給定。使用深層相等檢查。
assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { black: 'matcha' });
assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'oolong' });
assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'coffee', { green: 'matcha' });
.nestedProperty(object, property, [message])
斷言 object 具有一個名為 property 的直接或繼承屬性，property 可以是一個使用點號和方括號表示法表示巢狀引用的字串。
assert.nestedProperty({ tea: { green: 'matcha' }}, 'tea.green');
.notNestedProperty(object, property, [message])
斷言 object 不具有一個名為 property 的屬性，property 可以是一個使用點號和方括號表示法表示巢狀引用的字串。該屬性不能存在於物件中或其原型鏈上的任何地方。
assert.notNestedProperty({ tea: { green: 'matcha' }}, 'tea.oolong');
.nestedPropertyVal(object, property, value, [message])
斷言 object 物件擁有一個名為 property 的屬性，且其值為 value。property 可以使用點符號（dot-notation）和方括號符號（bracket-notation）來進行巢狀參照。使用嚴格相等性檢查（===）。
assert.nestedPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');
.notNestedPropertyVal(object, property, value, [message])
斷言 object 物件不擁有一個名為 property 的屬性，且其值為 value。property 可以使用點符號（dot-notation）和方括號符號（bracket-notation）來進行巢狀參照。使用嚴格相等性檢查（===）。
assert.notNestedPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');
assert.notNestedPropertyVal({ tea: { green: 'matcha' }}, 'coffee.green', 'matcha');
.deepNestedPropertyVal(object, property, value, [message])
斷言 object 物件擁有一個名為 property 的屬性，且其值為 value。property 可以使用點符號（dot-notation）和方括號符號（bracket-notation）來進行巢狀參照。使用深度相等性檢查。
assert.deepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yum' });
.notDeepNestedPropertyVal(object, property, value, [message])
斷言 object 物件不擁有一個名為 property 的屬性，且其值為 value。property 可以使用點符號（dot-notation）和方括號符號（bracket-notation）來進行巢狀參照。使用深度相等性檢查。
assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { oolong: 'yum' });
assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yuck' });
assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.black', { matcha: 'yum' });
.lengthOf(object, length, [message])
斷言 object 物件擁有預期的 length 或 size 值。
assert.lengthOf([1,2,3], 3, 'array has length of 3');
assert.lengthOf('foobar', 6, 'string has length of 6');
assert.lengthOf(new Set([1,2,3]), 3, 'set has size of 3');
assert.lengthOf(new Map([['a',1],['b',2],['c',3]]), 3, 'map has size of 3');
.hasAnyKeys(object, [keys], [message])
斷言 object 物件至少擁有一個提供的 keys。您也可以提供一個單一物件，而非 keys 陣列，而該物件的鍵將會被用作預期的鍵集合。
assert.hasAnyKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'iDontExist', 'baz']);
assert.hasAnyKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, iDontExist: 99, baz: 1337});
assert.hasAnyKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
assert.hasAnyKeys(new Set([{foo: 'bar'}, 'anotherKey']), [{foo: 'bar'}, 'anotherKey']);
.hasAllKeys(object, [keys], [message])
斷言 object 物件擁有全部且只有全部提供的 keys。您也可以提供一個單一物件，而非 keys 陣列，而該物件的鍵將會被用作預期的鍵集合。
assert.hasAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'bar', 'baz']);
assert.hasAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, bar: 99, baz: 1337]);
assert.hasAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
assert.hasAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}, 'anotherKey']);
.containsAllKeys(object, [keys], [message])
斷言 object 物件擁有全部提供的 keys，但可能擁有更多未列出的鍵。您也可以提供一個單一物件，而非 keys 陣列，而該物件的鍵將會被用作預期的鍵集合。
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'baz']);
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'bar', 'baz']);
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, baz: 1337});
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, bar: 99, baz: 1337});
assert.containsAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}]);
assert.containsAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
assert.containsAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}]);
assert.containsAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}, 'anotherKey']);
.doesNotHaveAnyKeys(object, [keys], [message])
斷言 object 物件不擁有任何提供的 keys。您也可以提供一個單一物件，而非 keys 陣列，而該物件的鍵將會被用作預期的鍵集合。
assert.doesNotHaveAnyKeys({foo: 1, bar: 2, baz: 3}, ['one', 'two', 'example']);
assert.doesNotHaveAnyKeys({foo: 1, bar: 2, baz: 3}, {one: 1, two: 2, example: 'foo'});
assert.doesNotHaveAnyKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{one: 'two'}, 'example']);
assert.doesNotHaveAnyKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{one: 'two'}, 'example']);
.doesNotHaveAllKeys(object, [keys], [message])
斷言 object 物件至少不擁有其中一個提供的 keys。您也可以提供一個單一物件，而非 keys 陣列，而該物件的鍵將會被用作預期的鍵集合。
assert.doesNotHaveAllKeys({foo: 1, bar: 2, baz: 3}, ['one', 'two', 'example']);
assert.doesNotHaveAllKeys({foo: 1, bar: 2, baz: 3}, {one: 1, two: 2, example: 'foo'});
assert.doesNotHaveAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{one: 'two'}, 'example']);
assert.doesNotHaveAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{one: 'two'}, 'example']);
.hasAnyDeepKeys(object, [keys], [message])
斷言 object 物件至少擁有一個提供的 keys。由於 Set 和 Map 可以將物件作為鍵，您可以使用此斷言執行深度比較。您也可以提供一個單一物件，而非 keys 陣列，而該物件的鍵將會被用作預期的鍵集合。
assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {one: 'one'});
assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), [{one: 'one'}, {two: 'two'}]);
assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);
assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {one: 'one'});
assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {three: 'three'}]);
assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);
.hasAllDeepKeys(object, [keys], [message])
斷言 object 物件擁有全部且只有全部提供的 keys。由於 Set 和 Map 可以將物件作為鍵，您可以使用此斷言執行深度比較。您也可以提供一個單一物件，而非 keys 陣列，而該物件的鍵將會被用作預期的鍵集合。
assert.hasAllDeepKeys(new Map([[{one: 'one'}, 'valueOne']]), {one: 'one'});
assert.hasAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);
assert.hasAllDeepKeys(new Set([{one: 'one'}]), {one: 'one'});
assert.hasAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);
.containsAllDeepKeys(object, [keys], [message])
斷言 object 物件包含全部提供的 keys。由於 Set 和 Map 可以將物件作為鍵，您可以使用此斷言執行深度比較。您也可以提供一個單一物件，而非 keys 陣列，而該物件的鍵將會被用作預期的鍵集合。
assert.containsAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {one: 'one'});
assert.containsAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);
assert.containsAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {one: 'one'});
assert.containsAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);
.doesNotHaveAnyDeepKeys(object, [keys], [message])
斷言 object 物件不擁有任何提供的 keys。由於 Set 和 Map 可以將物件作為鍵，您可以使用此斷言執行深度比較。您也可以提供一個單一物件，而非 keys 陣列，而該物件的鍵將會被用作預期的鍵集合。
assert.doesNotHaveAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {thisDoesNot: 'exist'});
assert.doesNotHaveAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{twenty: 'twenty'}, {fifty: 'fifty'}]);
assert.doesNotHaveAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {twenty: 'twenty'});
assert.doesNotHaveAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{twenty: 'twenty'}, {fifty: 'fifty'}]);
.doesNotHaveAllDeepKeys(object, [keys], [message])
斷言 object 物件至少不擁有其中一個提供的 keys。由於 Set 和 Map 可以將物件作為鍵，您可以使用此斷言執行深度比較。您也可以提供一個單一物件，而非 keys 陣列，而該物件的鍵將會被用作預期的鍵集合。
assert.doesNotHaveAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {thisDoesNot: 'exist'});
assert.doesNotHaveAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{twenty: 'twenty'}, {one: 'one'}]);
assert.doesNotHaveAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {twenty: 'twenty'});
assert.doesNotHaveAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {fifty: 'fifty'}]);
.throws(fn, [errorLike/string/regexp], [string/regexp], [message])
如果 errorLike 是一個 Error 建構函式，則斷言 fn 將會拋出一個屬於 errorLike 實例的錯誤。如果 errorLike 是一個 Error 實例，則斷言拋出的錯誤與 errorLike 是同一個實例。如果提供了 errMsgMatcher，它也會斷言拋出的錯誤訊息與 errMsgMatcher 相符。
assert.throws(fn, 'Error thrown must have this msg');
assert.throws(fn, /Error thrown must have a msg that matches this/);
assert.throws(fn, ReferenceError);
assert.throws(fn, errorInstance);
assert.throws(fn, ReferenceError, 'Error thrown must be a ReferenceError and have this msg');
assert.throws(fn, errorInstance, 'Error thrown must be the same errorInstance and have this msg');
assert.throws(fn, ReferenceError, /Error thrown must be a ReferenceError and match this/);
assert.throws(fn, errorInstance, /Error thrown must be the same errorInstance and match this/);
.doesNotThrow(fn, [errorLike/string/regexp], [string/regexp], [message])
如果 errorLike 是一個 Error 建構函式，則斷言 fn 不會拋出一個屬於 errorLike 實例的錯誤。如果 errorLike 是一個 Error 實例，則斷言拋出的錯誤不是與 errorLike 是同一個實例。如果提供了 errMsgMatcher，它也會斷言拋出的錯誤訊息不與 errMsgMatcher 相符。
assert.doesNotThrow(fn, 'Any Error thrown must not have this message');
assert.doesNotThrow(fn, /Any Error thrown must not match this/);
assert.doesNotThrow(fn, Error);
assert.doesNotThrow(fn, errorInstance);
assert.doesNotThrow(fn, Error, 'Error must not have this message');
assert.doesNotThrow(fn, errorInstance, 'Error must not have this message');
assert.doesNotThrow(fn, Error, /Error must not match this/);
assert.doesNotThrow(fn, errorInstance, /Error must not match this/);
.operator(val1, operator, val2, [message])
使用 operator 比較兩個值。
assert.operator(1, '<', 2, 'everything is ok');
assert.operator(1, '>', 2, 'this will fail');
.closeTo(actual, expected, delta, [message])
斷言目標值在 +/- delta 範圍內等於 expected。
assert.closeTo(1.5, 1, 0.5, 'numbers are close');
.approximately(actual, expected, delta, [message])
斷言目標值在 +/- delta 範圍內等於 expected。
assert.approximately(1.5, 1, 0.5, 'numbers are close');
.sameMembers(set1, set2, [message])
斷言 set1 和 set2 擁有相同的成員，順序不拘。使用嚴格相等性檢查（===）。
assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');
.notSameMembers(set1, set2, [message])
斷言 set1 和 set2 不擁有相同的成員，順序不拘。使用嚴格相等性檢查（===）。
assert.notSameMembers([ 1, 2, 3 ], [ 5, 1, 3 ], 'not same members');
.sameDeepMembers(set1, set2, [message])
斷言 set1 和 set2 擁有相同的成員，順序不拘。使用深度相等性檢查。
assert.sameDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [{ b: 2 }, { a: 1 }, { c: 3 }], 'same deep members');
.notSameDeepMembers(set1, set2, [message])
斷言 set1 和 set2 不擁有相同的成員，順序不拘。使用深度相等性檢查。
assert.notSameDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [{ b: 2 }, { a: 1 }, { f: 5 }], 'not same deep members');
.sameOrderedMembers(set1, set2, [message])
斷言 set1 和 set2 擁有相同的成員，且順序相同。使用嚴格相等性檢查（===）。
assert.sameOrderedMembers([ 1, 2, 3 ], [ 1, 2, 3 ], 'same ordered members');
.notSameOrderedMembers(set1, set2, [message])
斷言 set1 和 set2 不擁有相同的成員，或順序不相同。使用嚴格相等性檢查（===）。
assert.notSameOrderedMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'not same ordered members');
.sameDeepOrderedMembers(set1, set2, [message])
斷言 set1 和 set2 擁有相同的成員，且順序相同。使用深度相等性檢查。
assert.sameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { c: 3 } ], 'same deep ordered members');
.notSameDeepOrderedMembers(set1, set2, [message])
斷言 set1 和 set2 不擁有相同的成員，或順序不同。使用深度相等性檢查。
assert.notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { z: 5 } ], 'not same deep ordered members');
assert.notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { c: 3 } ], 'not same deep ordered members');
.includeMembers(superset, subset, [message])
斷言 subset 以任意順序被包含在 superset 中。使用嚴格相等性檢查 (===)。重複的成員會被忽略。
assert.includeMembers([ 1, 2, 3 ], [ 2, 1, 2 ], 'include members');
.notIncludeMembers(superset, subset, [message])
斷言 subset 沒有以任意順序被包含在 superset 中。使用嚴格相等性檢查 (===)。重複的成員會被忽略。
assert.notIncludeMembers([ 1, 2, 3 ], [ 5, 1 ], 'not include members');
.includeDeepMembers(superset, subset, [message])
斷言 subset 以任意順序被包含在 superset 中。使用深度相等性檢查。重複的成員會被忽略。
assert.includeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { b: 2 } ], 'include deep members');
.notIncludeDeepMembers(superset, subset, [message])
斷言 subset 沒有以任意順序被包含在 superset 中。使用深度相等性檢查。重複的成員會被忽略。
assert.notIncludeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { f: 5 } ], 'not include deep members');
.includeOrderedMembers(superset, subset, [message])
斷言 subset 以與 superset 相同的順序（從第一個元素開始）被包含在 superset 中。使用嚴格相等性檢查 (===)。
assert.includeOrderedMembers([ 1, 2, 3 ], [ 1, 2 ], 'include ordered members');
.notIncludeOrderedMembers(superset, subset, [message])
斷言 subset 沒有以與 superset 相同的順序（從第一個元素開始）被包含在 superset 中。使用嚴格相等性檢查 (===)。
assert.notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 1 ], 'not include ordered members');
assert.notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 3 ], 'not include ordered members');
.includeDeepOrderedMembers(superset, subset, [message])
斷言 subset 以與 superset 相同的順序（從第一個元素開始）被包含在 superset 中。使用深度相等性檢查。
assert.includeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 } ], 'include deep ordered members');
.notIncludeDeepOrderedMembers(superset, subset, [message])
斷言 subset 沒有以與 superset 相同的順序（從第一個元素開始）被包含在 superset 中。使用深度相等性檢查。
assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { f: 5 } ], 'not include deep ordered members');
assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 } ], 'not include deep ordered members');
assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { c: 3 } ], 'not include deep ordered members');
.oneOf(inList, list, [message])
斷言非物件、非陣列的值 inList 出現在扁平陣列 list 中。
assert.oneOf(1, [ 2, 1 ], 'Not found in list');
.changes(function, object, property, [message])
斷言函數會改變屬性的值。
var obj = { val: 10 };
var fn = function() { obj.val = 22 };
assert.changes(fn, obj, 'val');
.changesBy(function, object, property, delta, [message])
斷言函數會將屬性的值改變一個數值 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val += 2 };
assert.changesBy(fn, obj, 'val', 2);
.doesNotChange(function, object, property, [message])
斷言函數不會改變屬性的值。
var obj = { val: 10 };
var fn = function() { console.log('foo'); };
assert.doesNotChange(fn, obj, 'val');
.changesButNotBy(function, object, property, delta, [message])
斷言函數不會將屬性的值或函數的返回值改變一個數值 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val += 10 };
assert.changesButNotBy(fn, obj, 'val', 5);
.increases(function, object, property, [message])
斷言函數會增加數值物件屬性。
var obj = { val: 10 };
var fn = function() { obj.val = 13 };
assert.increases(fn, obj, 'val');
.increasesBy(function, object, property, delta, [message])
斷言函數會將數值物件屬性或函數的返回值增加一個數值 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val += 10 };
assert.increasesBy(fn, obj, 'val', 10);
.doesNotIncrease(function, object, property, [message])
斷言函數不會增加數值物件屬性。
var obj = { val: 10 };
var fn = function() { obj.val = 8 };
assert.doesNotIncrease(fn, obj, 'val');
.increasesButNotBy(function, object, property, delta, [message])
斷言函數不會將數值物件屬性或函數的返回值增加一個數值 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val = 15 };
assert.increasesButNotBy(fn, obj, 'val', 10);
.decreases(function, object, property, [message])
斷言函數會減少數值物件屬性。
var obj = { val: 10 };
var fn = function() { obj.val = 5 };
assert.decreases(fn, obj, 'val');
.decreasesBy(function, object, property, delta, [message])
斷言函數會將數值物件屬性或函數的返回值減少一個數值 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val -= 5 };
assert.decreasesBy(fn, obj, 'val', 5);
.doesNotDecrease(function, object, property, [message])
斷言函數不會減少數值物件屬性。
var obj = { val: 10 };
var fn = function() { obj.val = 15 };
assert.doesNotDecrease(fn, obj, 'val');
.doesNotDecreaseBy(function, object, property, delta, [message])
斷言函數不會將數值物件屬性或函數的返回值減少一個數值 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val = 5 };
assert.doesNotDecreaseBy(fn, obj, 'val', 1);
.decreasesButNotBy(function, object, property, delta, [message])
斷言函數不會將數值物件屬性或函數的返回值減少一個數值 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val = 5 };
assert.decreasesButNotBy(fn, obj, 'val', 1);
.ifError(object)
斷言如果值不是假值，如果值是真值則拋出錯誤。這是為了讓 chai 可以作為 Node 的 assert 類別的替代品。
var err = new Error('I am a custom error');
assert.ifError(err); // Rethrows err!
.isExtensible(object)
斷言 object 是可擴展的（可以新增屬性）。
assert.isExtensible({});
.isNotExtensible(object)
斷言 object 是不可擴展的。
var nonExtensibleObject = Object.preventExtensions({});
var sealedObject = Object.seal({});
var frozenObject = Object.freeze({});
assert.isNotExtensible(nonExtensibleObject);
assert.isNotExtensible(sealedObject);
assert.isNotExtensible(frozenObject);
.isSealed(object)
斷言 object 是密封的（無法新增屬性，且現有的屬性也無法移除）。
var sealedObject = Object.seal({});
var frozenObject = Object.seal({});
assert.isSealed(sealedObject);
assert.isSealed(frozenObject);
.isNotSealed(object)
斷言 object 是不密封的。
assert.isNotSealed({});
.isFrozen(object)
斷言 object 是凍結的（無法新增屬性，且現有的屬性也無法修改）。
var frozenObject = Object.freeze({});
assert.frozen(frozenObject);
.isNotFrozen(object)
斷言 object 是不凍結的。
assert.isNotFrozen({});
.isEmpty(target)
斷言目標不包含任何值。對於陣列和字串，它檢查 length 屬性。對於 Map 和 Set 實例，它檢查 size 屬性。對於非函數物件，它會取得自身可列舉字串鍵的計數。
assert.isEmpty([]);
assert.isEmpty('');
assert.isEmpty(new Map);
assert.isEmpty({});
.isNotEmpty(target)
斷言目標包含值。對於陣列和字串，它檢查 length 屬性。對於 Map 和 Set 實例，它檢查 size 屬性。對於非函數物件，它會取得自身可列舉字串鍵的計數。
assert.isNotEmpty([1, 2]);
assert.isNotEmpty('34');
assert.isNotEmpty(new Set([5, 6]));
assert.isNotEmpty({ key: 7 });