# 概述
ES6 原生提供了 Promise 对象。并且现在有很多框架实现了Promise方案，比如Q框架、bulebird框架。
所谓 Promise，就是一个对象，用来传递异步操作的消息。它代表了某个未来才会知道结果的事件（通常是一个异步操作），并且这个事件提供统一的 API，可供进一步处理。
Promise 对象有以下两个特点。
* 对象的状态不受外界影响。Promise 对象代表一个异步操作，有三种状态：Pending（进行中）、Resolved（已完成，又称 Fulfilled）和 Rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是 Promise 这个名字的由来，它的英语意思就是「承诺」，表示其他手段无法改变。
* 一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise 对象的状态改变，只有两种可能：从 Pending 变为 Resolved 和从 Pending 变为 Rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果。就算改变已经发生了，你再对 Promise 对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。
有了 Promise 对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。此外，Promise 对象提供统一的接口，使得控制异步操作更加容易。
Promise 也有一些缺点。首先，无法取消 Promise，一旦新建它就会立即执行，无法中途取消。其次，如果不设置回调函数，Promise 内部抛出的错误，不会反应到外部。第三，当处于 Pending 状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）。
Promise 构造函数接受一个函数作为参数，该函数的两个参数分别是 resolve 方法和 reject 方法。
如果异步操作成功，则用 resolve 方法将 Promise 对象的状态，从「未完成」变为「成功」（即从 pending 变为 resolved）；
如果异步操作失败，则用 reject 方法将 Promise 对象的状态，从「未完成」变为「失败」（即从 pending 变为 rejected）。
# 目前流行的Promise框架
* Q框架 https://github.com/kriskowal/q
* bluebird框架 https://github.com/petkaantonov/bluebird
* co框架 https://github.com/tj/co
* when框架 https://github.com/cujojs/when
# Promise框架基本的 api
~~~
//以完成状态
Promise.resolve()
//以失败状态
Promise.reject()
//执行完毕回调
Promise.prototype.then()
//捕获异常
Promise.prototype.catch()
// 所有的完成
Promise.all()
// 竞速，完成一个即可
Promise.race()
~~~
# 使用Q框架异步应用的案例
## 首选使用Q框架的原因在于以下几点
* jQuery里面的异步使用的是Q框架
* Angular里面的异步使用的也是Q框架
* Express里面并没有使用异步框架
* 因此综上所述选用Q框架还是具备一定的优势，现在讲究全栈开发，最好在异步框架的选择上达到前后数据端完全一致
# Q框架资源地址
* API: https://github.com/kriskowal/q/wiki/API-Reference
* Q框架 https://github.com/kriskowal/q
# Q框架安装
## NodeJS安装
~~~
npm install q -g
~~~
## angular框架体系安装
angular自带$q服务，无需安装
## jquery安装
jQuery中有deferred对象。无需安装。deferred对象与q框架如出一辙。基本使用方法和原理一样
# Q框架的案例
* 写一个函数带一个参数，返回函数结果为该参数累加1000，如果结果大于5000则返回错误，如果小于5000则返回累加结果。
~~~
//引用q框架
var Q = require('q');
//全局数据
//函数首选promise化
function f1(args) {
var defered = Q.defer();
setTimeout(function () {
//计算
args += 1000;
//如果结果大于5000那么给出错误的结果
if (args > 5000) {
//错误的结果
defered.reject('错误');
}
else {
//正确的结果
defered.resolve(args);
}
}, 1000);
return defered.promise;
};
//执行f1，并且执行then方法，等待异步结果
f1(100).then(function (data) {
console.log(data);
},function (err) {
console.log(err);
});
~~~
* 【使用q框架处理有一连串的异步方法，需要按顺序执行】一个变量经历4个工序，分别每个工序需要若干时间，假设第一个工序需要1秒，第二个工序需要2秒，第三个工序需要4秒，第四个工序需要1秒
~~~
var Q = require('q');
//f1(data)的参数data为初始值
function f1(data) {
var defered = Q.defer();
setTimeout(function () {
data += 'f1';
console.log('f1结束');
defered.resolve(data);
}, 1000);
return defered.promise;
};
//f2(data)的参数data会衔接上f1的data的结果
function f2(data) {
var defered = Q.defer();
setTimeout(function () {
data += 'f2';
console.log('f2结束');
defered.resolve(data);
}, 2000);
return defered.promise;
};
function f3(data) {
var defered = Q.defer();
setTimeout(function () {
data += 'f3';
console.log('f3结束');
defered.resolve(data);
}, 4000);
return defered.promise;
};
function f4(data) {
var defered = Q.defer();
setTimeout(function () {
data += 'f4';
console.log('f4结束');
defered.resolve(data);
}, 1000);
return defered.promise;
};
f1('hzj').then(f2).then(f3).then(f4).done(function (data) {
console.log(data);
});
~~~
* 动态多异步任务顺序执行
~~~
var Q = require('q');
function f2(temp) {
var defered = Q.defer();
setTimeout(function () {
temp.data += 'f2';
console.log(temp.js + ':f2结束');
temp.js += 1;
defered.resolve(temp);
}, 2000);
return defered.promise;
};
//动态自定义函数异步队列
function task() {
//需要执行的函数数组,需要注意的是这里是函数对象，并不是执行函数,且函数对象需要返回的是promise
var funcs = [f2, f2, f2, f2];
//设置初始值
var temp = {
//计数器
js: 0,
//真正的数据
data: 'hzj'
};
//实例化Q,并且给出初始值
var result = Q(temp);
//开始异步顺序执行函数数组里面的函数
//形成xx.then().then().then()形式
funcs.forEach(function (f) {
result = result.then(f);
});
//返回最后一个异步任务
return result;
}
//开始执行
//done方法为全部结束后，执行结果
task().done(function (data) {
console.log(data.data);
});
~~~
* Express中处理MySQL数据库的异步案例
~~~
//引入异步模块q
var q = require('q');
//引入express模块
var express = require('express');
//引入mysql模块
var mysql = require('mysql');
//数据库连接信息
var mysqlObj = {
host: 'localhost',
user: 'root',
port: 3306,
password: '123456',
database: 'question'
};
//express的app对象
var app = express();
//主表【1】
function f1() {
var defer = q.defer();
var connection = mysql.createConnection(mysqlObj);
connection.connect();
connection.query('select * from topic where topicType_id in(1,2)', function (err, rows, fields) {
if (err) {
defer.reject(err);
} else {
defer.resolve(rows);
}
});
connection.end;
return defer.promise;
}
//副表【n】【主副表关系为1:n】
function f2(data, id) {
var defer = q.defer();
var connection = mysql.createConnection(mysqlObj);
connection.connect();
connection.query('select * from item where topic_id=?;', [id], function (err, rows, fields) {
if (err) {
defer.reject(err);
}
else {
data.item = rows;
defer.resolve(data);
}
});
connection.end();
return defer.promise;
}
//启动路由
app.get('/topic/item', function (req, res) {
res.header("Access-Control-Allow-Origin", "*");
res.header("Access-Control-Allow-Headers", "X-Requested-With");
res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
res.header("X-Powered-By", ' 3.2.1');
res.header("Content-Type", "application/json;charset=utf-8");
var qQuerer = [];
var tempData = [];
f1().then(function (data) {
for (var i = 0; i < data.length; i++) {
qQuerer.push(f2(data[i], data[i].id));
}
//q.all的展开方案spread方法
//spread方法内置一个arguments数组
q.all(qQuerer).spread(function () {
for (var i = 0; i < data.length; i++) {
tempData.push(arguments[i]);
}
res.send(tempData);
});
});
});
//开服
app.listen(8888, function () {
console.log('OK');
});
~~~
* Angular服务中使用HTTP协议的异步案例
~~~
//Angular的自定义服务
//$http为Angular的http服务
//$q为Angular的异步服务
angular.module('myapp').service('topicServer', function ($http, $q) {
//开启异步对象
var defer = $q.defer();
$http.get('http://localhost:8888/topic/item').success(function (data, status, headers, congfig) {
//成功的时候使用resolve方法添加参数
defer.resolve(data);
}).error(function (data, status, headers, congfig) {
//失败的时候使用reject方法添加参数
defer.reject(data);
});
//返回异步对象【服务里面没有办法处理异步只能返回异步对象由控制器负责处理】
this.data = defer.promise;
});
angular.module('myapp').controller('indexCtrl',function ($scope,topicServer) {
//Angular控制器中调度服务的异步执行结果
topicServer.data.then(function (data) {
$scope.topic=data;
});
$scope.ASC=function (number) {
return String.fromCharCode(number+65);
};
});
~~~
* html模板显示
~~~
<!DOCTYPE html>
<html lang="en" ng-app="myapp">
<head>
<meta charset="UTF-8">
<title>Title</title>
<!--CSS-->
<link rel="stylesheet" href="../bower_components/bootstrap/dist/css/bootstrap.min.css">
<link rel="stylesheet" href="../bower_components/font-awesome/css/font-awesome.min.css">
<link rel="stylesheet" href="assets/css/mystyle.css">
<!--jquery-->
<script src="../bower_components/jquery/dist/jquery.min.js"></script>
<!--B3-->
<script src="../bower_components/bootstrap/dist/js/bootstrap.min.js"></script>
<!--angular-->
<script src="../bower_components/angular/angular.min.js"></script>
<!--angular路由-->
<script src="../bower_components/angular-ui-router/release/angular-ui-router.min.js"></script>
<!--模块顺序【1】-->
<script src="app.js"></script>
<!--路由表-->
<script src="router/uiRouter.js"></script>
<script src="run/run.js"></script>
<script src="server/basePath.js"></script>
<!--其他控制器-->
<script src="controller/indexCtrl.js"></script>
<script src="server/subjectServer.js"></script>
<script src="server/topictypeServer.js"></script>
<script src="server/topicServer.js"></script>
</head>
<body>
<div ng-controller="indexCtrl">
<ul>
<li ng-repeat="item in topic">
{{ $index+1+':'+item.name}}
<ul>
<li ng-repeat="item2 in item.item">
{{ ASC($index)+':'+item2.name}}
</li>
</ul>
</li>
</ul>
</div>
</body>
</html>
~~~
