assert.equal()

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

使用相等运算符（==）测试 actual 参数与 expected 参数是否相等（通俗解释equal方法接受三个参数，第一个参数是实际值，第二个是预期值，第三个是错误的提示信息。）。

 1 // 格式
 2 assert.equal(actual, expected, [message])
 3 
 4 assert.equal(true, value, message);
 5 // 等同于
 6 assert(value, message);
 7 
 8 // 例子
 9 var assert = require('assert');
10 
11 function add (a, b) {
12   return a + b;
13 }
14 
15 var expected = add(1,2);
16 
17 // 以下三句效果相同
18 assert(expected == 3, '预期1+2等于3');
19 assert.ok(expected == 3, '预期1+2等于3');
20 assert.equal(expected, 3, '预期1+2等于3');

 1 const assert = require('assert');
 2 
 3 assert.equal(1, 1);
 4 // 测试通过，1 == 1。
 5 assert.equal(1, '1');
 6 // 测试通过，1 == '1'。
 7 
 8 assert.equal(1, 2);
 9 // 抛出 AssertionError: 1 == 2
10 assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
11 // 抛出 AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

如果两个值不相等，则抛出一个带有 message 属性的 AssertionError，其中 message 属性的值等于传入的 message 参数的值。如果 message 参数为 undefined，则赋予默认的错误信息，equal方法内部使用的是相等运算符（==），而不是严格运算符（===），进行比较运算。

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

测试 actual 参数与 expected 参数是否深度相等。原始值使用相等运算符（==）比较。（通俗解释deepEqual方法用来比较两个对象。只要它们的属性一一对应，且值都相等，就认为两个对象相等，否则抛出一个错误。）

只测试可枚举的自身属性，不测试对象的原型、连接符、或不可枚举的属性（这些情况使用 assert.deepStrictEqual()）。

 1 // 格式
 2 assert.deepEqual(actual, expected, [message])
 3 
 4 // 例子
 5 var assert = require('assert');
 6 
 7 var list1 = [1, 2, 3, 4, 5];
 8 var list2 = [1, 2, 3, 4, 5];
 9 
10 assert.deepEqual(list1, list2, '预期两个数组应该有相同的属性');
11 //预期两个数组应该有相同属性
12 var person1 = { "name":"john", "age":"21" };
13 var person2 = { "name":"john", "age":"21" };
14 
15 assert.deepEqual(person1, person2, '预期两个对象应该有相同的属性');

   //预期两个数组应该有相同属性

Map 和 Set 包含的子项也会被测试。

子对象中可枚举的自身属性也会被测试：

View Code

如果两个值不相等，则抛出一个带有 message 属性的 AssertionError，其中 message 属性的值等于传入的 message 参数的值。如果 message 参数为 undefined，则赋予默认的错误信息。

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

测试 actual 参数与 expected 参数是否不深度相等。与 assert.deepEqual() 相反。

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);
// 测试通过，obj1 与 obj2 不深度相等。

assert.notDeepEqual(obj1, obj3);
// 抛出 AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4);
// 测试通过，obj1 与 obj4 不深度相等。

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

使用不等运算符（!=）测试 actual 参数与 expected 参数是否不相等(通俗解释notEqual方法的用法与equal方法类似，但只有在实际值等于预期值时，才会抛出错误)

 1 const assert = require('assert');
 2 
 3 assert.notEqual(1, 2);
 4 // 测试通过。
 5 
 6 assert.notEqual(1, 1);
 7 // 抛出 AssertionError: 1 != 1
 8 
 9 assert.notEqual(1, '1');
10 // 抛出 AssertionError: 1 != '1'

// 格式
assert.notEqual(actual, expected, [message])

// 用法
var assert = require('assert');

function add (a, b) {
  return a + b;
}

var expected = add(1,2);

// 以下三种写法效果相同
assert(expected != 4, '预期不等于4');
assert.ok(expected != 4, '预期不等于4');
assert.notEqual(expected, 4, '预期不等于4');

注意：notEqual方法内部使用不相等运算符（!=），而不是严格不相等运算符（!==），进行比较运算。