assert.equal()

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

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

 // 格式

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

 assert.equal(true, value, message);

 // 等同于

 assert(value, message);

 // 例子

 var assert = require('assert');

 function add (a, b) {

   return a + b;

 }

 var expected = add(1,2);

 // 以下三句效果相同

 assert(expected == 3, '预期1+2等于3');

 assert.ok(expected == 3, '预期1+2等于3');

 assert.equal(expected, 3, '预期1+2等于3');

 const assert = require('assert');

 assert.equal(1, 1);

 // 测试通过，1 == 1。

 assert.equal(1, '1');

 // 测试通过，1 == '1'。

 assert.equal(1, 2);

 // 抛出 AssertionError: 1 == 2

 assert.equal({ a: { b: 1 } }, { a: { b: 1 } });

 // 抛出 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 包含的子项也会被测试。

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

如果两个值不相等，则抛出一个带有 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方法类似，但只有在实际值等于预期值时，才会抛出错误)

 const assert = require('assert');

 assert.notEqual(1, 2);

 // 测试通过。

 assert.notEqual(1, 1);

 // 抛出 AssertionError: 1 != 1

 assert.notEqual(1, '1');

 // 抛出 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方法内部使用不相等运算符（!=），而不是严格不相等运算符（!==），进行比较运算。