首页 >> js开发 >> JavaScriptNode.js API详解之 assert模块用法实例分析
JavaScriptNode.js API详解之 assert模块用法实例分析
发布时间: 2021年1月13日 | 浏览:
| 分类:js开发
本文实例讲述了Node.js API详解之 assert模块用法。分享给大家供大家参考，具体如下：Node.js API详解之 assertassert 模块提供了断言测试的函数，用于测试不变式。
断言是编程术语，表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真，
可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。
同样，程序投入运行后，最终用户在遇到问题时可以重新启用断言。
使用断言可以创建更稳定、品质更好且不易于出错的代码。
当需要在一个值为false时中断当前操作的话，可以使用断言。
单元测试必须使用断言（Junit/JunitX）。使用方式：
const assert = require('assert');
const assert = require('assert');
assert.ok(value[, message])说明：
测试 value 是否为真值。 相当于 assert.equal(!!value, true, message)。
如果 value 不为真值，则抛出一个带有 message 属性的 AssertionError，
其中 message 属性的值等于传入的 message 参数的值。
如果 message 参数为 undefined，则赋予默认的错误信息。
测试 value 是否为真值。 相当于 assert.equal(!!value, true, message)。
如果 value 不为真值，则抛出一个带有 message 属性的 AssertionError，
其中 message 属性的值等于传入的 message 参数的值。
如果 message 参数为 undefined，则赋予默认的错误信息。demo：
const assert = require('assert');
assert.ok(true);
// 测试通过。
assert.ok(1);
// 测试通过。
assert.ok(false);
// 抛出 "AssertionError: false == true"
assert.ok(0);
// 抛出 "AssertionError: 0 == true"
assert.ok(false, '不是真值');
// 抛出 "AssertionError: 不是真值"
const assert = require('assert');
assert.ok(true);
// 测试通过。
assert.ok(1);
// 测试通过。
assert.ok(false);
// 抛出 "AssertionError: false == true"
assert.ok(0);
// 抛出 "AssertionError: 0 == true"
assert.ok(false, '不是真值');
// 抛出 "AssertionError: 不是真值"
assert(value[, message])说明：
assert.ok() 的别名。
用法与 assert.ok() 相同。
assert.ok() 的别名。
用法与 assert.ok() 相同。demo：
const assert = require('assert');
assert(true);
// 测试通过。
assert(1);
// 测试通过。
assert(false);
// 抛出 "AssertionError: false == true"
assert(0);
// 抛出 "AssertionError: 0 == true"
assert(false, '不是真值');
// 抛出 "AssertionError: 不是真值"
const assert = require('assert');
assert(true);
// 测试通过。
assert(1);
// 测试通过。
assert(false);
// 抛出 "AssertionError: false == true"
assert(0);
// 抛出 "AssertionError: 0 == true"
assert(false, '不是真值');
// 抛出 "AssertionError: 不是真值"
assert.ifError(value)说明：
如果 value 为真，则抛出 value。 可用于测试回调函数的 error 参数。
源码：function ifError(err) { if (err) throw err; };
如果 value 为真，则抛出 value。 可用于测试回调函数的 error 参数。
源码：function ifError(err) { if (err) throw err; };demo：
const assert = require('assert');
assert.ifError(0);
// 通过。
assert.ifError(1);
// 抛出 1。
assert.ifError('error');
// 抛出 'error'。
assert.ifError(new Error());
// 抛出 Error。
const assert = require('assert');
assert.ifError(0);
// 通过。
assert.ifError(1);
// 抛出 1。
assert.ifError('error');
// 抛出 'error'。
assert.ifError(new Error());
// 抛出 Error。
assert.equal(actual, expected[, message])说明：
使用相等运算符（==）测试 actual 参数与 expected 参数是否相等
使用相等运算符（==）测试 actual 参数与 expected 参数是否相等demo：
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 } }
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 } }
assert.deepEqual(actual, expected[, message])说明：
测试 actual 参数与 expected 参数是否深度相等。 原始值使用相等运算符（==）比较。
只测试可枚举的自身属性，不测试对象的原型、连接符、或不可枚举的属性（这些情况使用 assert.deepStrictEqual()）。
Map 和 Set 包含的子项也会被测试。
如果两个值不相等，则抛出一个带有 message 属性的 AssertionError，
其中 message 属性的值等于传入的 message 参数的值。
如果 message 参数为 undefined，则赋予默认的错误信息。
测试 actual 参数与 expected 参数是否深度相等。 原始值使用相等运算符（==）比较。
只测试可枚举的自身属性，不测试对象的原型、连接符、或不可枚举的属性（这些情况使用 assert.deepStrictEqual()）。
Map 和 Set 包含的子项也会被测试。
如果两个值不相等，则抛出一个带有 message 属性的 AssertionError，
其中 message 属性的值等于传入的 message 参数的值。
如果 message 参数为 undefined，则赋予默认的错误信息。demo：
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.deepEqual(/a/gi, new Date());
//测试通过，因为 RegExp 对象的属性不是可枚举的：
assert.deepEqual(obj1, obj1);
// 测试通过，对象与自身相等。
assert.deepEqual(obj1, obj2);
// 抛出 AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
// 因为 b 属性的值不同。
assert.deepEqual(obj1, obj3);
// 测试通过，两个对象相等。
assert.deepEqual(obj1, obj4);
// 抛出 AssertionError: { a: { b: 1 } } 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.deepEqual(/a/gi, new Date());
//测试通过，因为 RegExp 对象的属性不是可枚举的：
assert.deepEqual(obj1, obj1);
// 测试通过，对象与自身相等。
assert.deepEqual(obj1, obj2);
// 抛出 AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
// 因为 b 属性的值不同。
assert.deepEqual(obj1, obj3);
// 测试通过，两个对象相等。
assert.deepEqual(obj1, obj4);
// 抛出 AssertionError: { a: { b: 1 } } deepEqual {}
// 因为不测试原型。
assert.deepStrictEqual(actual, expected[, message])说明：
与 assert.deepEqual() 大致相同，但有一些区别：
1.原始值使用全等运算符（===）比较。Set 的值与 Map 的键使用 SameValueZero 比较。
2.对象的原型也使用全等运算符比较。
3.对象的类型标签要求相同。
4.比较[对象包装器][]时，其对象和里面的值要求相同。
与 assert.deepEqual() 大致相同，但有一些区别：
1.原始值使用全等运算符（===）比较。Set 的值与 Map 的键使用 SameValueZero 比较。
2.对象的原型也使用全等运算符比较。
3.对象的类型标签要求相同。
4.比较[对象包装器][]时，其对象和里面的值要求相同。demo：
const assert = require('assert');
assert.deepEqual({ a: 1 }, { a: '1' });
// 测试通过，因为 1 == '1'。
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// 抛出 AssertionError: { a: 1 } deepStrictEqual { a: '1' }
// 因为使用全等运算符 1 !== '1'。
// 以下对象都没有自身属性。
const date = new Date();
const object = {};
const fakeDate = {};
Object.setPrototypeOf(fakeDate, Date.prototype);
assert.deepEqual(object, fakeDate);
// 测试通过，不测试原型。
assert.deepStrictEqual(object, fakeDate);
// 抛出 AssertionError: {} deepStrictEqual Date {}
// 因为原型不同。
assert.deepEqual(date, fakeDate);
// 测试通过，不测试类型标签。
assert.deepStrictEqual(date, fakeDate);
// 抛出 AssertionError: 2021-03-11T14:25:31.849Z deepStrictEqual Date {}
// 因为类型标签不同。
assert.deepStrictEqual(new Number(1), new Number(2));
// 测试不通过，因为数值对象包装器里面的数值也会被比较。
assert.deepStrictEqual(new String('foo'), Object('foo'));
// 测试通过，因为这两个对象和里面的字符串都是相同的
const assert = require('assert');
assert.deepEqual({ a: 1 }, { a: '1' });
// 测试通过，因为 1 == '1'。
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// 抛出 AssertionError: { a: 1 } deepStrictEqual { a: '1' }
// 因为使用全等运算符 1 !== '1'。
// 以下对象都没有自身属性。
const date = new Date();
const object = {};
const fakeDate = {};
Object.setPrototypeOf(fakeDate, Date.prototype);
assert.deepEqual(object, fakeDate);
// 测试通过，不测试原型。
assert.deepStrictEqual(object, fakeDate);
// 抛出 AssertionError: {} deepStrictEqual Date {}
// 因为原型不同。
assert.deepEqual(date, fakeDate);
// 测试通过，不测试类型标签。
assert.deepStrictEqual(date, fakeDate);
// 抛出 AssertionError: 2021-03-11T14:25:31.849Z deepStrictEqual Date {}
// 因为类型标签不同。
assert.deepStrictEqual(new Number(1), new Number(2));
// 测试不通过，因为数值对象包装器里面的数值也会被比较。
assert.deepStrictEqual(new String('foo'), Object('foo'));
// 测试通过，因为这两个对象和里面的字符串都是相同的
assert.strictEqual(actual, expected[, message])说明：
使用全等运算符（===）测试 actual 参数与 expected 参数是否全等。
使用全等运算符（===）测试 actual 参数与 expected 参数是否全等。demo：
onst assert = require('assert');
assert.strictEqual(1, 2);
// 抛出 AssertionError: 1 === 2
assert.strictEqual(1, 1);
// 测试通过。
assert.strictEqual(1, '1');
// 抛出 AssertionError: 1 === '1'
onst assert = require('assert');
assert.strictEqual(1, 2);
// 抛出 AssertionError: 1 === 2
assert.strictEqual(1, 1);
// 测试通过。
assert.strictEqual(1, '1');
// 抛出 AssertionError: 1 === '1'
assert.notEqual(actual, expected[, message])说明：
使用不等运算符（!=）测试 actual 参数与 expected 参数是否不相等。
使用不等运算符（!=）测试 actual 参数与 expected 参数是否不相等。demo：
const assert = require('assert');
assert.notEqual(1, 2);
// 测试通过。
assert.notEqual(1, 1);
// 抛出 AssertionError: 1 != 1
assert.notEqual(1, '1');
// 抛出 AssertionError: 1 != '1'
const assert = require('assert');
assert.notEqual(1, 2);
// 测试通过。
assert.notEqual(1, 1);
// 抛出 AssertionError: 1 != 1
assert.notEqual(1, '1');
// 抛出 AssertionError: 1 != '1'
assert.notDeepEqual(actual, expected[, message])说明：
测试 actual 参数与 expected 参数是否不深度相等。 与 assert.deepEqual() 相反。
测试 actual 参数与 expected 参数是否不深度相等。 与 assert.deepEqual() 相反。demo：
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 不深度相等。
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 不深度相等。
assert.notDeepStrictEqual(actual, expected[, message])说明：
测试 actual 参数与 expected 参数是否不深度全等。 与 assert.deepStrictEqual() 相反。
测试 actual 参数与 expected 参数是否不深度全等。 与 assert.deepStrictEqual() 相反。demo：
const assert = require('assert');
assert.notDeepEqual({ a: 1 }, { a: '1' });
// 抛出 AssertionError: { a: 1 } notDeepEqual { a: '1' }
assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// 测试通过。
const assert = require('assert');
assert.notDeepEqual({ a: 1 }, { a: '1' });
// 抛出 AssertionError: { a: 1 } notDeepEqual { a: '1' }
assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// 测试通过。
assert.notStrictEqual(actual, expected[, message])说明：
使用不全等运算符（!==）测试 actual 参数与 expected 参数是否不全等。
使用不全等运算符（!==）测试 actual 参数与 expected 参数是否不全等。demo：
const assert = require('assert');
assert.notStrictEqual(1, 2);
// 测试通过。
assert.notStrictEqual(1, 1);
// 抛出 AssertionError: 1 !== 1
assert.notStrictEqual(1, '1');
// 测试通过。
assert.fail(message)
const assert = require('assert');
assert.notStrictEqual(1, 2);
// 测试通过。
assert.notStrictEqual(1, 1);
// 抛出 AssertionError: 1 !== 1
assert.notStrictEqual(1, '1');
// 测试通过。
assert.fail(message)
assert.fail(actual, expected[, message[, operator[, stackStartFunction]]])说明：
抛出 AssertionError。 如果 message 参数为空，则错误信息为 actual 参数 + operator 参数 + expected 参数。
如果只提供了 actual 参数与 expected 参数，则 operator 参数默认为 ‘!='。
如果提供了 message 参数，则它会作为错误信息，其他参数会保存在错误对象的属性中。
如果提供了 stackStartFunction 参数，则该函数上的栈帧都会从栈信息中移除
抛出 AssertionError。 如果 message 参数为空，则错误信息为 actual 参数 + operator 参数 + expected 参数。
如果只提供了 actual 参数与 expected 参数，则 operator 参数默认为 ‘!='。
如果提供了 message 参数，则它会作为错误信息，其他参数会保存在错误对象的属性中。
如果提供了 stackStartFunction 参数，则该函数上的栈帧都会从栈信息中移除demo：
const assert = require('assert');
assert.fail(1, 2, undefined, '>');
// 抛出 AssertionError [ERR_ASSERTION]: 1 > 2
assert.fail(1, 2, '错误信息');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
assert.fail(1, 2, '错误信息', '>');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
// 上面两个例子的 `actual` 参数、`expected` 参数与 `operator` 参数不影响错误消息。
assert.fail();
// 抛出 AssertionError [ERR_ASSERTION]: Failed
assert.fail('错误信息');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
assert.fail('a', 'b');
// 抛出 AssertionError [ERR_ASSERTION]: 'a' != 'b'
//使用 stackStartFunction 参数拦截异常的栈信息：
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)
//
...
const assert = require('assert');
assert.fail(1, 2, undefined, '>');
// 抛出 AssertionError [ERR_ASSERTION]: 1 > 2
assert.fail(1, 2, '错误信息');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
assert.fail(1, 2, '错误信息', '>');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
// 上面两个例子的 `actual` 参数、`expected` 参数与 `operator` 参数不影响错误消息。
assert.fail();
// 抛出 AssertionError [ERR_ASSERTION]: Failed
assert.fail('错误信息');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
assert.fail('a', 'b');
// 抛出 AssertionError [ERR_ASSERTION]: 'a' != 'b'
//使用 stackStartFunction 参数拦截异常的栈信息：
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.throws(block[, error][, message])说明：
断言 block 函数会抛出错误。
error 参数可以是构造函数、正则表达式、或自定义函数。
如果指定了 message 参数，则当 block 函数不抛出错误时，message 参数会作为 AssertionError 的错误信息。
断言 block 函数会抛出错误。
error 参数可以是构造函数、正则表达式、或自定义函数。
如果指定了 message 参数，则当 block 函数不抛出错误时，message 参数会作为 AssertionError 的错误信息。demo：
const assert = require('assert');
assert.throws(
() => {
throw new Error('错误信息');
},
/123/
);
// Error: 错误信息
assert.throws(
() => {
throw new Error('错误信息');
},
/错误/
);
// 通过
assert.throws(
() => {
throw new Error('错误信息');
},
Error
);
// 通过
assert.throws(
() => {
throw new Error('错误信息');
},
function(err) {
if ((err instanceof Error) && /错误/.test(err)) {
return true;
}
},
'不是期望的错误'
);
// 通过
// error 参数不能是字符串。 如果第二个参数是字符串，则视为省略 error 参数，传入的字符串会被用于 message 参数。
// 这是错误的！不要这么做！
assert.throws(() => {
throw new Error('错误信息');
}, '错误信息', '没有抛出期望的信息');
// 应该这么做。
assert.throws(() => {
throw new Error('错误信息');
}, /错误信息/, '没有抛出期望的信息');
const assert = require('assert');
assert.throws(
() => {
throw new Error('错误信息');
},
/123/
);
// Error: 错误信息
assert.throws(
() => {
throw new Error('错误信息');
},
/错误/
);
// 通过
assert.throws(
() => {
throw new Error('错误信息');
},
Error
);
// 通过
assert.throws(
() => {
throw new Error('错误信息');
},
function(err) {
if ((err instanceof Error) && /错误/.test(err)) {
return true;
}
},
'不是期望的错误'
);
// 通过
// error 参数不能是字符串。 如果第二个参数是字符串，则视为省略 error 参数，传入的字符串会被用于 message 参数。
// 这是错误的！不要这么做！
assert.throws(() => {
throw new Error('错误信息');
}, '错误信息', '没有抛出期望的信息');
// 应该这么做。
assert.throws(() => {
throw new Error('错误信息');
}, /错误信息/, '没有抛出期望的信息');
assert.doesNotThrow(block[, error][, message])说明：
断言 block 函数不会抛出错误。
当 assert.doesNotThrow() 被调用时，它会立即调用 block 函数。
如果抛出错误且错误类型与 error 参数指定的相同，则抛出 AssertionError。
如果错误类型不相同，或 error 参数为 undefined，则抛出错误。
断言 block 函数不会抛出错误。
当 assert.doesNotThrow() 被调用时，它会立即调用 block 函数。
如果抛出错误且错误类型与 error 参数指定的相同，则抛出 AssertionError。
如果错误类型不相同，或 error 参数为 undefined，则抛出错误。demo：
const assert = require('assert');
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
SyntaxError
);
// TypeError: 错误信息
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
TypeError
);
// AssertionError [ERR_ASSERTION]: Got unwanted exception.
// 错误信息
// 如果抛出了 AssertionError 且有给 message 参数传值，则 message 参数的值会被附加到 AssertionError 的信息中：
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
TypeError,
'抛出错误'
);
// AssertionError [ERR_ASSERTION]: Got unwanted exception: 抛出错误
// 错误信息
const assert = require('assert');
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
SyntaxError
);
// TypeError: 错误信息
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
TypeError
);
// AssertionError [ERR_ASSERTION]: Got unwanted exception.
// 错误信息
// 如果抛出了 AssertionError 且有给 message 参数传值，则 message 参数的值会被附加到 AssertionError 的信息中：
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
TypeError,
'抛出错误'
);
// AssertionError [ERR_ASSERTION]: Got unwanted exception: 抛出错误
// 错误信息
注意事项说明：
对于 SameValueZero 比较，建议使用 ES2021 的 Object.is()。
对于 SameValueZero 比较，建议使用 ES2021 的 Object.is()。demo：
const a = 0;
const b = -a;
assert.notStrictEqual(a, b);
// 抛出 AssertionError: 0 !== -0
// 因为全等运算符不区分 -0 与 +0。
assert(!Object.is(a, b));
// 但 Object.is() 可以区分。
const str1 = 'foo';
const str2 = 'foo';
assert.strictEqual(str1 / 1, str2 / 1);
// 抛出 AssertionError: NaN === NaN
// 因为全等运算符不能用于测试 NaN。
assert(Object.is(str1 / 1, str2 / 1));
// 但 Object.is() 可以测试。
const a = 0;
const b = -a;
assert.notStrictEqual(a, b);
// 抛出 AssertionError: 0 !== -0
// 因为全等运算符不区分 -0 与 +0。
assert(!Object.is(a, b));
// 但 Object.is() 可以区分。
const str1 = 'foo';
const str2 = 'foo';
assert.strictEqual(str1 / 1, str2 / 1);
// 抛出 AssertionError: NaN === NaN
// 因为全等运算符不能用于测试 NaN。
assert(Object.is(str1 / 1, str2 / 1));
// 但 Object.is() 可以测试。
SameValueZero说明：
内部比较操作SameValueZero（x，y）
如果 type of x 不同于 type of y，返回false。
如果 type of x 是数字，那么
如果 x 为 NaN， y 为 NaN，返回 true。
如果 x 是 +0 而 y 是 -0，返回 true。
如果 x 是 -0 而 y 是 +0，返回 true。
如果 x 与 y 相同，则返回 true。
返回 假。
内部比较操作SameValueZero（x，y）
如果 type of x 不同于 type of y，返回false。
如果 type of x 是数字，那么
如果 x 为 NaN， y 为 NaN，返回 true。
如果 x 是 +0 而 y 是 -0，返回 true。
如果 x 是 -0 而 y 是 +0，返回 true。
如果 x 与 y 相同，则返回 true。
返回 假。希望本文所述对大家node.js程序设计有所帮助。
断言是编程术语，表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真，
可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。
同样，程序投入运行后，最终用户在遇到问题时可以重新启用断言。
使用断言可以创建更稳定、品质更好且不易于出错的代码。
当需要在一个值为false时中断当前操作的话，可以使用断言。
单元测试必须使用断言（Junit/JunitX）。使用方式：
const assert = require('assert');
const assert = require('assert');
assert.ok(value[, message])说明：
测试 value 是否为真值。 相当于 assert.equal(!!value, true, message)。
如果 value 不为真值，则抛出一个带有 message 属性的 AssertionError，
其中 message 属性的值等于传入的 message 参数的值。
如果 message 参数为 undefined，则赋予默认的错误信息。
测试 value 是否为真值。 相当于 assert.equal(!!value, true, message)。
如果 value 不为真值，则抛出一个带有 message 属性的 AssertionError，
其中 message 属性的值等于传入的 message 参数的值。
如果 message 参数为 undefined，则赋予默认的错误信息。demo：
const assert = require('assert');
assert.ok(true);
// 测试通过。
assert.ok(1);
// 测试通过。
assert.ok(false);
// 抛出 "AssertionError: false == true"
assert.ok(0);
// 抛出 "AssertionError: 0 == true"
assert.ok(false, '不是真值');
// 抛出 "AssertionError: 不是真值"
const assert = require('assert');
assert.ok(true);
// 测试通过。
assert.ok(1);
// 测试通过。
assert.ok(false);
// 抛出 "AssertionError: false == true"
assert.ok(0);
// 抛出 "AssertionError: 0 == true"
assert.ok(false, '不是真值');
// 抛出 "AssertionError: 不是真值"
assert(value[, message])说明：
assert.ok() 的别名。
用法与 assert.ok() 相同。
assert.ok() 的别名。
用法与 assert.ok() 相同。demo：
const assert = require('assert');
assert(true);
// 测试通过。
assert(1);
// 测试通过。
assert(false);
// 抛出 "AssertionError: false == true"
assert(0);
// 抛出 "AssertionError: 0 == true"
assert(false, '不是真值');
// 抛出 "AssertionError: 不是真值"
const assert = require('assert');
assert(true);
// 测试通过。
assert(1);
// 测试通过。
assert(false);
// 抛出 "AssertionError: false == true"
assert(0);
// 抛出 "AssertionError: 0 == true"
assert(false, '不是真值');
// 抛出 "AssertionError: 不是真值"
assert.ifError(value)说明：
如果 value 为真，则抛出 value。 可用于测试回调函数的 error 参数。
源码：function ifError(err) { if (err) throw err; };
如果 value 为真，则抛出 value。 可用于测试回调函数的 error 参数。
源码：function ifError(err) { if (err) throw err; };demo：
const assert = require('assert');
assert.ifError(0);
// 通过。
assert.ifError(1);
// 抛出 1。
assert.ifError('error');
// 抛出 'error'。
assert.ifError(new Error());
// 抛出 Error。
const assert = require('assert');
assert.ifError(0);
// 通过。
assert.ifError(1);
// 抛出 1。
assert.ifError('error');
// 抛出 'error'。
assert.ifError(new Error());
// 抛出 Error。
assert.equal(actual, expected[, message])说明：
使用相等运算符（==）测试 actual 参数与 expected 参数是否相等
使用相等运算符（==）测试 actual 参数与 expected 参数是否相等demo：
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 } }
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 } }
assert.deepEqual(actual, expected[, message])说明：
测试 actual 参数与 expected 参数是否深度相等。 原始值使用相等运算符（==）比较。
只测试可枚举的自身属性，不测试对象的原型、连接符、或不可枚举的属性（这些情况使用 assert.deepStrictEqual()）。
Map 和 Set 包含的子项也会被测试。
如果两个值不相等，则抛出一个带有 message 属性的 AssertionError，
其中 message 属性的值等于传入的 message 参数的值。
如果 message 参数为 undefined，则赋予默认的错误信息。
测试 actual 参数与 expected 参数是否深度相等。 原始值使用相等运算符（==）比较。
只测试可枚举的自身属性，不测试对象的原型、连接符、或不可枚举的属性（这些情况使用 assert.deepStrictEqual()）。
Map 和 Set 包含的子项也会被测试。
如果两个值不相等，则抛出一个带有 message 属性的 AssertionError，
其中 message 属性的值等于传入的 message 参数的值。
如果 message 参数为 undefined，则赋予默认的错误信息。demo：
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.deepEqual(/a/gi, new Date());
//测试通过，因为 RegExp 对象的属性不是可枚举的：
assert.deepEqual(obj1, obj1);
// 测试通过，对象与自身相等。
assert.deepEqual(obj1, obj2);
// 抛出 AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
// 因为 b 属性的值不同。
assert.deepEqual(obj1, obj3);
// 测试通过，两个对象相等。
assert.deepEqual(obj1, obj4);
// 抛出 AssertionError: { a: { b: 1 } } 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.deepEqual(/a/gi, new Date());
//测试通过，因为 RegExp 对象的属性不是可枚举的：
assert.deepEqual(obj1, obj1);
// 测试通过，对象与自身相等。
assert.deepEqual(obj1, obj2);
// 抛出 AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
// 因为 b 属性的值不同。
assert.deepEqual(obj1, obj3);
// 测试通过，两个对象相等。
assert.deepEqual(obj1, obj4);
// 抛出 AssertionError: { a: { b: 1 } } deepEqual {}
// 因为不测试原型。
assert.deepStrictEqual(actual, expected[, message])说明：
与 assert.deepEqual() 大致相同，但有一些区别：
1.原始值使用全等运算符（===）比较。Set 的值与 Map 的键使用 SameValueZero 比较。
2.对象的原型也使用全等运算符比较。
3.对象的类型标签要求相同。
4.比较[对象包装器][]时，其对象和里面的值要求相同。
与 assert.deepEqual() 大致相同，但有一些区别：
1.原始值使用全等运算符（===）比较。Set 的值与 Map 的键使用 SameValueZero 比较。
2.对象的原型也使用全等运算符比较。
3.对象的类型标签要求相同。
4.比较[对象包装器][]时，其对象和里面的值要求相同。demo：
const assert = require('assert');
assert.deepEqual({ a: 1 }, { a: '1' });
// 测试通过，因为 1 == '1'。
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// 抛出 AssertionError: { a: 1 } deepStrictEqual { a: '1' }
// 因为使用全等运算符 1 !== '1'。
// 以下对象都没有自身属性。
const date = new Date();
const object = {};
const fakeDate = {};
Object.setPrototypeOf(fakeDate, Date.prototype);
assert.deepEqual(object, fakeDate);
// 测试通过，不测试原型。
assert.deepStrictEqual(object, fakeDate);
// 抛出 AssertionError: {} deepStrictEqual Date {}
// 因为原型不同。
assert.deepEqual(date, fakeDate);
// 测试通过，不测试类型标签。
assert.deepStrictEqual(date, fakeDate);
// 抛出 AssertionError: 2021-03-11T14:25:31.849Z deepStrictEqual Date {}
// 因为类型标签不同。
assert.deepStrictEqual(new Number(1), new Number(2));
// 测试不通过，因为数值对象包装器里面的数值也会被比较。
assert.deepStrictEqual(new String('foo'), Object('foo'));
// 测试通过，因为这两个对象和里面的字符串都是相同的
const assert = require('assert');
assert.deepEqual({ a: 1 }, { a: '1' });
// 测试通过，因为 1 == '1'。
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// 抛出 AssertionError: { a: 1 } deepStrictEqual { a: '1' }
// 因为使用全等运算符 1 !== '1'。
// 以下对象都没有自身属性。
const date = new Date();
const object = {};
const fakeDate = {};
Object.setPrototypeOf(fakeDate, Date.prototype);
assert.deepEqual(object, fakeDate);
// 测试通过，不测试原型。
assert.deepStrictEqual(object, fakeDate);
// 抛出 AssertionError: {} deepStrictEqual Date {}
// 因为原型不同。
assert.deepEqual(date, fakeDate);
// 测试通过，不测试类型标签。
assert.deepStrictEqual(date, fakeDate);
// 抛出 AssertionError: 2021-03-11T14:25:31.849Z deepStrictEqual Date {}
// 因为类型标签不同。
assert.deepStrictEqual(new Number(1), new Number(2));
// 测试不通过，因为数值对象包装器里面的数值也会被比较。
assert.deepStrictEqual(new String('foo'), Object('foo'));
// 测试通过，因为这两个对象和里面的字符串都是相同的
assert.strictEqual(actual, expected[, message])说明：
使用全等运算符（===）测试 actual 参数与 expected 参数是否全等。
使用全等运算符（===）测试 actual 参数与 expected 参数是否全等。demo：
onst assert = require('assert');
assert.strictEqual(1, 2);
// 抛出 AssertionError: 1 === 2
assert.strictEqual(1, 1);
// 测试通过。
assert.strictEqual(1, '1');
// 抛出 AssertionError: 1 === '1'
onst assert = require('assert');
assert.strictEqual(1, 2);
// 抛出 AssertionError: 1 === 2
assert.strictEqual(1, 1);
// 测试通过。
assert.strictEqual(1, '1');
// 抛出 AssertionError: 1 === '1'
assert.notEqual(actual, expected[, message])说明：
使用不等运算符（!=）测试 actual 参数与 expected 参数是否不相等。
使用不等运算符（!=）测试 actual 参数与 expected 参数是否不相等。demo：
const assert = require('assert');
assert.notEqual(1, 2);
// 测试通过。
assert.notEqual(1, 1);
// 抛出 AssertionError: 1 != 1
assert.notEqual(1, '1');
// 抛出 AssertionError: 1 != '1'
const assert = require('assert');
assert.notEqual(1, 2);
// 测试通过。
assert.notEqual(1, 1);
// 抛出 AssertionError: 1 != 1
assert.notEqual(1, '1');
// 抛出 AssertionError: 1 != '1'
assert.notDeepEqual(actual, expected[, message])说明：
测试 actual 参数与 expected 参数是否不深度相等。 与 assert.deepEqual() 相反。
测试 actual 参数与 expected 参数是否不深度相等。 与 assert.deepEqual() 相反。demo：
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 不深度相等。
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 不深度相等。
assert.notDeepStrictEqual(actual, expected[, message])说明：
测试 actual 参数与 expected 参数是否不深度全等。 与 assert.deepStrictEqual() 相反。
测试 actual 参数与 expected 参数是否不深度全等。 与 assert.deepStrictEqual() 相反。demo：
const assert = require('assert');
assert.notDeepEqual({ a: 1 }, { a: '1' });
// 抛出 AssertionError: { a: 1 } notDeepEqual { a: '1' }
assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// 测试通过。
const assert = require('assert');
assert.notDeepEqual({ a: 1 }, { a: '1' });
// 抛出 AssertionError: { a: 1 } notDeepEqual { a: '1' }
assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// 测试通过。
assert.notStrictEqual(actual, expected[, message])说明：
使用不全等运算符（!==）测试 actual 参数与 expected 参数是否不全等。
使用不全等运算符（!==）测试 actual 参数与 expected 参数是否不全等。demo：
const assert = require('assert');
assert.notStrictEqual(1, 2);
// 测试通过。
assert.notStrictEqual(1, 1);
// 抛出 AssertionError: 1 !== 1
assert.notStrictEqual(1, '1');
// 测试通过。
assert.fail(message)
const assert = require('assert');
assert.notStrictEqual(1, 2);
// 测试通过。
assert.notStrictEqual(1, 1);
// 抛出 AssertionError: 1 !== 1
assert.notStrictEqual(1, '1');
// 测试通过。
assert.fail(message)
assert.fail(actual, expected[, message[, operator[, stackStartFunction]]])说明：
抛出 AssertionError。 如果 message 参数为空，则错误信息为 actual 参数 + operator 参数 + expected 参数。
如果只提供了 actual 参数与 expected 参数，则 operator 参数默认为 ‘!='。
如果提供了 message 参数，则它会作为错误信息，其他参数会保存在错误对象的属性中。
如果提供了 stackStartFunction 参数，则该函数上的栈帧都会从栈信息中移除
抛出 AssertionError。 如果 message 参数为空，则错误信息为 actual 参数 + operator 参数 + expected 参数。
如果只提供了 actual 参数与 expected 参数，则 operator 参数默认为 ‘!='。
如果提供了 message 参数，则它会作为错误信息，其他参数会保存在错误对象的属性中。
如果提供了 stackStartFunction 参数，则该函数上的栈帧都会从栈信息中移除demo：
const assert = require('assert');
assert.fail(1, 2, undefined, '>');
// 抛出 AssertionError [ERR_ASSERTION]: 1 > 2
assert.fail(1, 2, '错误信息');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
assert.fail(1, 2, '错误信息', '>');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
// 上面两个例子的 `actual` 参数、`expected` 参数与 `operator` 参数不影响错误消息。
assert.fail();
// 抛出 AssertionError [ERR_ASSERTION]: Failed
assert.fail('错误信息');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
assert.fail('a', 'b');
// 抛出 AssertionError [ERR_ASSERTION]: 'a' != 'b'
//使用 stackStartFunction 参数拦截异常的栈信息：
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)
//
...
const assert = require('assert');
assert.fail(1, 2, undefined, '>');
// 抛出 AssertionError [ERR_ASSERTION]: 1 > 2
assert.fail(1, 2, '错误信息');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
assert.fail(1, 2, '错误信息', '>');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
// 上面两个例子的 `actual` 参数、`expected` 参数与 `operator` 参数不影响错误消息。
assert.fail();
// 抛出 AssertionError [ERR_ASSERTION]: Failed
assert.fail('错误信息');
// 抛出 AssertionError [ERR_ASSERTION]: 错误信息
assert.fail('a', 'b');
// 抛出 AssertionError [ERR_ASSERTION]: 'a' != 'b'
//使用 stackStartFunction 参数拦截异常的栈信息：
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.throws(block[, error][, message])说明：
断言 block 函数会抛出错误。
error 参数可以是构造函数、正则表达式、或自定义函数。
如果指定了 message 参数，则当 block 函数不抛出错误时，message 参数会作为 AssertionError 的错误信息。
断言 block 函数会抛出错误。
error 参数可以是构造函数、正则表达式、或自定义函数。
如果指定了 message 参数，则当 block 函数不抛出错误时，message 参数会作为 AssertionError 的错误信息。demo：
const assert = require('assert');
assert.throws(
() => {
throw new Error('错误信息');
},
/123/
);
// Error: 错误信息
assert.throws(
() => {
throw new Error('错误信息');
},
/错误/
);
// 通过
assert.throws(
() => {
throw new Error('错误信息');
},
Error
);
// 通过
assert.throws(
() => {
throw new Error('错误信息');
},
function(err) {
if ((err instanceof Error) && /错误/.test(err)) {
return true;
}
},
'不是期望的错误'
);
// 通过
// error 参数不能是字符串。 如果第二个参数是字符串，则视为省略 error 参数，传入的字符串会被用于 message 参数。
// 这是错误的！不要这么做！
assert.throws(() => {
throw new Error('错误信息');
}, '错误信息', '没有抛出期望的信息');
// 应该这么做。
assert.throws(() => {
throw new Error('错误信息');
}, /错误信息/, '没有抛出期望的信息');
const assert = require('assert');
assert.throws(
() => {
throw new Error('错误信息');
},
/123/
);
// Error: 错误信息
assert.throws(
() => {
throw new Error('错误信息');
},
/错误/
);
// 通过
assert.throws(
() => {
throw new Error('错误信息');
},
Error
);
// 通过
assert.throws(
() => {
throw new Error('错误信息');
},
function(err) {
if ((err instanceof Error) && /错误/.test(err)) {
return true;
}
},
'不是期望的错误'
);
// 通过
// error 参数不能是字符串。 如果第二个参数是字符串，则视为省略 error 参数，传入的字符串会被用于 message 参数。
// 这是错误的！不要这么做！
assert.throws(() => {
throw new Error('错误信息');
}, '错误信息', '没有抛出期望的信息');
// 应该这么做。
assert.throws(() => {
throw new Error('错误信息');
}, /错误信息/, '没有抛出期望的信息');
assert.doesNotThrow(block[, error][, message])说明：
断言 block 函数不会抛出错误。
当 assert.doesNotThrow() 被调用时，它会立即调用 block 函数。
如果抛出错误且错误类型与 error 参数指定的相同，则抛出 AssertionError。
如果错误类型不相同，或 error 参数为 undefined，则抛出错误。
断言 block 函数不会抛出错误。
当 assert.doesNotThrow() 被调用时，它会立即调用 block 函数。
如果抛出错误且错误类型与 error 参数指定的相同，则抛出 AssertionError。
如果错误类型不相同，或 error 参数为 undefined，则抛出错误。demo：
const assert = require('assert');
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
SyntaxError
);
// TypeError: 错误信息
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
TypeError
);
// AssertionError [ERR_ASSERTION]: Got unwanted exception.
// 错误信息
// 如果抛出了 AssertionError 且有给 message 参数传值，则 message 参数的值会被附加到 AssertionError 的信息中：
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
TypeError,
'抛出错误'
);
// AssertionError [ERR_ASSERTION]: Got unwanted exception: 抛出错误
// 错误信息
const assert = require('assert');
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
SyntaxError
);
// TypeError: 错误信息
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
TypeError
);
// AssertionError [ERR_ASSERTION]: Got unwanted exception.
// 错误信息
// 如果抛出了 AssertionError 且有给 message 参数传值，则 message 参数的值会被附加到 AssertionError 的信息中：
assert.doesNotThrow(
() => {
throw new TypeError('错误信息');
},
TypeError,
'抛出错误'
);
// AssertionError [ERR_ASSERTION]: Got unwanted exception: 抛出错误
// 错误信息
注意事项说明：
对于 SameValueZero 比较，建议使用 ES2021 的 Object.is()。
对于 SameValueZero 比较，建议使用 ES2021 的 Object.is()。demo：
const a = 0;
const b = -a;
assert.notStrictEqual(a, b);
// 抛出 AssertionError: 0 !== -0
// 因为全等运算符不区分 -0 与 +0。
assert(!Object.is(a, b));
// 但 Object.is() 可以区分。
const str1 = 'foo';
const str2 = 'foo';
assert.strictEqual(str1 / 1, str2 / 1);
// 抛出 AssertionError: NaN === NaN
// 因为全等运算符不能用于测试 NaN。
assert(Object.is(str1 / 1, str2 / 1));
// 但 Object.is() 可以测试。
const a = 0;
const b = -a;
assert.notStrictEqual(a, b);
// 抛出 AssertionError: 0 !== -0
// 因为全等运算符不区分 -0 与 +0。
assert(!Object.is(a, b));
// 但 Object.is() 可以区分。
const str1 = 'foo';
const str2 = 'foo';
assert.strictEqual(str1 / 1, str2 / 1);
// 抛出 AssertionError: NaN === NaN
// 因为全等运算符不能用于测试 NaN。
assert(Object.is(str1 / 1, str2 / 1));
// 但 Object.is() 可以测试。
SameValueZero说明：
内部比较操作SameValueZero（x，y）
如果 type of x 不同于 type of y，返回false。
如果 type of x 是数字，那么
如果 x 为 NaN， y 为 NaN，返回 true。
如果 x 是 +0 而 y 是 -0，返回 true。
如果 x 是 -0 而 y 是 +0，返回 true。
如果 x 与 y 相同，则返回 true。
返回 假。
内部比较操作SameValueZero（x，y）
如果 type of x 不同于 type of y，返回false。
如果 type of x 是数字，那么
如果 x 为 NaN， y 为 NaN，返回 true。
如果 x 是 +0 而 y 是 -0，返回 true。
如果 x 是 -0 而 y 是 +0，返回 true。
如果 x 与 y 相同，则返回 true。
返回 假。希望本文所述对大家node.js程序设计有所帮助。
相关文章:
- jsJS的时间格式化和时间戳转换函数示例详解js大全
- js解决vue的router组件component在import时不能使用变量问题js大全
- js谈一谈vue请求数据放在created好还是mounted里好js大全
- js解决vue页面渲染但dom没渲染的操作js大全
- js解决VUE mounted 钩子函数执行时 img 未加载导致页面布局的问题js大全
- jsVue组件跨层级获取组件操作js大全
- js代码详解JavaScript作用域 闭包
- jsJS实现audio音频剪裁剪切复制播放与上传(步骤详解)js大全
- jsElement Breadcrumb 面包屑的使用方法js大全
- jsvue+element-ui JYAdmin后台管理系统模板解析js大全
刚刚发布热门点击发布时间
- [05/18]前端外包工具:如何npm清理缓冲yarn,pnpm 清理缓存
- [05/18]前端开发工具:npm和pnpm有什么区别?pnpm安装
- [05/18]前端开发:npm与yarn的区别
- [07/09]Chrome抓取页面内容代码|chrome插件获取页面数据
- [07/09]谷歌浏览器数据采集插件开发|谷歌浏览器的采集功能
- [07/09]Chrome插件轻松抓取网络数据,Chrome插件轻松抓取网页源码数据
- [07/09]chrome插件怎么安装?chrome插件开发如何安装chrome插件
- [07/09]快速chrome插件开发-北京chrome插件开发外包
- [12/31]清大光德落地护眼灯|清大光德儿童护眼灯
- [07/20]网站无障碍适老化外包改造私有化过程遇到问题整理
- [07/19]适老化改造工信部明确APP适老化规范：禁广告弹窗，网站需提供特大字体
- [07/19]适老化改造包括哪些方面?
- [07/19]什么是适老化改造？
- [07/19]适老化与信息无障碍是什么关系，二者有何异同？
- [07/19]网站如何进行适老化改造？
