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被修改");
}
});

函数定义 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 === prev<a href="https://www.jb51.cc/tag/IoU/" target="_blank" class="keywords">IoU</a>s.nlink) return; 

oldStatus = newStatus; 

// 触发self对象的中的change事件，并且把current和prev<a href="https://www.jb51.cc/tag/IoU/" target="_blank" class="keywords">IoU</a>s对象， 
// 传入到change事件的回调<a href="https://www.jb51.cc/tag/hanshu/" target="_blank" class="keywords">函数</a> 
// 在本构造<a href="https://www.jb51.cc/tag/hanshu/" target="_blank" class="keywords">函数</a>内部，是没有继承EventEmitter构造<a href="https://www.jb51.cc/tag/hanshu/" target="_blank" class="keywords">函数</a>原型链中的<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>的 
// 但是这里，却使用了原型链中的emit<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>。why？ 
self.emit('change',current,prev<a href="https://www.jb51.cc/tag/IoU/" target="_blank" class="keywords">IoU</a>s); 

};

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),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.interval);
}

//对该实例，监听change事件，并设置回调函数
stat.addListener('change',listener);

return stat;
};

// 把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;
}
};

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

方法使用到的构造函数 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',filename);
}
};
}

// FSWatcher的原型链继承EventEmitter构造函数的原型链的属性和方法
util.inherits(FSWatcher,EventEmitter);

// start方法，当初始化构造函数之后，要执行该方法，才能开始监听filename指向的目录或者文件
FSWatcher.prototype.start = function(filename,recursive) {
nullCheck(filename);

//调用C++中实现的方法，开始执行监听动作
var err = this._handle.start(pathModule._makeLong(filename),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,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.recursive);

// 如果有回调函数，则添加一个绑定事件，并设置它的回调函数
if (listener) {
watcher.addListener('change',listener);
}

// 返回该实例
return watcher;
};

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

f.on("change",filename){
console.log("change12");
f.close();
//关闭
});

var ff = fs.watchFile("./message.txt",prev){
console.log("change21");
});

ff.on("change",function(){
console.log("change22");
ff.stop();
//关闭
});

var f = fs.watch("./",filename){
console.log("change11");
});

var ff = fs.watchFile("./message.txt",prev){
console.log("change21");
});

f.emit("change");
ff.emit("change");