fs.read(fd,buffer,offset,length,position,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> 
  //它们俩是完全相同的。其实质是，它们俩占据的内存也是相同的， 
  //它们就是同一个缓存区。 
 }); 
}); 

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); 
}); 

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) "htmlcode">

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) "htmlcode">

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模块有重要的作用，好好学习，天天向上。


以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。