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被创建"); 
  }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构造函数定义 
function StatWatcher() { 
  //把EventEmitter内部的实例化属性添加到this对象上去。 
  //而EventEmitter的原型链属性和方法，不会被添加到this对象 
  //所以，基本上，也就是把EventEmitter实例中的domain,_events,_maxListeners这三个属性 
  //添加到了this对象上去了。 
  EventEmitter.call(this); 
 
  //把this缓存到self变量中，便于下面的闭包回调使用该创建闭包时的this对象 
  var self = this; 
 
  //调用C++实现的StatWatcher构造函数，并把返回的对象，赋值到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++中实现的StatWatcher实例化后的对象，定义它的onchange事件。 
  // 我测试过new binding.StatWatcher();实例化之后，是没有onchange属性的 
  // 所以，这里应该是属于直接定义改属性的，那么定义之后，在nodejs的C++代码实现中 
  // 是如何判断这个属性存在，然后在符合一定的条件下，又去执行这个属性的呢？ 
  // 这是我疑惑的地方，这个需要当学习到更多这方面的知识后，再去了解一下。 
  // 经过我的测试，这个属性，是在实例的start执行时需要的，如果没有定义该属性 
  // 那么，在使用start方法，开始监听事件时，会被抛出异常的 
  // 抛出异常，是因为你监听的文件，当前不存在～～ 
  // 如果监听的文件，当前已经存在，则不会执行onchange的回调 
  this._handle.onchange = function(current, previous, newStatus) { 
    // 当实例被话之后，当被监听的文件，被更改时，都会触发该属性的回调函数 
    // 并且传入三个参数 
 
    // 这里的三个判断，当前不知道为什么会在这个时候，不执行～～ 
    if (oldStatus === -1 && 
      newStatus === -1 && 
      current.nlink === previous.nlink) return; 
 
    oldStatus = newStatus; 
 
    // 触发self对象的中的change事件，并且把current和previous对象， 
    // 传入到change事件的回调函数 
    // 在本构造函数内部，是没有继承EventEmitter构造函数原型链中的方法的 
    // 但是这里，却使用了原型链中的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重新定义来原型链之后，再执行其他的扩展，以防止原型链断链的情况 
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是否合法 
  //如果不合法，则抛出一个异常然后停止执行 
  nullCheck(filename); 
 
  //调用path模块的方法，返回文件的绝对路径 
  filename = pathModule.resolve(filename); 
  var stat; 
  var listener; 
 
  //默认的配置信息，这里也说明来下，为何监听间隔为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 
  }; 
 
  //对参数进行判断，判断是否有自定义的option，如果有，使用自定义的 
  //没有定义的，使用默认值 
  //回调函数赋值 
  if (util.isObject(arguments[1])) { 
    options = util._extend(options, arguments[1]); 
    listener = arguments[2]; 
  } else { 
    listener = arguments[1]; 
  } 
 
  //回调函数是必须的，如果没有回调函数，则直接抛出一个异常，并停止运行 
  if (!listener) { 
    throw new Error('watchFile requires a listener function'); 
  } 
 
  //看完上面的inStatWatchers的源码之后，觉得这里是否可以再次优化一次？ 
  //stat =inStatWatchers(filename); 
  //if(!stat){ 
    //stat = statWatchers[filename] = new StatWatcher(); 
    //stat.start(filename,options.persistent,options.interval); 
  //} 
  //这样的话，就可以节省一次对象的查找和取值了 
 
  //判断该文件，是否已经创建了StatWatcher实例 
  if (inStatWatchers(filename)) { 
    //如果之前已经创建过了，则使用之前创建过的StatWatcher实例 
    stat = statWatchers[filename]; 
  } else { 
    //如果没有，则 重新创建一个，并把创建的示例，保存下来 
    //用于接下来的，玩意又对该文件再次添加watchFile时，使用 
    stat = statWatchers[filename] = new StatWatcher(); 
    //并且，对实例执行start的方法，应该是启动该实例不 
    stat.start(filename, options.persistent, options.interval); 
  } 
 
  //对该实例，监听change事件，并设置回调函数 
  stat.addListener('change', listener); 
 
  return stat; 
}; 

fs.unwatchFile(filename,[listener]); 

fs.unwatchFile = function(filename, listener) { 
  //判断filename是否合法，不合法，则抛出异常 
  nullCheck(filename); 
 
  // 把filename转换成绝对地址 
  filename = pathModule.resolve(filename); 
 
  // 判断需要解除绑定文件，是否有缓存StatWatchers的实例， 
  // 如果没有，则表示，没有绑定过监听事件，则不需要去解除绑定 
  if (!inStatWatchers(filename)) return; 
 
  var stat = statWatchers[filename]; 
  // 依然觉得，上两行代码，是可以优化一下的，如下： 
  // var stat = inStatWatchers(filename); 
  //if(!stat){return "";} 
  //依然是两行代码，可是却少了一次作用链的查找，和遍历对象的取值 
 
  // 判断，第二个参数，是否为一个function，如果是，则移除该function的回调 
  // 否则，移除该文件所有的监听回调函数 
  if (util.isFunction(listener)) { 
    stat.removeListener('change', listener); 
  } else { 
    stat.removeAllListeners('change'); 
  } 
 
  // 判断该文件，是否还有监听的回调函数，如果没有了，则清除 
  // 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方法使用到的构造函数 
function FSWatcher() { 
  // 继承事件模块中的实例内部属性和方法 
  EventEmitter.call(this); 
 
  // 缓存this对象，在闭包的回调函数中使用 
  var self = this; 
 
  // 获取C++中实现的FSEvent构造函数， 
  // 该获取是否应该放到函数外部去，优化代码 
  // 就像在StatWatcher构造函数内部的binding.StatWatcher();方法 
  var FSEvent = process.binding('fs_event_wrap').FSEvent; 
  this._handle = new FSEvent(); 
  this._handle.owner = this; 
 
  //绑定回调，onchange事件 
  this._handle.onchange = function(status, event, filename) { 
    // event变了好像是有问题的，我本地测试，event的值一直是“rename” 
    // 根据status的值，作出不同的处理 
    if (status < 0) { 
      self._handle.close(); 
      self.emit('error', errnoException(status, 'watch')); 
    } else { 
      self.emit('change', event, filename); 
    } 
  }; 
} 
 
// FSWatcher的原型链继承EventEmitter构造函数的原型链的属性和方法 
util.inherits(FSWatcher, EventEmitter); 
 
// start方法，当初始化构造函数之后，要执行该方法，才能开始监听filename指向的目录或者文件 
FSWatcher.prototype.start = function(filename, persistent, recursive) { 
  nullCheck(filename); 
 
  //调用C++中实现的方法，开始执行监听动作 
  var err = this._handle.start(pathModule._makeLong(filename), 
    persistent, 
    recursive); 
 
  // 如果监听时，没有能正确的执行，则关闭该实例，并且抛出一个异常 
  if (err) { 
    this._handle.close(); 
    throw errnoException(err, 'watch'); 
  } 
}; 
 
// 关闭监听 
FSWatcher.prototype.close = function() { 
  this._handle.close(); 
}; 
 
fs.watch = function(filename) { 
 
  // 判断filename是否合法 
  nullCheck(filename); 
  var watcher; 
  var options; 
  var listener; 
 
  // 判断是否有参数 
  // 初始化参数和回调函数 
  if (util.isObject(arguments[1])) { 
    options = arguments[1]; 
    listener = arguments[2]; 
  } else { 
    options = {}; 
    listener = arguments[1]; 
  } 
 
  // 给persistent和recursive设置默认值，这里我依然觉得是可以优化的。 
  // 既然在后面只是使用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; 
 
  // 创建FSWatcher的实例，并执行实例中的start方法，开始监听filename的更新事件 
  watcher = new FSWatcher(); 
  watcher.start(filename, options.persistent, options.recursive); 
 
  // 如果有回调函数，则添加一个绑定事件，并设置它的回调函数 
  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(); 
  //关闭 
}); 
 
 
var ff = fs.watchFile("./message.txt",function(curr,prev){ 
  console.log("change21"); 
}); 
 
ff.on("change",function(){ 
  console.log("change22"); 
  ff.stop(); 
  //关闭 
}); 

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