/*
Promise到底是个什么梗？
作为新手，这两天被promise弄得对Node.js的兴趣少了一半！百度'nodejs promise'出来的文章基本都是你抄我我抄你，没有一个能讲明白的，难道用一些通俗易懂的例子来解释就这么难吗?，我没学过es6，只会一些非常简单的js语法，我只想用node做点小玩意，难道不学es6就玩不了node吗？劳资偏不信这个邪！
*/

var Promise = require('bluebird');
var util = require('util');

/*一个简单得不能再简单的模拟的异步方法*/
function sum(p1, p2, callback){
    setTimeout(function(){
        var e = parseInt(Math.random()*10);//模拟随机产生异常
        if(e){
            callback(null, p1+p2);
        }else{
			callback(util.format("发生异常:p1=%d, p2=%d",p1,p2));
        }
    },1000);
}
//一般异步方法都是这样用的：（像fs、http等）
/*
sum(1, 2, function (err, sum) {
    if(err){
        console.log(err);
    } else {
        console.log(sum);
    }
})
*/
/*
//而一些情况下我们真的会这样用：
sum(1, 2, function (err, sum) {
    if(err){
        console.log(err);
    } else {
        sum(sum, 3, function (err, sum) {
            if(err){
                console.log(err);
            } else {
                sum(sum, 4, function (err, sum) {
                    if(err){
                        console.log(err);
                    } else {
                        console.log(sum);
                    }
                });
            }
        });
    }
})
*/
/*
整个逻辑简单得不得了,而代码却像屎一样难看，但是下一步的操作总是依赖上一步的操作，虽然方法是异步的，但是你只能这样嵌套，你有更好的办法吗？请告诉我
这个逻辑就像是：
1.一个用户请求访问一个文件，但是我首先要判断一下文件是否存在，这就是第一个异步了
2.如果文件存在，我又去数据里查一下这个文件他能不能访问，这又是一个异步
3.如果可以访问，最后我再把这个文件发送出去，这又是一个异步

你说这种逻辑不是和php之类的一样吗？node的异步方式有个卵用！
是的，我也是这么认为的，但是“大家好才是真的好”，大家都说好，那必有其道理，是我等还没领悟到。那没领悟到之前，问题总得解决吧，
这种屎一样的代码除了电脑，谁看了都不爽.

先不说传说中的Promise库怎么用，想想connect或express对中间件的处理方式
app.use(中间件1)
app.use(中间件2)
app.use(中间件3)
app.use(异常处理中间件)
中间件怎么处理的呢？当前中间件处理不了或者完成了工作就转移到下一个中间件
function(req,res,next){ //一般中间件大概长这个样子，和http.createServer()那个回调不同的是，多了一个next参数
	next(); //next是个函数，调用他之后就会把工作转移到下一个中间件，next可以传递参数，这参数一传就直接跳到异常处理去了！不传就是到下一个普通中间件
}
异常处理中间件
function(err,req,res,next){ //区别就是第一个参数是err，这种区别怎么判断呢? arguments.length判断函数的参数个数！！！就这么简单
	next('error'); //和普通中间件一样，这里给下一个异常处理传了'error'字符串，就是第一个参数，普通中间件的next玩法一样
}
对于中间件我大概就说这么多了。基于这种思想，寡人自己发明了个轮子：
*/
/*
function Next(){
    this.funcs = [];
}
Next.prototype.next = function(callback){
    this.funcs.push(callback);
    return this;
}
Next.prototype.start = function(){
    var func = this.funcs.shift();
    func && func.apply(this,arguments);
}
exports = module.exports = Next;

//用法很简单,next()就是不断的添加函数，start就是按顺序执行他们，
var next = new Next();

next.next(function(p1,p2){
	sum(p1,p2,function(e,sum){
		if(e){
			console.log(e);
		}else{
			next.start(sum,3);
		}
	})
}).next(function(p1,p2){
	sum(p1,p2,function(e,sum){
		if(e){
			console.log(e);
		}else{
			next.start(sum,4);
		}
	})
}).next(function(p1,p2){
	sum(p1,p2,function(e,sum){
		if(e){
			console.log(e);
		}else{
			console.log(sum);
		}
	})
})
next.start(1,2)
*/
/*
程序还是那个程序，但是层次结构清晰多了，毕竟node.js也有些年头了，我等菜鸟没有必要重新发明轮子
var Promise = require('bluebird'); //bluebird就是一个现成的Promise，拿过来用


Promise据说就能解决坑爹的回调问题，但是，寡人却看不懂网上别人写的文章到底TM是什么意思！
Promise大概说的是这样一种结构：

Promise(function(){
	//异步操作1
}).then(function(data){
	//异步操作2，可以收到上面那个异步操作的结果
}).then(function(data){
    //异步操作3，可以收到上面那个异步操作的结果
}).catch(function(e){ 
	 //如果上面的任何一步发生异常就直接到这里了
})
*/
//这就是一个基本的用法
/*
new Promise(function(resolve, reject){  //原理和我的轮子差不多，不过调用下一步的方法放到了函数参数上，我不清楚这有什么好处
    sum(1, 2, function(err, sum){
		if (err) {
			reject(err);
		} else {
			resolve(sum)
		}
	});
}).then(function(data){
	console.log(data);
}).catch(function(err){
	console.log(err);
});
*/

//问题就TM来了，是啊，这是把回调拆开来了，可是then里面没有resolve, reject了，下一步呢？
/*
new Promise(function(resolve, reject){
    sum(1, 2, function(err, sum){
		if (err) {
			reject(err);
		} else {
			resolve(sum)
		}
	});
}).then(function(data){
	console.log(data);

}).then(function(data){ //我先不管下一步怎么办，上面不是说是.then().then()这种结构嘛，我毫不犹豫地就复制了一份
	console.log(data); //输出undefined，尼码，还真执行了，但是上一步没有resolve来传递参数啊！

}).catch(function(err){
	console.log(err);
});
*/

//经过研究，原来是要在then()里再返回一个Promise对象
/*
new Promise(function(resolve, reject){
    sum(1, 2, function(err, sum){
		if (err) {
			reject(err);
		} else {
			resolve(sum)
		}
	});
}).then(function(data){
	console.log(data);
	return new Promise(function(resolve, reject){  //屎一样的代码，原来是要这么用！
				sum(data, 3, function(err, sum){
					if (err) {
						reject(err);
					} else {
						resolve(sum)
					}
				});
})

}).then(function(data){
	console.log(data); 

}).catch(function(err){ //原来catch真的可以在上面任何一个地方出错时中断顺序直接到达这里，这真的不好理解，按理来说别的Promise对象发生什么事不归他管啊？
	console.log(err);
});
*/
/*现在，让我们的代码变得更加优雅一点吧
//对sum函数进行包装
function psum(p1,p2){
	return new Promise(function(resolve,reject){
		sum(p1, p2, function(err,s){
			if(err){
				reject(err);
			}else{
				resolve(s);
			}
		});
	});
}

psum(1,2).then(function(data){
	console.log(data);
	return psum(data,3);

}).then(function(data){
	console.log(data);
	return psum(data,4);

}).then(function(data){
	console.log(data);
	//return ;  //达到最终目的，没有必要再返回什么东西了

}).catch(function(err){
	console.log(err);
});
//当然bluebird给我们提供了更简单的方式帮我们自动完成了，你可以试试用下面这行代码来代替我们手动包装的psum
//var psum = Promise.promisify(sum);
*/

以上这就是Promise的一个基本用法了。

/*
//然而，事情并不是我们想像中那么美好，定义一个ret函数，只是简单的把两个参数原封不动返回
function ret(p1, p2, callback){
    setTimeout(function(){
        var e = parseInt(Math.random()*10);//模拟随机产生异常
        if(e){
            callback(null, p1, p2);
        }else{
			callback(util.format("发生异常:p1=%d, p2=%d",p1,p2));
        }
    },1000);
}

//var pret = Promise.promisify(ret);
var pret = function(p1,p2){
	return new Promise(function(resolve,reject){
		ret(p1,p2,function(e, a, b){
			if(e){
				reject(e);
			}else{
				resolve(a,b);
			}
		});
	});
};

pret(11,22).then(function(a,b){  //我想当然的以为a,b会传回来，然而并没有，这就是说resolve只能传递一个参数
	console.log(a,b);  //11 undefined
	console.log(arguments); //{ '0': 11 }
}).catch(function(e){
	console.log(e);
});

*/




/*
Promise还有一个网上传说中的用法
**无关系汇总任务**
*/
function foo(p1, p2, callback){//还是一个异步的加法
	var str = 'foo('+p1+','+p2+')';
	var delay = (p1==1) ? 3000 : 1000;//故意让pfoo(1,2)返回得慢一些

	console.log(str + '异步开始');
    setTimeout(function(){
		console.log(str + '异步完成');
		callback(null, p1+p2);
    },delay);
}
var pfoo = Promise.promisify(foo);//Promise化foo函数

var promise1 = pfoo(1,2);
var promise2 = pfoo(3,4);
var arr = [ promise1, promise2 ];

Promise.all(arr).then(function(datas){
	console.log(datas);
	var sum = 0;
	for(var i in datas){
		sum += datas[i];
	}
	console.log('sum=' + sum);
});
/*
结果：
foo(1,2)异步开始
foo(3,4)异步开始
foo(3,4)异步完成
foo(1,2)异步完成
[ 3, 7 ]
sum=10

可以看到两次调用是‘同时执行’的，而不是一个等待另一个执行完毕再执行
这样一来上面所说的：
“1.一个用户请求访问一个文件，但是我首先要判断一下文件是否存在，这就是第一个异步了
2.如果文件存在，我又去数据里查一下这个文件他能不能访问，这又是一个异步
3.如果可以访问，最后我再把这个文件发送出去，这又是一个异步”

就可以优化了：
同时两个异步任务，一个检查文件是否存在，另一个去查数据库
两个任务都完成了再根据两个任务的结果决定最终的处理方式，这样，node异步方式的优势似乎又回来了。


以上内容均属个人观点，如有雷同纯属巧合，如有异议者请详细说明，寡人读书少，网上的Promise真的太概念化了，对新手一点都不友好
2016/09/04 19:05 入node坑一星期左右，之前几乎没用js做过什么事情
*/