Nodejs异步编程二——Promise/A

Promise/A模式相对比较简单，主要适用于单个异步操作,具体如下：

• 只会存在三种状态：未完成态、完成态和失败态。
• 未完成态只能向完成态和失败态转化。完成态和失败态不能相互转化。
• 状态一旦转化，不能更改。

以文件读取为例

var fs = require("fs");
var path = require("path");

var readStream = fs.createReadStream(path.normalize('/test/1.txt'));
var fileContent = "";

readStream.on("error", function(err){
    console.log(err);
})

readStream.on("data", function(data){
    fileContent += data;
})

readStream.on("end", function(){
    console.log("读取完成");
    console.log(fileContent.toString());
})

通过events模块实现一个简单的Promise/A。

Promise

var util = require("util");
var EventEmitter = require("events");

var Promise = function(){
    EventEmitter.call(this);
}

util.inherits(Promise, EventEmitter)

Promise.prototype.then = function(successHandler, errorHandler, processHandler){
    if(typeof successHandler === 'function'){
        // 成功函数只执行一次
        this.once('success', successHandler);
    }
    if(typeof errorHandler === 'function'){
        // 失败函数只执行一次
        this.once('error', errorHandler)
    }
    if(typeof processHandler === 'function'){
        this.on('process', processHandler)
    }
}

Deffered

var Deferred = function() {
    this.state = 'unfulfilled';
    this.promise = new Promise();
}

Deferred.prototype.resolve = function(obj){
    this.state = 'fulfilled';
    this.promise.emit("success", obj);
}

Deferred.prototype.reject = function(err){
    this.state = 'failed';
    this.promise.emit("error", err);
}

Deferred.prototype.process = function(data){
    this.promise.emit("process", data);
}

封装

var deferred = function(readStream){
var defferred = new Deferred();
readStream.on("error",function(err){
    defferred.reject(err)
})
readStream.on("end", function(){
    defferred.resolve();
})
readStream.on("data", function(data){
    defferred.process(data)
})
return defferred.promise;
}

var fileContent = ""
deferred(readStream).then(function(){
    console.log(fileContent.toString());
}, function(err){
    console.log(err);
}, function(data){
    fileContent += data;
})