前一篇学习了文件的打开和关闭，文件操作总不能只包含打开和关闭吧，这里就开始文件的读写操作。
fs模块方法
1:read和readSync方法
该方法，是从文件的指定位置处读取文件，一直读取到文件底部，然后江都区到的内容输出到一个缓存区，使用方法如下：
fs.read(fd,buffer,offset,length,position,callback);
在read方法中，支持6个参数：
- fd参数，是文件描述符，是open方法的回调函数中获取到的，是一个数字。
- buffer，是一个buffer对象，用于指定将文件数据读取到那个缓存区，如果不定义，则会生成一个新的缓存区，进行存放新读取到的数据。
- offset，是一个整数值，用于指定向缓存区中写入数据时的开始位置，以字节为单位。其实也就是，读入到缓存中的数据，从buffer对象的第几个元素开始写入。
- length，是一个整数值，表示读入的数据，多少数据写入到buffer对象中去，要保证不能超出buffer的容纳范围，否则会抛出一个范围异常。
- position，是一个整数值，表示，从文件中的哪个位置，开始读取数据，如果设置为非0的整数，则从该整数所示的位置，读取长度为length的数据到buffer对象中。
- callback，回调函数，当读取文件成功之后，把执行该函数，该回调函数支持三个参数：
function (err,bytesRead,buffer){
//err为读取文件操作失败时，触发的错误对象
//bytesRead为读取到的字节数，如果文件的比较大，则该值就是length的值，
//如果文件的大小比length小，则该值为实际中读取到的字节数。
//buffer为读取到的内容，保存到了该缓存区，如果在使用read时，
//传入了buffer对象，则此处的buffer就是传入的buffer对象。
//如果在read时没有传入buffer，则此处的buffer为新创建的buffer对象
}
上面把参数的含义以及回调函数的定义，都说明了一下，这里就看一个示例吧：
var fs = require("fs");
fs.open("fs.txt","r",function(err,fd){
//读取fs.text，文件的内容为“123456789”，长度为9
var buffer = new Buffer([0,0,0,0,0,0,0,0,0,0]);
//创建一个长度为10，初始值为0的buffer对象。
//数据比较少，就直接写了，否则还是使用fill方法吧。
console.log(buffer);
//<Buffer 00 00 00 00 00 00 00 00 00 00>
//初始时的buffer对象
fs.read(fd,buffer,4,6,4,function(err,bytesRead,buffer1){
//读取到的数据，从buffer对象的第5个元素开始保存，保存6个字节的元素
//读取文件，是从文件的第5个字节开始，因为文件中内容长度为9，
//那么，读取到的内容就是56789，所以buffer的最后一位仍然为初始值。
//由于想要读取的字节长度为6，但是文件内容过短，只读取了5个字节的有效数据
//就到了文件的结尾了，所以，bytesRead的值不是6，而是5。
//而buffer对象，为被写入新数据之后的对象。
console.log(bytesRead); //5
console.log(buffer1);
//<Buffer 00 00 00 00 35 36 37 38 39 00>
console.log(buffer);
//<Buffer 00 00 00 00 35 36 37 38 39 00>
//它们俩是完全相同的。其实质是，它们俩占据的内存也是相同的，
//它们就是同一个缓存区。
});
});
一般情况下，异步调用时，回调函数中，只有两个参数存在，第一个参数为err对象，第二个参数为操作之后的数据，可是，这里有三个数据，那么在同步时，什么才是返回值呢？
所以，要做如下的测试：
var fs = require("fs");
fs.open("fs.txt","r",function(err,fd){
//读取fs.text，文件的内容为“123456789”，长度为9
var buffer = new Buffer([0,0,0,0,0,0,0,0,0,0]);
var bytesRead = fs.readSync(fd,buffer,4,6,4);
console.log(bytesRead);
});
返回的是bytesRead的值，并没有返回buffer对象，可以想象，因为buffer对象是原本传入的buffer对象，依然可以通过传入的buffer对象，直接访问到重写数据之后的buffer对象。
但是，有个问题就来了，如果没有传入buffer对象呢？这又要如何呢？这个问题暂且别过，因为这个问题，并没有在一些API文档中说明，在书中也没有看到这个用法，但是接下来，我们去分析一下源码，就能发现，除了上述的两种常用的方法之外，还有其他的使用方式。
OK，先看下read方法的源码：
fs.read = function(fd, buffer, offset, length, position, callback) {
if (!util.isBuffer(buffer)) {
//如果传入的第二个参数不是一个buffer对象，则做一些自适应的处理
// legacy string interface (fd, length, position, encoding, callback)
var cb = arguments[4],
encoding = arguments[3];
//本来read方法是有6个参数的，当buffer没有传入的时候，
//则相应的offset也变得没有意义，所以变为了4个参数。
//而这个时候，参数的形式就变成了前面英文部分的样子。5个参数，加入了encoding参数。
assertEncoding(encoding);
//判断传入的encoding是否是当前支持的编码方式
//如果不是，则抛出异常
position = arguments[2];
length = arguments[1];
buffer = new Buffer(length);
offset = 0;
//设置对应的值，新建buffer对象
//把callback做一个代理，根据传入的编码方式，把结果按照指定的编码，传入回调函数
callback = function(err, bytesRead) {
if (!cb) return;
//如果回调函数不存在，则直接退出
var str = (bytesRead > 0) ? buffer.toString(encoding, 0, bytesRead) : '';
//注意，当读取文件成功后，执行了wrapper的回调，从wrapper中，
//执行到该callback回调时，并没有传入buffer对象，
//并且，调用read中的回调的三个参数是:err,str(按照指定编码之后的字符串)，
//bytesRead(读取字节数)，并没有buffer对象传入
(cb)(err, str, bytesRead);
};
}
function wrapper(err, bytesRead) {
// Retain a reference to buffer so that it can't be GC'ed too soon.
// 由这里可以看出，在C++读取文件时，回调函数只有两个值
//err对象和真实读取的字节数，至于buffer对象，则是nodejs代理之后
//给添加上的
callback && callback(err, bytesRead || 0, buffer);
}
//创建一个实例，定义oncomplete属性
//该实例，按照猜测，应该是分段读取文件的一个对象
//当读取文件完成之后，会执行oncomplete方法
var req = new FSReqWrap();
req.oncomplete = wrapper;
//调用C++的接口，开始读取文件
binding.read(fd, buffer, offset, length, position, req);
};
看了上面的源码分析，那么也就发现了另外一种使用read的方法了，即，不输入buffer和offset，添加encoding的5个参数的使用，举一个最简单的实例吧。
var fs = require("fs");
fs.open("fs.txt","r",function(err,fd){
//读取fs.text，文件的内容为“123456789”，长度为9
var buf1 = new Buffer([0,0,0,0,0,0,0,0,0,0]);
fs.read(fd,6,4,null,function(err,str,bytesRead){
console.log(err);
//null
console.log("str="+str);
//str=56789
console.log("bytesRead="+bytesRead);
//bytesRead=5
});
});
注意，当不传入buffer对象时，回调函数中的三个参数也相应的有了变化，详情请看前面的实例代码中，回调函数的参数以及源码中的注释。
继续看下readSync的源码，在本文的前面，也给出了一个readSync的示例，当传入buffer对象时，返回值是读取到真是字节数，那么，既然read方法可以省略buffer对象，改为返回读取到的字符串，那么readSync方法呢？这个就让我们看下源码中，是如何处理这些数据的。
fs.readSync = function(fd, buffer, offset, length, position) {
var legacy = false;
if (!util.isBuffer(buffer)) {
// legacy string interface (fd, length, position, encoding, callback)
//该部分的处理，和read方法内部，完全相同，不再注释。
//唯一区别，legacy标识符，标志是否传入了buffer，为false时，表示传入了
legacy = true;
var encoding = arguments[3];
assertEncoding(encoding);
position = arguments[2];
length = arguments[1];
buffer = new Buffer(length);
offset = 0;
}
//C++的read方法，如果传入了第六个参数，则属于读取成功之后，执行的回调相关的对象
//如果不传入，则返回值为读取到的真是字节数，该数小于等于length
var r = binding.read(fd, buffer, offset, length, position);
if (!legacy) {
//如果，传入了buffer对象，则直接返回读取到的真是字节数
return r;
}
var str = (r > 0) ? buffer.toString(encoding, 0, r) : '';
//如果没有传入buffer对象，那么返回一个数组，该数组包含两个元素，
//字符串和读取到的字节数
return [str, r];
};
那么接下来看下，如果不传入buffer对象时的一个示例吧：
var fs = require("fs");
fs.open("fs.txt","r",function(err,fd){
//读取fs.text，文件的内容为“123456789”，长度为9
var buf1 = new Buffer([0,0,0,0,0,0,0,0,0,0]);
var arr = fs.readSync(fd,6,4,null);
console.log(arr);
//["56789",5]
});
OK，到这里，关于read和readSync方法的使用及一些原理性东西，也基本说完了。
2：write和writeSync方法
有读取的方法，那么就必然有写入的方法了，要么flag=w不就无用了么。并且看到了前面的关于read的一些使用，那么接下来，对于write的使用，看起来就变得更加的简单了，现在直接看下示例：
var fs = require("fs");
fs.open("fs.txt","a+",function(err,fd){
//读取fs.text，文件的内容为“123456789”，长度为9
var buf1 = new Buffer("我喜爱Nodejs");
console.log(buf1);
//显示buf1的buffer数据
//计算buf1的长度，把该数据全部写入到fs.txt文件中
fs.write(fd,buf1,0,buf1.length,0,function(err,len,buf){
console.log("len="+len);
//写入的长度
//写入的buf，其实和buf1完全相等
console.log(buf);
fs.read(fd,len,9,"utf8",function(err,str,len2){
console.log("len2="+len2);
//读取从9开始的数据
console.log("str="+str);
//读取相应得到的字符串
//我喜爱Nodejs
});
});
});
从上面这个示例可以看出，write方法和read方法，使用基本是完全一样的，只是一个是在读取文件一个是在写入文件，前提也是需要你在open打开文件时，使用的flag打开文件方式，要支持读写才行。
既然，write和read是相同的使用方法，那么也可以不定义buffer的直接写入数据，所以，可以继续看下面的这个示例：
var fs = require("fs");
fs.open("fs.txt","a+",function(err,fd){
//读取fs.text，文件的内容为“123456789”，长度为9
//复杂的写法，和简单的写法，就看个人喜好了，0代表的是字符串的开始位置
//fs.write(fd,"我喜爱Nodejs",0,"utf8",function(err,len,str)
fs.write(fd,"我喜爱Nodejs",function(err,len,str){
console.log("len="+len); //len=15
//写入的长度
//当直接写入字符串时，返回的也不再是buffer对象，而是字符串
console.log("str="+str); //我喜爱Nodejs
fs.read(fd,len,9,"utf8",function(err,str,len2){
console.log("len2="+len2); //len2=15
//读取从9开始的数据
console.log("str="+str);
//读取相应得到的字符串
//我喜爱Nodejs
});
});
});
这里就不再分析源码了，基本上write的源码和read的源码处理方式类似，只是在最后调用C++接口不同而已，所以这里也就不再占用空间了。有兴趣的可以直接去nodejs的github源码中，查看：fs.js。
关于writeSync的用法，用法和write是相同的，只是不需要回调函数，并且也不需要返回写入的数据，所以，和readSync的区别，也就是，readSync在不传入buffer时，会返回一个长度为2的数组，而writeSync不受buffer对象的影响，只要写入成功，就会返回写入的真实字节数。
不加示例，不加源码分析，请参考上面的read方法，readSync方法和write方法，也可以参考nodejs的API文档：Nodejs的API中文版。
总结
本篇的read和write是文档操作的基础，是属于最基本的操作，也是最重要的操作，本篇也是属于fs模块中的基本使用方法，对于以后学习其他方法，以及更好的了解fs模块有重要的作用，好好学习，天天向上。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持找一找教程网。
