文本操作模塊-fs模塊(二)

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="">
    //初始時的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 35="" 36="" 37="" 38="" 39="" 00="">
                console.log(buffer);
        //<buffer 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中文版。

發佈留言