fs.watchFile(filename,[option],listener); 

var fs = require("fs"); 
 
fs.watchFile("./message.txt",function(curr,prev){ 
  if(Date.parse(prev.ctime) == 0){ 
    console.log("message.txt被創(chuàng)建"); 
  }else if(Date.parse(curr.ctime) == 0){ 
    console.log("message.txt被刪除"); 
  }else if(Date.parse(prev.mtime) != Date.parse(curr.mtime)){ 
    console.log("message.txt被修改"); 
  } 
}); 

// Stat Change Watchers 
// StatWatcher構(gòu)造函數(shù)定義 
function StatWatcher() { 
  //把EventEmitter內(nèi)部的實例化屬性添加到this對象上去。 
  //而EventEmitter的原型鏈屬性和方法，不會被添加到this對象 
  //所以，基本上，也就是把EventEmitter實例中的domain,_events,_maxListeners這三個屬性 
  //添加到了this對象上去了。 
  EventEmitter.call(this); 
 
  //把this緩存到self變量中，便于下面的閉包回調(diào)使用該創(chuàng)建閉包時的this對象 
  var self = this; 
 
  //調(diào)用C++實現(xiàn)的StatWatcher構(gòu)造函數(shù)，并把返回的對象，賦值到this對象的_handle屬性上 
  this._handle = new binding.StatWatcher(); 
 
  // uv_fs_poll is a little more powerful than ev_stat but we curb it for 
  // the sake of backwards compatibility 
  var oldStatus = -1; 
 
  //當C++中實現(xiàn)的StatWatcher實例化后的對象，定義它的onchange事件。 
  // 我測試過new binding.StatWatcher();實例化之后，是沒有onchange屬性的 
  // 所以，這里應(yīng)該是屬于直接定義改屬性的，那么定義之后，在nodejs的C++代碼實現(xiàn)中 
  // 是如何判斷這個屬性存在，然后在符合一定的條件下，又去執(zhí)行這個屬性的呢？ 
  // 這是我疑惑的地方，這個需要當學習到更多這方面的知識后，再去了解一下。 
  // 經(jīng)過我的測試，這個屬性，是在實例的start執(zhí)行時需要的，如果沒有定義該屬性 
  // 那么，在使用start方法，開始監(jiān)聽事件時，會被拋出異常的 
  // 拋出異常，是因為你監(jiān)聽的文件，當前不存在～～ 
  // 如果監(jiān)聽的文件，當前已經(jīng)存在，則不會執(zhí)行onchange的回調(diào) 
  this._handle.onchange = function(current, previous, newStatus) { 
    // 當實例被話之后，當被監(jiān)聽的文件，被更改時，都會觸發(fā)該屬性的回調(diào)函數(shù) 
    // 并且傳入三個參數(shù) 
 
    // 這里的三個判斷，當前不知道為什么會在這個時候，不執(zhí)行～～ 
    if (oldStatus === -1 && 
      newStatus === -1 && 
      current.nlink === previous.nlink) return; 
 
    oldStatus = newStatus; 
 
    // 觸發(fā)self對象的中的change事件，并且把current和previous對象， 
    // 傳入到change事件的回調(diào)函數(shù) 
    // 在本構(gòu)造函數(shù)內(nèi)部，是沒有繼承EventEmitter構(gòu)造函數(shù)原型鏈中的方法的 
    // 但是這里，卻使用了原型鏈中的emit方法。why？ 
    self.emit('change', current, previous); 
  }; 
 
  this._handle.onstop = function() { 
    self.emit('stop'); 
  }; 
} 
 
// 把EventEmitter原型鏈的屬性和方法，擴展到StatWatcher對象的原型鏈中 
// 更確切的說明就是，StatWatcher.prototype = EventEmitter.prototype; 
util.inherits(StatWatcher, EventEmitter); 
 
// 在StatWatcher重新定義來原型鏈之后，再執(zhí)行其他的擴展，以防止原型鏈斷鏈的情況 
StatWatcher.prototype.start = function(filename, persistent, interval) { 
  nullCheck(filename); 
  this._handle.start(pathModule._makeLong(filename), persistent, interval); 
}; 
 
StatWatcher.prototype.stop = function() { 
  this._handle.stop(); 
}; 
 
//緩存Watcher的一個對象 
var statWatchers = {}; 
function inStatWatchers(filename) { 
  //判斷filename是否在statWatchers中，如果是則返回緩存的實例 
  return Object.prototype.hasOwnProperty.call(statWatchers, filename) && 
  statWatchers[filename]; 
} 
 
fs.watchFile = function(filename) { 
  //判斷fileName是否合法 
  //如果不合法，則拋出一個異常然后停止執(zhí)行 
  nullCheck(filename); 
 
  //調(diào)用path模塊的方法，返回文件的絕對路徑 
  filename = pathModule.resolve(filename); 
  var stat; 
  var listener; 
 
  //默認的配置信息，這里也說明來下，為何監(jiān)聽間隔為5007ms， 
  //只是，我表示，我是沒有看懂下面的英文注釋要說啥的 
  var options = { 
    // Poll interval in milliseconds. 5007 is what libev used to use. It's 
    // a little on the slow side but let's stick with it for now to keep 
    // behavioral changes to a minimum. 
    interval: 5007, 
    persistent: true 
  }; 
 
  //對參數(shù)進行判斷，判斷是否有自定義的option，如果有，使用自定義的 
  //沒有定義的，使用默認值 
  //回調(diào)函數(shù)賦值 
  if (util.isObject(arguments[1])) { 
    options = util._extend(options, arguments[1]); 
    listener = arguments[2]; 
  } else { 
    listener = arguments[1]; 
  } 
 
  //回調(diào)函數(shù)是必須的，如果沒有回調(diào)函數(shù)，則直接拋出一個異常，并停止運行 
  if (!listener) { 
    throw new Error('watchFile requires a listener function'); 
  } 
 
  //看完上面的inStatWatchers的源碼之后，覺得這里是否可以再次優(yōu)化一次？ 
  //stat =inStatWatchers(filename); 
  //if(!stat){ 
    //stat = statWatchers[filename] = new StatWatcher(); 
    //stat.start(filename,options.persistent,options.interval); 
  //} 
  //這樣的話，就可以節(jié)省一次對象的查找和取值了 
 
  //判斷該文件，是否已經(jīng)創(chuàng)建了StatWatcher實例 
  if (inStatWatchers(filename)) { 
    //如果之前已經(jīng)創(chuàng)建過了，則使用之前創(chuàng)建過的StatWatcher實例 
    stat = statWatchers[filename]; 
  } else { 
    //如果沒有，則 重新創(chuàng)建一個，并把創(chuàng)建的示例，保存下來 
    //用于接下來的，玩意又對該文件再次添加watchFile時，使用 
    stat = statWatchers[filename] = new StatWatcher(); 
    //并且，對實例執(zhí)行start的方法，應(yīng)該是啟動該實例不 
    stat.start(filename, options.persistent, options.interval); 
  } 
 
  //對該實例，監(jiān)聽change事件，并設(shè)置回調(diào)函數(shù) 
  stat.addListener('change', listener); 
 
  return stat; 
}; 

fs.unwatchFile(filename,[listener]); 

fs.unwatchFile = function(filename, listener) { 
  //判斷filename是否合法，不合法，則拋出異常 
  nullCheck(filename); 
 
  // 把filename轉(zhuǎn)換成絕對地址 
  filename = pathModule.resolve(filename); 
 
  // 判斷需要解除綁定文件，是否有緩存StatWatchers的實例， 
  // 如果沒有，則表示，沒有綁定過監(jiān)聽事件，則不需要去解除綁定 
  if (!inStatWatchers(filename)) return; 
 
  var stat = statWatchers[filename]; 
  // 依然覺得，上兩行代碼，是可以優(yōu)化一下的，如下： 
  // var stat = inStatWatchers(filename); 
  //if(!stat){return "";} 
  //依然是兩行代碼，可是卻少了一次作用鏈的查找，和遍歷對象的取值 
 
  // 判斷，第二個參數(shù)，是否為一個function，如果是，則移除該function的回調(diào) 
  // 否則，移除該文件所有的監(jiān)聽回調(diào)函數(shù) 
  if (util.isFunction(listener)) { 
    stat.removeListener('change', listener); 
  } else { 
    stat.removeAllListeners('change'); 
  } 
 
  // 判斷該文件，是否還有監(jiān)聽的回調(diào)函數(shù)，如果沒有了，則清除 
  // listenerCount方法，是繼承自EventEmitter的原型鏈中的方法ßßß 
  if (EventEmitter.listenerCount(stat, 'change') === 0) { 
    stat.stop(); 
    statWatchers[filename] = undefined; 
  } 
}; 

fs.watch(filename,[option],listener); 

var fs = require("fs"); 
 
var f = fs.watch("./",function(event,filename){ 
  console.log("event="+event); 
  console.log("filename="+filename); 
}); 

// watch方法使用到的構(gòu)造函數(shù) 
function FSWatcher() { 
  // 繼承事件模塊中的實例內(nèi)部屬性和方法 
  EventEmitter.call(this); 
 
  // 緩存this對象，在閉包的回調(diào)函數(shù)中使用 
  var self = this; 
 
  // 獲取C++中實現(xiàn)的FSEvent構(gòu)造函數(shù)， 
  // 該獲取是否應(yīng)該放到函數(shù)外部去，優(yōu)化代碼 
  // 就像在StatWatcher構(gòu)造函數(shù)內(nèi)部的binding.StatWatcher();方法 
  var FSEvent = process.binding('fs_event_wrap').FSEvent; 
  this._handle = new FSEvent(); 
  this._handle.owner = this; 
 
  //綁定回調(diào)，onchange事件 
  this._handle.onchange = function(status, event, filename) { 
    // event變了好像是有問題的，我本地測試，event的值一直是“rename” 
    // 根據(jù)status的值，作出不同的處理 
    if (status < 0) { 
      self._handle.close(); 
      self.emit('error', errnoException(status, 'watch')); 
    } else { 
      self.emit('change', event, filename); 
    } 
  }; 
} 
 
// FSWatcher的原型鏈繼承EventEmitter構(gòu)造函數(shù)的原型鏈的屬性和方法 
util.inherits(FSWatcher, EventEmitter); 
 
// start方法，當初始化構(gòu)造函數(shù)之后，要執(zhí)行該方法，才能開始監(jiān)聽filename指向的目錄或者文件 
FSWatcher.prototype.start = function(filename, persistent, recursive) { 
  nullCheck(filename); 
 
  //調(diào)用C++中實現(xiàn)的方法，開始執(zhí)行監(jiān)聽動作 
  var err = this._handle.start(pathModule._makeLong(filename), 
    persistent, 
    recursive); 
 
  // 如果監(jiān)聽時，沒有能正確的執(zhí)行，則關(guān)閉該實例，并且拋出一個異常 
  if (err) { 
    this._handle.close(); 
    throw errnoException(err, 'watch'); 
  } 
}; 
 
// 關(guān)閉監(jiān)聽 
FSWatcher.prototype.close = function() { 
  this._handle.close(); 
}; 
 
fs.watch = function(filename) { 
 
  // 判斷filename是否合法 
  nullCheck(filename); 
  var watcher; 
  var options; 
  var listener; 
 
  // 判斷是否有參數(shù) 
  // 初始化參數(shù)和回調(diào)函數(shù) 
  if (util.isObject(arguments[1])) { 
    options = arguments[1]; 
    listener = arguments[2]; 
  } else { 
    options = {}; 
    listener = arguments[1]; 
  } 
 
  // 給persistent和recursive設(shè)置默認值，這里我依然覺得是可以優(yōu)化的。 
  // 既然在后面只是使用persistent和recursive，那么為何不定義著涼變量 
  // var persistent = options.persistent, 
  //   recursive = options.recursive; 
  // if(util.isUndefined(persistent)) persistent = true; 
  // if(util.isUndefined(recursive)) recursive = false; 
  // ... 
  // watcher.start(filename,persistent,recursive); 
  // 我會認為，去一個對象中查找變量，比直接查找到一個變量，要花費多一點點的時間。 
 
  if (util.isUndefined(options.persistent)) options.persistent = true; 
  if (util.isUndefined(options.recursive)) options.recursive = false; 
 
  // 創(chuàng)建FSWatcher的實例，并執(zhí)行實例中的start方法，開始監(jiān)聽filename的更新事件 
  watcher = new FSWatcher(); 
  watcher.start(filename, options.persistent, options.recursive); 
 
  // 如果有回調(diào)函數(shù)，則添加一個綁定事件，并設(shè)置它的回調(diào)函數(shù) 
  if (listener) { 
    watcher.addListener('change', listener); 
  } 
 
  // 返回該實例 
  return watcher; 
}; 

var fs = require("fs"); 
 
var f = fs.watch("./",function(event,filename){ 
  console.log("event="+event); 
  console.log("filename="+filename); 
}); 
 
f.on("change",function(event,filename){ 
  console.log("change12"); 
  f.close(); 
  //關(guān)閉 
}); 
 
 
var ff = fs.watchFile("./message.txt",function(curr,prev){ 
  console.log("change21"); 
}); 
 
ff.on("change",function(){ 
  console.log("change22"); 
  ff.stop(); 
  //關(guān)閉 
}); 

var fs = require("fs"); 
 
var f = fs.watch("./",function(event,filename){ 
console.log("change11"); 
}); 
 
 
var ff = fs.watchFile("./message.txt",function(curr,prev){ 
console.log("change21"); 
}); 
 
f.emit("change"); 
ff.emit("change");