今天我们主要来介绍下Node体系中的文件系统。

fs 模块交互的几种方式

• POSIX 文件 I/O
• 文件流
• 批量文件 I/O
• 文件监控

POSIX 文件系统

代码示例：

const fs = require('fs');
const assert = require('assert');
const fd = fs.openSync('./file.txt', 'w+');
const writeBuf = new Buffer('some data to write');
fs.writeSync(fd, writeBuf, 0, writeBuf.length, 0);
const readBuf = new Buffer(writeBuf.length);
fs.readSync(fd, readBuf, 0, writeBuf.length, 0);
assert.equal(writeBuf.toString(), readBuf.toString());
fs.closeSync(fd);

读写流

const fs = require('fs');
const readable = fs.createReadStream('./original.txt');
const writeable = fs.createWriteStream('./copy.txt'); 

readable.pipe(writeable);

文件监控

fs.watchFile 比 fs.watch 低效，但更好用。

同步读取与 require

同步 fs 的方法应该在第一次初始化应用的时候使用。

const fs = require('fs');
const config = JSON.parse(fs.readFileSync('./config.json').toString());
init(config);

require：

const config = require('./config.json);
init(config);

• 模块会被全局缓冲，其他文件也加载并修改，会影响到整个系统加载了此文件的模块
• 可以通过 Object.freeze 来冻结一个对象

文件描述

文件描述是在操作系统中管理的在进程中打开文件所关联的一些数字或者索引。操作系统通过指派一个唯一的整数给每个打开的文件用来查看关于这个文件。

console.log('log') 是 process.stdout.write('log') 的语法糖。

一个文件描述是 open 以及 openSync 方法调用返回的一个数字

const fd = fs.openSync('myfile', 'a');
console.log(typeof fd === 'number'); // true

文件锁

协同多个进程同时访问一个文件，保证文件的完整性以及数据不能丢失：

• 强制锁（在内核级别执行）
• 咨询锁（非强制，只在涉及到进程订阅了相同的锁机制）
• node-fs-ext 通过 flock 锁住一个文件
• 使用锁文件
• 进程 A 尝试创建一个锁文件，并且成功了
• 进程 A 已经获得了这个锁，可以修改共享的资源
• 进程 B 尝试创建一个锁文件，但失败了，无法修改共享的资源

Node 实现锁文件

• 使用独占标记创建锁文件
• 使用 mkdir 创建锁文件

独占标记

// 所有需要打开文件的方法，fs.writeFile、fs.createWriteStream、fs.open 都有一个 x 标记
// 这个文件应该已独占打开，若这个文件存在，文件不能被打开
fs.open('config.lock', 'wx', (err) => {
 if (err) { return console.err(err); }
});
// 最好将当前进程号写进文件锁中
// 当有异常的时候就知道最后这个锁的进程
fs.writeFile(
 'config.lock',
 process.pid,
 { flogs: 'wx' },
 (err) => {
 if (err) { return console.error(err) };
 },
);

mkdir 文件锁

独占标记有个问题，可能有些系统不能识别 0_EXCL 标记。另一个方案是把锁文件换成一个目录，PID 可以写入目录中的一个文件。

fs.mkidr('config.lock', (err) => {
 if (err) { return console.error(err); }
 fs.writeFile(`/config.lock/${process.pid}`, (err) => { 

 if (err) { return console.error(err); }
 });
});

lock 模块实现

const fs = require('fs');
const lockDir = 'config.lock';
let hasLock = false;
exports.lock = function (cb) { // 获取锁
 if (hasLock) { return cb(); } // 已经获取了一个锁
 fs.mkdir(lockDir, function (err) {
 if (err) { return cb(err); } // 无法创建锁
 fs.writeFile(lockDir + '/' + process.pid, function (err) { // 把 PID写入到目录中以便调试
 if (err) { console.error(err); } // 无法写入 PID，继续运行
 hasLock = true; // 锁创建了
 return cb();
 });
 });
};
exports.unlock = function (cb) { // 解锁方法
 if (!hasLock) { return cb(); } // 如果没有需要解开的锁
 fs.unlink(lockDir + '/' + process.pid, function (err) {
 if (err) { return cb(err); }
 fs.rmdir(lockDir, function (err) {
 if (err) return cb(err);
 hasLock = false;
 cb();
 });
 });
};
process.on('exit', function () {
 if (hasLock) {
 fs.unlinkSync(lockDir + '/' + process.pid); // 如果还有锁，在退出之前同步删除掉
 fs.rmdirSync(lockDir);
 console.log('removed lock');
 }
});

递归文件操作

推荐一个线上库：mkdirp

递归：要解决我们的问题就要先解决更小的相同的问题。

dir-a
├── dir-b
│ ├── dir-c
│ │ ├── dir-d
│ │ │ └── file-e.png
│ │ └── file-e.png
│ ├── file-c.js
│ └── file-d.txt
├── file-a.js
└── file-b.txt

查找模块：find /asset/dir-a -name="file.*"

[
 'dir-a/dir-b/dir-c/dir-d/file-e.png',
 'dir-a/dir-b/dir-c/file-e.png',
 'dir-a/dir-b/file-c.js',
 'dir-a/dir-b/file-d.txt',
 'dir-a/file-a.js',
 'dir-a/file-b.txt',
]

const fs = require('fs');
const join = require('path').join;
// 同步查找
exports.findSync = function (nameRe, startPath) {
 const results = [];
 function finder(path) {
 const files = fs.readdirSync(path);
 for (let i = 0; i < files.length; i++) {
 const fpath = join(path, files[i]);
 const stats = fs.statSync(fpath);
 if (stats.isDirectory()) { finder(fpath); }
 if (stats.isFile() && nameRe.test(files[i])) {
 results.push(fpath);
 }
 }
 }
 finder(startPath); 

 return results;
};
// 异步查找
exports.find = function (nameRe, startPath, cb) { // cb 可以传入 console.log，灵活
 const results = [];
 let asyncOps = 0; // 2
 function finder(path) {
 asyncOps++;
 fs.readdir(path, function (er, files) {
 if (er) { return cb(er); }
 files.forEach(function (file) {
 const fpath = join(path, file);
 asyncOps++;
 fs.stat(fpath, function (er, stats) {
 if (er) { return cb(er); }
 if (stats.isDirectory()) finder(fpath);
 if (stats.isFile() && nameRe.test(file)) {
 results.push(fpath);
 }
 asyncOps--;
 if (asyncOps == 0) {
 cb(null, results);
 }
 });
 });
 asyncOps--;
 if (asyncOps == 0) {
 cb(null, results);
 }
 });
 }
 finder(startPath);
};
console.log(exports.findSync(/file.*/, `${__dirname}/dir-a`));
console.log(exports.find(/file.*/, `${__dirname}/dir-a`, console.log));

监视文件和文件夹

想要监听一个文件或者目录，并在文件更改后执行一个动作。

const fs = require('fs');
fs.watch('./watchdir', console.log); // 稳定且快
fs.watchFile('./watchdir', console.log); // 跨平台
 

逐行地读取文件流

const fs = require('fs');
const readline = require('readline');
const rl = readline.createInterface({
 input: fs.createReadStream('/etc/hosts'),
 crlfDelay: Infinity
});
rl.on('line', (line) => {
 console.log(`cc ${line}`);
 const extract = line.match(/(\\d+\\.\\d+\\.\\d+\\.\\d+) (.*)/);
});