Node.js-开发实践：高性能FS
【前言】
nodejs的fs模块相信大家都不陌生，
本文对比一下fs模块的三种使用方式。
【fs的三种使用方式】
nodejs官方提供了fs的三种使用方式，
https://nodejs.org/dist/latest-v18.x/docs/api/fs.html#promise-example
callback方式
示例代码如下：
const { unlink } = require('node:fs');
unlink('/tmp/hello', (err) => {
if (err) throw err;
console.log('successfully deleted /tmp/hello');
});这是最传统的方式，
充分的体现了nodejs事件驱动，非阻塞IO的特点，
但是代码会嵌套，导致回调地狱。。
promise方式
示例代码如下：
const { unlink } = require('node:fs/promises');
(async function (path) {
try {
await unlink(path);
console.log(`successfully deleted ${path}`);
} catch (error) {
console.error('there was an error:', error.message);
}
})('/tmp/hello');这种方式中，
每个api都返回了一个Promise对象，
需要配合async / await使用。
sync方式
示例代码如下：
const { unlinkSync } = require('node:fs');
try {
unlinkSync('/tmp/hello');
console.log('successfully deleted /tmp/hello');
} catch (err) {
// handle the error
}这种方式中，
不会导致代码嵌套，
而且不需要配合async / await使用。
小结
单从书写方式来说：sync > promise > callback
【测试代码】
接着会从两个维度进行测试
1. 处理文件的耗时
2. 处理文件的性能
找一个最简单的fs场景，判断文件是否存在，
三种方式对应的代码如下：
callback方式
// fs
const { access } = require('node:fs');
// is exists
exports.isExistsCallback = function (filePath, callback) {
access(filePath, (err) => {
if (callback) callback(err ? false : true);
});
};promise方式
// fs
const { access } = require('node:fs/promises');
// is exists
exports.isExistsPromise = async function (filePath) {
try {
await access(filePath);
return true;
} catch (error) {
return false;
}
};sync方式
// fs
const { accessSync } = require('node:fs');
// is exists
exports.isExistsSync = function (filePath) {
try {
accessSync(filePath);
return true;
} catch (error) {
return false;
}
};【时间对比】
测试方式为，传入一个不存在的路径，
重复n次，对比耗时
callback方式测试代码
const { isExistsCallback } = require('./fs-callback.js');
const times = 10000;
let callIndex = 0;
const filePath = '/file/not/exists';
// test callback
function testCallback() {
console.time('isExists by callback');
isExistsCallback(filePath, callback);
}
function callback(res) {
callIndex = callIndex + 1;
if (callIndex === times) {
console.timeEnd('isExists by callback');
} else {
isExistsCallback(filePath, callback);
}
}promise方式测试代码
const { isExistsPromise } = require('./fs-promise.js');
const times = 10000;
const filePath = '/file/not/exists';
// test promise
async function testPromise() {
console.time('isExists by promise');
for (let i = 0; i < times; i++) {
await isExistsPromise(filePath);
}
console.timeEnd('isExists by promise');
}sync方式测试代码
const { isExistsSync } = require('./fs-sync.js');
const times = 10000;
const filePath = '/file/not/exists';
// test sync
function testSync() {
console.time('isExists by sync');
for (let i = 0; i < times; i++) {
isExistsSync(filePath);
}
console.timeEnd('isExists by sync');
}时间对比
重复1w次，效果如下：
重复10w次，效果如下：
小结
从处理文件的耗时来看：sync << ( callback < promise )
【性能对比】
这里的性能对比，
不是对比处理文件时占用的内存或者cpu，
而是指对nodejs进程的占用，
测试方式如上，只是多加了一个每1ms的打印，
let intervalIndex = 0;
const intervalId = setInterval(() => {
console.log(1);
intervalIndex = intervalIndex + 1;
if (intervalIndex === 10) clearInterval(intervalId);
}, 1);并将重复次数调整到10次，
callback方式效果
promise方式效果
sync方式效果
性能对比
这里可以看出sync的方式是阻塞的方式，
也就是虽然sync处理文件耗时比较少，
但是会阻塞之后所有的操作，直到sync执行完毕，
简单理解是为了“减少处理时间，优化js写法”，
而独占了nodejs进程，阻塞了其他操作。
小结
从对进程的占用来看：( callback < promise ) << sync
【高性能fs】
其实在web前端或者nodejs的开发中，
fs的频繁使用比较少，
一般是上传下载等场景会用到。
但是在electron开发桌面应用时，
fs的操作就会变的很频繁，
这个时候就要关注高性能的使用fs，
callback方式
1. 书写会导致回调地狱
2. 体现nodejs事件驱动，非阻塞io
3. 性能最好
promise方式
1. 书写需要配合async / await使用
2. 也体现事件驱动，非阻塞io
3. 性能和callback很接近，稍微有损耗
sync方式
1. 书写最简单， 也不需要async / await
2. 阻塞性使用
3. 性能极差，谨慎使用
小结
1. 如果是很简单的场景且追求耗时少，可以使用sync的方式
2. 其他场景都谨慎使用sync，而推荐使用promise的方式