时间：2020-10-25 14:33:17 | 栏目：NodeJS | 点击：次
下面继续nodejs的学习，在前两篇中，已经把文件操作的打开，关闭读写这两个最基本的功能进行了简单的说明，它们的强大之处，让我觉得知道这几种方法之后，基本上就可以随意的操作文件了，但是open，read，write等方法，需要操作的参数确实是有点多的，所以，基于让使用者更简单的完成读写操作，开发者们，继续给这些方法做了进一步的封装，也就是本文接下来将要说的readFile，和writeFile方法，当然也有他们的同步执行方法，只是篇幅有限，并且同步的方法和异步的方法，在内部实现和参数使用中，差别不大，所以在以后的文章中，基本上不会再涉及到同步方法了。
使用方法
fs.readFile(fileName,[options],callback);
其中：
fileName是表示您要操作的文件的地址，这个地址可以使用绝对地址，也可以使用相对地址，关于它可以支持的所有规则，可以参考之前文章中的path操作，path模块，就是专门为了地址这个功能存在的。
options是读取文件时，所需要的参数，options是一个对象，它只包含两个参数：options = { encoding: “utf-8”, flag: 'r' }，其中，encoding表示读取文件成功后，返回的数据的编码格式，默认返回格式为buffer对象，flag的值表示是如何读取文件的，支持的参数，与使用fs.open时，相同，具体请参考：文本操作模块-fs模块（一），但是在我个人看来，这里的flag取值一般也就是r，r+着两种方式了，毕竟readFile就是为了读取文件内容才定义的。
callback是回调函数，当改文件读取成功时，执行该文件，并且callback方法支持两个参数：
callback(err,data){
//err为读取失败时的错误对象，保持错误信息
//data为读取成功时，返回的读取信息，该信息的返回格式，是由options对象中的encoding决定
}
在接下来给出测试用例之前，我们再来想想另外的一个问题，那就是使用fs.read方法读取文件时，我需要知道明确的传入要读取信息的长度，而在这里，我要读取一整个文件的内容，那么这个文件包含的内容的总长度要怎么计算呢？这是一个问题，当然我也是在看readFile的源码时，看到了这个，所以才在这里提前说明一下的。
对的，fs模块中，提供了一个方法，可以让你获取到文件的一些基本信息，这个方法就是fs.fstat方法，它也是一个异步执行的方法，使用方法如下：
var fs = require("fs");
fs.open('fs.js','r',function(err,fd){
if(err){
console.log("open file error");
//如果打开文件失败时，会执行到这里
return false;
}
fs.fstat(fd,function(err,state){
if(err){
console.log("err when fstate!");
return false;
}
console.log(state);
//state是一个对象，其中包含着当前打开文件的一些基本信息
});
});
保持上面的代码，然后在控制台执行的结果如下：
{
dev: 16777220,
mode: 33279,
nlink: 1,
uid: 501,
gid: 20,
rdev: 0,
blksize: 4096,
ino: 1456286,
size: 86418,
blocks: 176,
atime: Sat Aug 15 2015 15:46:59 GMT+0800 (CST),
mtime: Sat Aug 15 2015 15:01:55 GMT+0800 (CST),
ctime: Sat Aug 15 2015 15:01:55 GMT+0800 (CST),
birthtime: Mon Aug 03 2015 22:47:02 GMT+0800 (CST)
}
当我们使用console.log在控制台打印信息时，只能显示一些本身的属性，其实state还支持一些方法，比如：isDirectory，isFile，isBlockDevice等方法，这里因为我平时也不会太用到nodejs做东西，所以对其中的很多属性，都用不到，使用不到，所以也就导致，我对于这个属性或者方法的含义，不能很好的理解，所以这里就不多说了。
至于关于state的东西，可以在fs.js中，查看查找fs.State构造函数，既可以找到所有包含的信息。
测试用例
var fs = require("fs");
fs.readFile('test.js',"utf-8",function(err,data){
if(err){
console.log("readFile file error");
return false;
}
console.log(data);
});
上面给出的是最简单的示例了，因为我读取的文件中，保持的内容只是一段中文文本，所以这里使用的是utf-8的编码格式，如果这里不传入编码格式，那么返回的data值则是一个Buffer对象。
readFile源码分析
虽然这里叫做源码分析，实质上，只是来一起看下，readFile在源码中是如何实现的。该部分只有源码，请查看源码中对应的注释，了解源码的整改结构。
fs.readFile = function(path, options, callback_) {
var callback = maybeCallback(arguments[arguments.length - 1]);
//msybeCallback用来判断是否为一个function，这里时判断传入的第二个参数是否为function
//如果不是，那么就定义一个，这里对于后面的逻辑影响不大
//给options设置一些默认值，readFile的第二个参数，只能是三种情况
//1：function，这个时候，options使用默认值，第二个参数为回调函数
//2：string类型，这个时候，第二个参数为encoding的属性值
//3：object类型，这个时候，表示options为一个完整的对象，可能包含也可能不包含encoding和flag属性
//如果不为上述的三种类型，那么直接抛出一个类型异常，停止执行
if (util.isFunction(options) || !options) {
options = { encoding: null, flag: 'r' };
} else if (util.isString(options)) {
options = { encoding: options, flag: 'r' };
} else if (!util.isObject(options)) {
throw new TypeError('Bad arguments');
}
var encoding = options.encoding;
assertEncoding(encoding);
//判断encoding是否为当前支持的编码类型，如果不支持，则抛出一个异常，停止执行。
//判断encoding的方法在Buffer模块中，请参考前面的文章，文章地址，请在源码分析的结尾查看。
// first, stat the file, so we know the size.
var size;
var buffer; // single buffer with file data
var buffers; // list for when size is unknown
var pos = 0;
var fd;
//参数验证成功，开始执行读取数据的，设置flag默认值
var flag = options.flag || 'r';
//首先根据路径，打开文件，open的使用，请参考前面的文章
fs.open(path, flag, 438 /*=0666*/, function(er, fd_) {
//如果失败，那么获取到失败的error对象，并返回该对象
if (er) return callback(er);
//记录打开文件的文件描述符
fd = fd_;
//使用fstat，查看当前打开文件的一些基本信息。
//fstat获取到的信息，请向前翻看。
fs.fstat(fd, function(er, st) {
if (er) {
//如果在执行fstat时失败，则执行关闭文件的操作，
//关闭之后，把错误信息，传入readFile的回调函数
return fs.close(fd, function() {
callback(er);
});
}
size = st.size;
//根据文件的大小，执行不同的操作
//如果为空文件，则重新定义一个空的buffers，执行read文件的方法
if (size === 0) {
// the kernel lies about many files.
// Go ahead and try to read some bytes.
buffers = [];
return read();
}
//如果文件内容，大于内存所能保存的最大量，则抛出一个范围异常。
if (size > kMaxLength) {
var err = new RangeError('File size is greater than possible Buffer: ' + '0x3FFFFFFF bytes');
return fs.close(fd, function() {
callback(err);
});
}
//否则，定义一个与内容相当大小的Buffer对象，开始执行read方法
buffer = new Buffer(size);
read();
});
});
function read() {
//根据size的不同，执行两个方法
//当读取成功时，执行afterRead方法。
//其中，size，buffer，fd，pos，等都是父级作用域的变量
if (size === 0) {
buffer = new Buffer(8192);
fs.read(fd, buffer, 0, 8192, -1, afterRead);
} else {
fs.read(fd, buffer, pos, size - pos, -1, afterRead);
}
}
function afterRead(er, bytesRead) {
if (er) {
//读取文件失败时，根据失败时的错误对象，执行readFile的回调函数
return fs.close(fd, function(er2) {
return callback(er);
});
}
//如果读取的数据量为0，则表示已经读取结束，则执行close方法，结束readFile方法，并返回数据
if (bytesRead === 0) {
return close();
}
//如果有值，则更改pos的值，也就是更改在read方法中，读取文件起始位置的值。
pos += bytesRead;
//如果pos的值，已经等于文件的长度size了，则表示当前文件已经读取结束了，则关闭文件
//否则，继续调用read方法，继续读取。
//如果size＝＝＝0的话，有可能是fstat没有能正常的读取到size的值，就执行后面的
if (size !== 0) {
if (pos === size) close();
else read();
} else {
// unknown size, just read until we don't get bytes.
//猜测，这里可能是在某些系统下，无法获取到文件的字节数，所以添加的这个判断。
buffers.push(buffer.slice(0, bytesRead));
read();
}
}
function close() {
fs.close(fd, function(er) {
//当文件读取结束时，拼接读取到的数组，
if (size === 0) {
// collected the data into the buffers list.
buffer = Buffer.concat(buffers, pos);
} else if (pos < size) {
buffer = buffer.slice(0, pos);
}
//根据是否有encoding，做一次编码转换
if (encoding) buffer = buffer.toString(encoding);
//把最终的数据，传入readFile的回调函数中。
return callback(er, buffer);
});
}
};
OK，上面就是源码中，readFile的实现逻辑，源码中，有提到了判断encoding是否为当前支持的编码方式的地方。
在前面我也说了句，在使用readFile时，设置flag的值，其实是无用的（我本人的想法，也可能是我资历尚浅，没有碰到过这样的需求），但是不妨碍有些人为了测试或者好玩，对于readFile的时候，设置flag＝“w+”的情况，当然这个时候，直接就报错来吧。
前面的是readFile的相关东西，下面继续看下写文件的呢，也就是writeFile的方法来。
使用方法
fs.writeFile(fileName,data,[options],callback);
其中：
最简单的示例：
var fs = require("fs");
fs.writeFile('test.js',"新添加的数据",{flag:"a+"},function(err,data){
if(err){
console.log("readFile file error");
return false;
}
console.log(data);
});
这里说的示例，都是最简单的示例，参数什么的，好多都没有设置，因为在我看来，只要我能把源码中相关的信息看懂，那么关于这些API的使用，我就可以几乎找到它所有的使用方法，所以，在这里给出示例的时候，我都是给的一个最简单的示例，然后后面继续开始看下源码中的信息，在源码中，就可以把writeFile的使用方法，都能懂一些了。
writeFile源码
继续看下writeFile中的源码实现逻辑，让我们可以对writeFile有更深层次的了解。
function writeAll(fd, buffer, offset, length, position, callback) {
//判断最后一个是否为回调函数，如果不是，给一个默认的回调函数
//默认的回调函数，在使用者来说，是无法访问到的
callback = maybeCallback(arguments[arguments.length - 1]);
// write(fd, buffer, offset, length, position, callback)
//文件标志符是fd，需要写入的数据是buffer，真实写入数据，是从buffer的offset位置开始
//取长度为length的数据，写入到fd指向的文件中，position的位置处。
fs.write(fd, buffer, offset, length, position, function(writeErr, written) {
if (writeErr) {
//如果写入失败，则关闭文件，执行callback，传入失败信息保存对象
fs.close(fd, function() {
if (callback) callback(writeErr);
});
} else {
//written为保存的数据byte值，如果意见全部保存，则保存完成，关闭文件
if (written === length) {
fs.close(fd, callback);
} else {
//如果没有保存完毕，则更新offset，length，position的值，继续调用该方法，
//保存剩下的数据，直到把所有的数据保存成功为止。
offset += written;
length -= written;
position += written;
writeAll(fd, buffer, offset, length, position, callback);
}
}
});
}
fs.writeFile = function(path, data, options, callback) {
//判断最后一个是否为回调函数，如果不是，给一个默认的回调函数
var callback = maybeCallback(arguments[arguments.length - 1]);
//给options设置一些默认值，writeFile的第三个参数，只能是三种情况
//1：function，这个时候，options使用默认值，第三个参数为回调函数
//2：string类型，这个时候，第三个参数为encoding的属性值
//3：object类型，这个时候，表示options为一个完整的对象，可能包含也可能不包含encoding和flag属性
//如果不为上述的三种类型，那么直接抛出一个类型异常，停止执行
//这里的判断和readFile基本完全一样，只是默认值不一样而已
if (util.isFunction(options) || !options) {
options = { encoding: 'utf8', mode: 438 /*=0666*/, flag: 'w' };
} else if (util.isString(options)) {
options = { encoding: options, mode: 438, flag: 'w' };
} else if (!util.isObject(options)) {
throw new TypeError('Bad arguments');
}
//判断当前设置的encoding是否为当前支持的encoding，如果不支持，会抛出一个异常，
//停止继续向下执行
assertEncoding(options.encoding);
//默认信息设置好，则打开文件，执行写入操作
var flag = options.flag || 'w';
fs.open(path, flag, options.mode, function(openErr, fd) {
if (openErr) {
//打开失败时，把失败原因，传入writeFile的回调函数
if (callback) callback(openErr);
}else {
//打开成功时，要把需要写入的data信息，改为buffer对象
var buffer = util.isBuffer(data) ? data : new Buffer('' + data,options.encoding || 'utf8');
//判断是否打开的方式，是否是追加模式，
//这里让我很疑惑的一个问题是，为什么这里要用正则表达式？
//这样简单的判断，直接食用indexOf，不是会有更高的效率？
// var position = flag.indexOf("a") == -1 ? 0 : null;
var position = /a/.test(flag) ? null : 0;
//准备好了所有的信息，则开始使用writeAll方法，写入文件
writeAll(fd, buffer, 0, buffer.length, position, callback);
}
});
};
OK，writeFile的源码就是这样了，其实这里还有一个就是追加到文件的方法，命名为appendFile，这个就不单独来写了，看下源码，应该就能懂了。
fs.appendFile = function(path, data, options, callback_) {
var callback = maybeCallback(arguments[arguments.length - 1]);
if (util.isFunction(options) || !options) {
options = { encoding: 'utf8', mode: 438 /*=0666*/, flag: 'a' };
} else if (util.isString(options)) {
options = { encoding: options, mode: 438, flag: 'a' };
} else if (!util.isObject(options)) {
throw new TypeError('Bad arguments');
}
if (!options.flag)
options = util._extend({ flag: 'a' }, options);
//调用的writeFile
fs.writeFile(path, data, options, callback);
};
appendFile的源码，就更没有什么新东西了，只是做了一个判断，然后给flag标签添加了一个a属性值，之后就直接调用的weiteFile的方法了。
总结
关于nodejs的操作文件，是比较重要的一个概念，所以包含的信息，也是比较多的，本篇依然是在之前open，read，write等的基础上，执行的再一次的封装，不属于新的概念，只是为了能让使用者更简单的使用读写文件的功能而已。后面继续在看一些其他的操作文件的API的功能及其实现。