2956人阅读
angularJS（2）
本文转自：
如果想使用 $http 或者其他异步操作, 那 $q 是必须要掌握的概念啦. Let's get started!
假设有一个家具厂，而它有一个VIP客户张先生。
有一天张先生需要一个豪华衣柜，于是，他打电话给家具厂说我需要一个衣柜，回头做好了给我送来，这个操作就叫$q.defer，也就是延期，因为这个衣柜不是现在要的，所以张先生这是在发起一个可延期的请求。
同时，家具厂给他留下了一个回执号，并对他说：我们做好了会给您送过去，放心吧。这叫做promise，也就是承诺。
这样，这个defer算是正式创建了，于是他把这件事记录在自己的日记上，并且同时记录了回执号，这叫做deferred，也就是已延期事件。
现在，张先生就不用再去想着这件事了，该做什么做什么，这就是“异步”的含义。
假设家具厂在一周后做完了这个衣柜，并如约送到了张先生家（包邮哦，亲），这就叫做deferred.resolve(衣柜)，也就是“已解决”。而这时候张先生只要签收一下这个（衣柜）参数就行了，当然，这个“邮包”中也不一定只有衣柜，还可以包含别的东西，比如厂家宣传资料、产品名录等。整个过程中轻松愉快，谁也没等谁，没有浪费任何时间。
假设家具厂在评估后发现这个规格的衣柜我们做不了，那么它就需要deferred.reject(理由)，也就是“拒绝”。拒绝没有时间限制，可以发生在给出承诺之后的任何时候，甚至可能发生在快做完的时候。而且拒绝时候的参数也不仅仅限于理由，还可以包含一个道歉信，违约金之类的，总之，你想给他什么就给他什么，如果你觉得不会惹恼客户，那么不给也没关系。
假设家具厂发现，自己正好有一个符合张先生要求的存货，它就可以用$q.when(现有衣柜)来把这个承诺给张先生，这件事就立即被解决了，皆大欢喜，张先生可不在乎你是从头做的还是现有的成品，只会惊叹于你们的效率之高。
假设这个家具厂对客户格外的细心，它还可能通过deferred.notify(进展情况)给张先生发送进展情况的“通知”。
这样，整个异步流程就圆满完成，无论成功或者失败，张先生都没有往里面投入任何额外的时间成本。
好，我们再扩展一下这个故事：
张先生这次需要做一个桌子，三把椅子，一张席梦思，但是他不希望今天收到个桌子，明天收到个椅子，后天又得签收一次席梦思，而是希望家具厂做好了之后一次性送过来，但是他下单的时候又是分别下单的，那么他就可以重新跟家具厂要一个包含上述三个承诺的新承诺，这就是$q.all(桌子承诺，椅子承诺，席梦思承诺)，
这样，他就不用再关注以前的三个承诺了，直接等待这个新的承诺完成，到时候只要一次性签收了前面的这些承诺就行了。
$q 支持两种写法, 第一种是类似于ES6标准构造函数写法
$q(function resolver (resolve, reject) {})
+ ES6 写法并不支持 progress/notify 的回调函数
+ 在构造函数中抛异常也并不会显式的reject the promise
var iWantResolve = true;
function es6promise() {
return $q(function (resolve, reject) {
$timeout(function () {
if (iWantResolve) {
resolve(&es6promise resolved&);
reject(&es6promise reject&);
promise.then(successCb, errCb, notifyCb)
其中successCb 将在 promise resolve 后被调用, errCb 将在 promise reject 后被调
notifyCb 将在 deferred.notify 后被调用, 可以多次调用
promise.catch == promise.then(null, errCb), 用于处理之前没有被处理的 rejected promise
promise.finally 将最后被调用, 一般用于资源释放的清理操作
es6promise()
.then(function (data) {
console.log(data);
.catch(function (err) {
console.log(err);
// if(iWantResolve == true) output: es6promise resolved
// if(iWantResolve = false) output: es6promise reject
第二种是类似于 commonJS 的写法 $q.deferred()
function commonJsPromise() {
var deferred = $q.defer();
$timeout(function () {
deferred.notify(&commonJS notify&);
if (iWantResolve) {
deferred.resolve(&commonJS resolved&);
deferred.reject(&commonJS reject&);
return deferred.
commonJsPromise()
.then(function /** success callback**/(data) {
console.log(data);
}, function /** error callback **/ (err) {
console.log(err);
}, function /** progress callback **/ (update) {
console.log(update);
$q.all([promise1, promise1]) 接受一个包含若干个 promise 的数组,
等所有的 promise resolve 后, 其本身 resolve 包含上述结果的数组 [data1, data2]
如果上述 promise 有一个 reject, 那么$q.all() 会把这个 rejected promise 作为其 rejected promise (只有一个哦)
progress/notify 的 callback 并没有用
$q.all([es6promise(), commonJsPromise()])
.then(function (dataArr) {
console.log(&$q.all: &, dataArr);
}, function (err) {
console.log(&$q.all: &, err)
}, function /** unnecessary **/ (update) {
console.log(&$q.all&, update);
// if(iWantResolve == true) output: $q.all:
[&es6promise resolved&, &commonJS resolved&]
// if(iWantResolve = false) output: $q.all:
es6promise reject
$q.reject() 立即返回一个rejected 的 promise, 在链式调用的时候很有用
$q.resolve == $q.when(value, successCb, errorCb, progressCb)
value 可能是一个 then-able 的 obj(即可以是 $q.defer() 返回的, 也可以是其他库产生的), 也可能是任意数据, 但是 $q.when 最终都会返回一个 promise
$q.when 既可以写成上述的构造函数形式, 也可以写成 $q.when(value).then(fn, fn, fn) 的形式
$q.reject(&instant reject&)
.catch(function (err) {
console.log(err);
// output: instant reject
$q.when(commonJsPromise(),
function /** success callback **/(data) {
console.log(&$q.when success callback function: & + data);
return &$q.when success callback return another value&;
.then(function (data) {
console.log(&$q.when then function:& + data);
// if(iWantResolve == true) output:
// $q.when success callback functionL: commonJS resolved
// $q.when then function:$q.when success callback return another value
// if(iWantResolve = false) output:
// $q.when err callback function: commonJS reject
// $q.when then function:undefined
$q.when(&some value&, function (data){
console.log(data);
// output: some value
任何在 successCb, errCb 中返回的非 $q.reject()对象, 都将成为一个 resolve 的 promise.
所以可以出现如下语法 promise.then().then().then()
$q.when(&1&)
.then(function (data) {
console.log(data);
return $q.reject(2);
.catch(function (err) {
console.log(err);
.then(function (data) {
console.log(data);
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：442939次
积分：4218
积分：4218
排名：第7696名
原创：29篇
转载：144篇
评论：60条
(1)(4)(1)(3)(2)(4)(6)(10)(6)(3)(2)(2)(4)(1)(2)(1)(6)(9)(12)(8)(3)(11)(4)(2)(2)(4)(4)(6)(3)(1)(12)(14)(3)(1)(5)(1)(2)(4)(4)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'我们知道,JavaScript语言的执行环境是单线程的。
所谓&单线程&，就是指一次只能完成一件任务。如果有多个任务，就必须排队，前面一个任务完成，再执行后面一个任务，以此类推。
这种模式的好处是实现起来比较简单，执行环境相对单纯；坏处是只要有一个任务耗时很长，后面的任务都必须排队等着，会拖延整个程序的执行。常见的浏览器无响应（假死），往往就是因为某一段Javascript代码长时间运行（比如死循环），导致整个页面卡在这个地方，其他任务无法执行。
为了解决这个问题，Javascript语言将任务的执行模式分成两种：同步（Synchronous）和异步（Asynchronous）。
&同步模式&就是上一段的模式，后一个任务等待前一个任务结束，然后再执行，程序的执行顺序与任务的排列顺序是一致的、同步的；
&异步模式&则完全不同，每一个任务有一个或多个回调函数（callback），前一个任务结束后，不是执行后一个任务，而是执行回调函数，后一个任务则是不等前一个任务结束就执行，所以程序的执行顺序与任务的排列顺序是不一致的、异步的。
通常，我们执行异步的方法是通过回调函数，如：
function f1(){
setTimeout(function () {
//doSomething
setTimeout(function () {
//doSomething
setTimeout(function () {
//doSomething
这样书写固然简单，但是问题也来了，金字塔类型的接口不利于代码阅读与维护，如果，代码写成这样，会不会更利于阅读维护呢？
.then(function () {
.then(function () {
.then(function () {
});即将原来的回调金字塔式改写成链式，这样我们就可以很清楚的看清楚每个方法执行的是什么了。
因此CommonJS提出一种Promise规范，目的是为了异步编程提供统一的接口
Jquery中的promise
在jquery1.5版本后，引入了promise对象，实现了基本的promise,如果你在jquery1.5以上版本，可以发现 原来的ajax方法还可以这样用
var jqxhr = $.ajax( &example.php& )
.done(function() {
alert( &success& );
.fail(function() {
alert( &error& );
.always(function() {
alert( &complete& );
将原来嵌入内部的success,error方法变为链式调用，这是因为在1.5版本，ajax方法进行了封装，$.ajax()获得的是一个$.Deferred对象。
因此，我们可以知道Deferred对象可以完成链式异步调用，
因此，我们可以将这样的形式
function wait(resolve){
resolve(a);
wait(function (data) {
alert(data)
}); 改写成
function wait() {
var def = $.Deferred();
//获取deferred对象
def.resolve(1); // 改变Deferred对象的执行状态
，resolve为成功状态 //当收到resolve时，变执行then方法
setTimeout(tasks, 1000);
return def.promise();
$.when(wait())
.then(function (data) {
alert(data);
该值有resolve(1) 中的1得来
有时候，我们需要不止一部，可能需要多个步骤，那么只需要 在前一个then的回调中签返回值就可，从这里我们能够看出 .then()方法返回的也是一个deferred.promise对象
$.when(wait())
.then(function (data) {
alert(data);
return data+1;
.then(function (data) {
alert(data);
angular中的promise
同上，在angular中，我们也支持promise异步方法，他使用了一个内置对象$q
具体使用代码如下：
&span style=&white-space:pre&& &/span&var getData = function () {
var defer = $q.defer();
//同jquery $.Deferred
$timeout(function () {
defer.resolve(1);
//改变成功状态
return defer.
.then(function (data) {
//getData执行完成后
alert(data);
return data+1;
.then(function (data) {
alert(data);
});注意，angular还有一个when方法，他和jquery中的$.when()还是有一些区别的，如下
&span style=&font-family:Microsoft YaH&&var def = $q.defer();
var q=$q.when(12);
q.then(function (data) {
alert(data); //12
});&/span&angular 中$q.when()方法是将里面的参数封装成一个$q.defer().promise对象，因此 可以通过then方法获取when里面的值
而Jquery中，$.when()接收的是一个deferred对象，不满足promise/A规范。
其实在promise/A规范中还有很多关于promise的定义，如all()&、spread()&、race()&、denodeify()&，如果想了解
promise 的更多功能，我建议诸位看看 Bluebird 函数库的&。本文只记录了最简单的形式，如果有什么问题，望指正，谢谢。
本文已收录于以下专栏：
相关文章推荐
以下是已经添加RSA之后的git操作
关于push和clone：
想要把文件夹pro1里面的内容全部push到git上去，过程如下：
1.在pro1文件夹内打开git bash
2.git in...
现在还不透彻，日后补上
了解Promise
在谈论Promise之前我们要了解一下一些额外的知识；我们知道JavaScript语言的执行环境是“单线程”，所谓单线程，就是一次只能够执行一个任务，如果有多个任务的话就要排...
每周荐书：Java Web、Python极客编程、移动Web前端（评论送书） 各位抱歉，上周活动停更一周，本周继续感谢大家对每周荐书栏目的支持，先公布下上期活动中奖名单 微雨燕凝霜寒森林之舟架构探险：...
既然是用来处理异步编程的，那么在浏览器端的JS里，主要是2种: setTimeout 和 Ajax 请求.
promise 的使用就很像Ajax请求的成功和失败回调。
此承诺/延迟(promise...
$q.all是用于执行多个异步任务进行回调，它可以接受一个promise的数组，或是promise的hash(object)。任何一个promise失败，都会导致整个任务的失败。
例1：接受一个pr...
var deferred = $q.defer();\\生成deferred异步对象
deferred.resolve(rtns);\\执行到这里时，改变deferred状态为执行成功，返回rtns为...
鼠标 / 键盘属性
返回当事件被触发时，&ALT& 是否...
指令，很重要
AngularJS与JQuery最大的区别在哪里？我认为，表现在数据双向绑定，实质就是DOM的操作形式不一样。
JQuery通过选择器找到DOM元素，再赋予元素的行为；
...
MVC模式（三层架构模式）
（Model-View-Controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Control...
他的最新文章
讲师：刘文志
讲师：陈伟
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)AngularJs $q 使用总结 &
AngularJs $q 使用总结
AngularJs $q 使用总结
$q主要的用途就是用看似同步的代码实现异步的功能,$q可以帮助你解决更种回调,且看起来逻辑很清晰.研究了好久,终于明白基本用法.
var ObjectDefferred = $q.defer() 返回一个deferred对象,一般情况下都基于deferred对象进行操作
$q.reject(...)
会创建一个promiss并且被解析成reject,用于链式操作的情景中
$q.when(value, [successCallback], [errorCallback], [progressCallback])
Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted. 这里包裹一个变量value,这个变量可以是promise可以是常量,任何类型都可以:如果是常量(非promiss)变量,相当于直接执行resolve操作,并且把这个变量传入success call back中; 如果是promise, 会调用相应的call back.
$q.resolve(value, [successCallback], [errorCallback], [progressCallback]); 返回一个resolve的promiss,一般用于链式操作.
$q.all(promises); 这里的promises是array类型,所有的promiss满足之后才会执行后续的操作(then),一般用于链式操作中.
deferred对象接口:
deferred对象的生成方式是调用 $q.defer()接口.deferred对象有如下的api:
resolve(value)
成功执行该任务,并且返回一个value对象
reject(reason)
失败执行该任务,并且返回一个value对象
notify(value)
通知该任务的执行进度,并且将相应的value对象返回
建立一个promise关联这个deferred对象
promiss对象接口:
promise对象是deferred对象的一个属性,直接调用ObjectDefferred.promise就可以获取到
then(successCallback, errorCallback, notifyCallback) – regardless of when the promise was or will be resolved or rejected,then calls one of the success or error callbacks asynchronously as soon as the result is available. The callbacks are called with a single argument: the result or rejection reason. Additionally, the notify callback may be called zero or more times to provide a progress indication, before the promise is resolved or rejected.This method returns a new promise which is resolved or rejected via the return value of the successCallback, errorCallback(unless that value is a promise, in which case it is resolved with the value which is resolved in that promise using ). It also notifies via the return value of the notifyCallback method. The promise cannot be resolved or rejected from the notifyCallback method.
catch(errorCallback) – shorthand for promise.then(null, errorCallback)
finally(callback, notifyCallback) – allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value. This is useful to release resources or do some clean-up that needs to be done whether the promise was rejected or resolved. See the
for more information.
var deferred = $q.defer();
deferred.resolve(1);
var promiseA = deferred.
.then(function(val){$(val);return ++})
.then(function(val){$(val);return ++})
function(val){$(val);return ++},
function(val){$(val)}
<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f
var deferred = $q.defer();&&&&deferred.resolve(1);var promiseA = deferred.promise;promiseA&& .then(function(val){$log.info(val);return ++val;})&& .then(function(val){$log.info(val);return ++val;})&& .then(&&&&&&&& function(val){$log.info(val);return ++val;},&&&&&&&& function(val){$log.info(val)}&& );
链式调用完成后控制台打印出 1,2,3
var deferred = $q.defer();
deferred.resolve(1);
var promiseA = deferred.
.then(function(val){$(val);return $q.reject(15);})
.then(function(val){$(val);return ++})
.then(function(val){$(val);return ++})
.then(function(val){$(val);return ++})
function(val){$(val);return ++},
function(val){$(val)}
<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f
var deferred = $q.defer();&&&&deferred.resolve(1);var promiseA = deferred.promise;promiseA&& .then(function(val){$log.info(val);return $q.reject(15);})&& .then(function(val){$log.info(val);return ++val;})&& .then(function(val){$log.info(val);return ++val;})&& .then(function(val){$log.info(val);return ++val;})&& .then(&&&&&&&& function(val){$log.info(val);return ++val;},&&&&&&&& function(val){$log.info(val)}&& );
链式调用完成后控制台打印出 1,15,可以看出，第一个return $q.reject(15)之后，直到最后一个then()才有错误回调函数，所以异常一直传递到最后，中间的几个then()没有错误回调函数。
$q.when('I Love you!')
.then(function(value){$(value)});
<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f
$q.when('I Love you!')&&&&.then(function(value){$log.info(value)});
控制台打印出I Love you!; 前面已经说过了when里面value如果是常量,会直接返回success callback
$q.when($q.reject('I Hate you!'))
.then(null,function(value){$(value)});
$q.when($q.reject('I Hate you!'))&&&&.then(null,function(value){$log.info(value)});
控制台打印出I Hate you!; $q.reject会生成一个reject的promise
var promiseA = $q.when('I Love you!');
var promiseB = $q.when('Love story!');
var promiseC = $q.when("Let't get wet!");
$q.all([promiseA,promiseB,promiseC]).then(function(value){
value[0].then(function(value){$(value);})
value[1].then(function(value){$(value);})
value[2].then(function(value){$(value);})
<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f<div class="crayon-num" data-line="crayon-59f03f<div class="crayon-num crayon-striped-num" data-line="crayon-59f03f
var promiseA = $q.when('I Love you!'); var promiseB = $q.when('Love story!'); var promiseC = $q.when("Let't get wet!"); $q.all([promiseA,promiseB,promiseC]).then(function(value){&&&&value[0].then(function(value){$log.info(value);})&&&&value[1].then(function(value){$log.info(value);})&&&&value[2].then(function(value){$log.info(value);}) })
控制台打印出I Love you!，Love story!，"Let't get wet!
在线演示的一个例子: http://jsfiddle.net/jeremylikness/Q2jMG/
$q无非就是一个采用then方式异步回调,关键在于对promise和defer()对象的理解先说说什么是Promise，什么是$q吧。Promise是一种异步处理模式，有很多的实现方式，比如著名的Kris Kwal's Q还有JQuery的Deffered。
什么是Promise
以前了解过Ajax的都能体会到回调的痛苦，同步的代码很容易调试，但是异步回调的代码，会让开发者陷入泥潭，无法跟踪，比如：
funA(arg1,arg2,function(){
funcB(arg1,arg2,function(){
funcC(arg1,arg2,function(){
本身嵌套就已经很不容易理解了，加上不知何时才触发回调，这就相当于雪上加霜了。
但是有了Promise这种规范，它能帮助开发者用同步的方式，编写异步的代码，比如在AngularJS中可以使用这种方式：
deferABC.resolve(xxx)
.then(funcSuccess(){},funcError(){},funcNotify(){});
当resolve内的对象成功执行，就会触发funcSuccess，如果失败就会触发funcError。有点类似
deferABC.resolve(function(){
Sunccess:funcSuccess,
error:funcError,
notify:funcNotify
再说的直白点，Promise就是一种对执行结果不确定的一种预先定义，如果成功，就xxxx；如果失败，就xxxx，就像事先给出了一些承诺。
比如，小白在上学时很懒，平时总让舍友带饭，并且事先跟他说好了，如果有韭菜鸡蛋就买这个菜，否则就买西红柿炒鸡蛋；无论买到买不到都要记得带包烟。
小白让舍友带饭()
.then(韭菜鸡蛋，西红柿炒鸡蛋)
.finally(带包烟)
q服务是AngularJS中自己封装实现的一种Promise实现，相对与Kris Kwal's Q要轻量级的多。先介绍一下$q常用的几个方法：
defer() 创建一个deferred对象，这个对象可以执行几个常用的方法，比如resolve,reject,notify等
all() 传入Promise的数组，批量执行，返回一个promise对象
when() 传入一个不确定的参数，如果符合Promise标准，就返回一个promise对象。
在Promise中，定义了三种状态：等待状态，完成状态，拒绝状态。
关于状态有几个规定：
1 状态的变更是不可逆的
2 等待状态可以变成完成或者拒绝
defer()方法
在$q中，可以使用resolve方法，变成完成状态；使用reject方法，变成拒绝状态。
下面看看&$q的简单使用：
&html ng-app="myApp"&
&meta http-equiv="Content-Type" content="text/ charset=utf-8" /&
&script src="/libs/angular.js/1.2.16/angular.min.js"&&/script&
&div ng-controller="myctrl"&
&script type="text/javascript"&
var myAppModule = angular.module("myApp",[]);
myAppModule.controller("myctrl",["$scope","$q",function($scope, $ q ){
$scope.test = 1;//这个只是用来测试angularjs是否正常的，没其他的作用
var defer1 = $q.defer();
var promise1 = defer1.
.then(function(value){
console.log("in promise1 ---- success");
console.log(value);
},function(value){
console.log("in promise1 ---- error");
console.log(value);
},function(value){
console.log("in promise1 ---- notify");
console.log(value);
.catch(function(e){
console.log("in promise1 ---- catch");
console.log(e);
.finally(function(value){
console.log('in promise1 ---- finally');
console.log(value);
defer1.resolve("hello");
// defer1.reject("sorry,reject");
其中defer()用于创建一个deferred对象，defer.promise用于返回一个promise对象，来定义then方法。then中有三个参数，分别是成功回调、失败回调、状态变更回调。
其中resolve中传入的变量或者函数返回结果，会当作第一个then方法的参数。then方法会返回一个promise对象，因此可以写成
.then(a,b,c)
.then(a,b,c)
.then(a,b,c)
.finally()
继续说说上面那段代码，then...catch...finally可以想想成java里面的try...catch...finally。
这个all()方法，可以把多个primise的数组合并成一个。当所有的promise执行成功后，会执行后面的回调。回调中的参数，是每个promise执行的结果。当批量的执行某些方法时，就可以使用这个方法。
var funcA = function(){
console.log("funcA");
return "hello,funA";
var funcB = function(){
console.log("funcB");
return "hello,funB";
$q.all([funcA(),funcB()])
.then(function(result){
console.log(result);
执行的结果：
Array [ "hello,funA", "hello,funB" ]
when()方法
when方法中可以传入一个参数，这个参数可能是一个值，可能是一个符合promise标准的外部对象。
var funcA = function(){
console.log("funcA");
return "hello,funA";
$q.when(funcA())
.then(function(result){
console.log(result);
当传入的参数不确定时，可以使用这个方法。
hello,funA
阅读(...) 评论()