fs.read(fd,buffer,offset,length,position,callback); 

function (err,bytesRead,buffer){ 
 //err為讀取文件操作失敗時，觸發(fā)的錯誤對象 
 //bytesRead為讀取到的字節(jié)數(shù)，如果文件的比較大，則該值就是length的值， 
 //如果文件的大小比length小，則該值為實際中讀取到的字節(jié)數(shù)。 
 //buffer為讀取到的內(nèi)容，保存到了該緩存區(qū)，如果在使用read時， 
 //傳入了buffer對象，則此處的buffer就是傳入的buffer對象。 
 //如果在read時沒有傳入buffer，則此處的buffer為新創(chuàng)建的buffer對象 
} 

var fs = require("fs"); 
 
fs.open("fs.txt","r",function(err,fd){ 
 //讀取fs.text，文件的內(nèi)容為“123456789”，長度為9 
 var buffer = new Buffer([0,0,0,0,0,0,0,0,0,0]); 
 //創(chuàng)建一個長度為10，初始值為0的buffer對象。 
 //數(shù)據(jù)比較少，就直接寫了，否則還是使用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){ 
  //讀取到的數(shù)據(jù)，從buffer對象的第5個元素開始保存，保存6個字節(jié)的元素 
  //讀取文件，是從文件的第5個字節(jié)開始，因為文件中內(nèi)容長度為9， 
  //那么，讀取到的內(nèi)容就是56789，所以buffer的最后一位仍然為初始值。 
  //由于想要讀取的字節(jié)長度為6，但是文件內(nèi)容過短，只讀取了5個字節(jié)的有效數(shù)據(jù) 
  //就到了文件的結(jié)尾了，所以，bytesRead的值不是6，而是5。 
  //而buffer對象，為被寫入新數(shù)據(jù)之后的對象。 
  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> 
  //它們倆是完全相同的。其實質(zhì)是，它們倆占據(jù)的內(nèi)存也是相同的， 
  //它們就是同一個緩存區(qū)。 
 }); 
}); 

var fs = require("fs"); 
 
fs.open("fs.txt","r",function(err,fd){ 
 //讀取fs.text，文件的內(nèi)容為“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)) { 
 //如果傳入的第二個參數(shù)不是一個buffer對象，則做一些自適應(yīng)的處理 
 // legacy string interface (fd, length, position, encoding, callback) 
 var cb = arguments[4], 
  encoding = arguments[3]; 
 //本來read方法是有6個參數(shù)的，當(dāng)buffer沒有傳入的時候， 
 //則相應(yīng)的offset也變得沒有意義，所以變?yōu)榱?個參數(shù)。 
 //而這個時候，參數(shù)的形式就變成了前面英文部分的樣子。5個參數(shù)，加入了encoding參數(shù)。 
  
 assertEncoding(encoding); 
 //判斷傳入的encoding是否是當(dāng)前支持的編碼方式 
 //如果不是，則拋出異常 
 
 position = arguments[2]; 
 length = arguments[1]; 
 buffer = new Buffer(length); 
 offset = 0; 
 //設(shè)置對應(yīng)的值，新建buffer對象 
 
 //把callback做一個代理，根據(jù)傳入的編碼方式，把結(jié)果按照指定的編碼，傳入回調(diào)函數(shù) 
 callback = function(err, bytesRead) { 
  if (!cb) return; 
  //如果回調(diào)函數(shù)不存在，則直接退出 
  
  var str = (bytesRead > 0) ? buffer.toString(encoding, 0, bytesRead) : ''; 
 
  //注意，當(dāng)讀取文件成功后，執(zhí)行了wrapper的回調(diào)，從wrapper中， 
  //執(zhí)行到該callback回調(diào)時，并沒有傳入buffer對象， 
  //并且，調(diào)用read中的回調(diào)的三個參數(shù)是:err,str(按照指定編碼之后的字符串)， 
  //bytesRead(讀取字節(jié)數(shù))，并沒有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++讀取文件時，回調(diào)函數(shù)只有兩個值 
 //err對象和真實讀取的字節(jié)數(shù)，至于buffer對象，則是nodejs代理之后 
 //給添加上的 
 callback && callback(err, bytesRead || 0, buffer); 
 } 
 
 //創(chuàng)建一個實例，定義oncomplete屬性 
 //該實例，按照猜測，應(yīng)該是分段讀取文件的一個對象 
 //當(dāng)讀取文件完成之后，會執(zhí)行oncomplete方法 
 var req = new FSReqWrap(); 
 req.oncomplete = wrapper; 
 
 //調(diào)用C++的接口，開始讀取文件 
 binding.read(fd, buffer, offset, length, position, req); 
}; 

var fs = require("fs"); 
 
fs.open("fs.txt","r",function(err,fd){ 
 //讀取fs.text，文件的內(nèi)容為“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 
 }); 
  
}); 

fs.readSync = function(fd, buffer, offset, length, position) { 
 var legacy = false; 
 if (!util.isBuffer(buffer)) { 
 // legacy string interface (fd, length, position, encoding, callback) 
 //該部分的處理，和read方法內(nèi)部，完全相同，不再注釋。 
 //唯一區(qū)別，legacy標(biāo)識符，標(biāo)志是否傳入了buffer，為false時，表示傳入了 
 legacy = true; 
 var encoding = arguments[3]; 
 
 assertEncoding(encoding); 
 
 position = arguments[2]; 
 length = arguments[1]; 
 buffer = new Buffer(length); 
 
 offset = 0; 
 } 
 
 //C++的read方法，如果傳入了第六個參數(shù)，則屬于讀取成功之后，執(zhí)行的回調(diào)相關(guān)的對象 
 //如果不傳入，則返回值為讀取到的真是字節(jié)數(shù)，該數(shù)小于等于length 
 var r = binding.read(fd, buffer, offset, length, position); 
 if (!legacy) { 
 //如果，傳入了buffer對象，則直接返回讀取到的真是字節(jié)數(shù) 
 return r; 
 } 
 
 var str = (r > 0) ? buffer.toString(encoding, 0, r) : ''; 
 //如果沒有傳入buffer對象，那么返回一個數(shù)組，該數(shù)組包含兩個元素， 
 //字符串和讀取到的字節(jié)數(shù) 
 return [str, r]; 
}; 

var fs = require("fs"); 
 
fs.open("fs.txt","r",function(err,fd){ 
 //讀取fs.text，文件的內(nèi)容為“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] 
}); 

var fs = require("fs"); 
 
fs.open("fs.txt","a+",function(err,fd){ 
 //讀取fs.text，文件的內(nèi)容為“123456789”，長度為9 
 var buf1 = new Buffer("我喜愛Nodejs"); 
 console.log(buf1); 
 //顯示buf1的buffer數(shù)據(jù) 
 //計算buf1的長度，把該數(shù)據(jù)全部寫入到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開始的數(shù)據(jù) 
   console.log("str="+str); 
   //讀取相應(yīng)得到的字符串 
   //我喜愛Nodejs 
  }); 
 }); 
}); 

var fs = require("fs"); 
 
fs.open("fs.txt","a+",function(err,fd){ 
 //讀取fs.text，文件的內(nèi)容為“123456789”，長度為9 
  
 //復(fù)雜的寫法，和簡單的寫法，就看個人喜好了，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 
  //寫入的長度 
   
  //當(dāng)直接寫入字符串時，返回的也不再是buffer對象，而是字符串 
  console.log("str="+str); //我喜愛Nodejs 
  fs.read(fd,len,9,"utf8",function(err,str,len2){ 
   console.log("len2="+len2); //len2=15 
   //讀取從9開始的數(shù)據(jù) 
   console.log("str="+str); 
   //讀取相應(yīng)得到的字符串 
   //我喜愛Nodejs 
  }); 
 }); 
});