JS异步

• done与fail传参给函数

                var searchDfd = id ?
                    $.when(this.idSearch(id, this.catChosen), this.keySearch(keyword, this.catChosen)) :
                    this.keySearch(keyword, this.catChosen);
                searchDfd
                    .done(this.searchSuccess) //注意匿名函数的用法
                    .fail(this.searchError()); //将参数传给函数执行的返回值


            searchSuccess: function() {


            },

            searchError: function() {
                return function(error) {

                };
            },

原因在于

　　$.ajax("test.html")
　　.done(function(){ alert("哈哈，成功了！");} )
　　.fail(function(){ alert("出错啦！"); } )
　　.done(function(){ alert("第二个回调函数！");} );
promise always

这个方法用来指定回调函数的，它的作用是，不管调用的是deferred.resolve()还是deferred.reject()，最后总是执行。

      $.when(save, del, update).always(function() {
                console.log('clear cache');

                // savedone.resolve();
            });

解决两个异步操作的嵌套返回问题

//错误的使用
    function masterRight(choise) {
        var defer = $.Deferred();
        (function() {
            var defer2 = $.Deferred();
            if (choise) {
                isMaster = "ture";
                defer2.resolve(isMaster);
            } else {
                isMaster = "false";
                defer2.reject(isMaster);
            }
            return defer2.promise();
        })();
        return defer.promise();
    }


    $(window).on('load', function() {
        var outer = masterRight(1).done(function(isMater) {
            console.log(isMaster);
        });
        console.log(outer);
    });

解决方法1

getUserData().done(function() {
                        masterRight().done(function(permission) {
                            isMasterRight(permission).done(function() {
                                if (isMaster === true) {
                                } else {
                                }
                            });
                        }).fail(function(error) {
                            console.log(error);
                        });
                    });
var dfds = [.Deferred()];

解决方法2
deferred.promise() 没有参数时，返回一个新的deferred对象，该对象的运行状态无法被改变；接受参数时，作用为在参数对象上部署deferred接口。

　$.when(wait(dtd))
　　.done(function(){ alert("哈哈，成功了！"); })
　　.fail(function(){ alert("出错啦！"); });
或者

//wait函数还是保持不变，我们直接把它传入$.Deferred()：
　　$.Deferred(wait)
　　.done(function(){ alert("哈哈，成功了！"); })
　　.fail(function(){ alert("出错啦！"); });
或者

//直接在wait对象上部署deferred接口。
dtd.promise(wait);
　　wait.done(function(){ alert("哈哈，成功了！"); })
　　.fail(function(){ alert("出错啦！"); });
　　wait(dtd);

promise的灵活使用，promise always，def=[def1,def2],when,以及出现嵌套时可以的解决方法
解决两个异步操作的嵌套返回问题

//嵌套的使用
    function masterRight(choise) {
        var defer = $.Deferred();
        (function() {
            var defer2 = $.Deferred();
            if (choise) {
                defer2.resolve(isMaster);
            } else {
                defer2.reject(isMaster);
            }
            return defer2.promise();
        })();
        return defer.promise();
    }

替代方法1

getUserData().done(function() {
                        masterRight().done(function(permission) {
                            isMasterRight(permission).done(function() {
                                if (isMaster === true) {
                                    $("#master_promote_tab").css({
                                        "display": "inline-block"
                                    });
                                    self.getMasterPromote().reset();
                                    self.hideLoading();
                                } else {
                                    $("#master_promote_tab").css({
                                        "display": "none"
                                    });
                                }
                            });
                        }).fail(function(error) {
                            console.log(error);
                        });
                    });
var dfds = [$.Deferred(), $.Deferred()];

查看资料后，替代方法2

deferred.promise() 没有参数时，返回一个新的deferred对象，该对象的运行状态无法被改变；接受参数时，作用为在参数对象上部署deferred接口。

　$.when(wait(dtd))
　　.done(function(){})
　　.fail(function(){});

或者

//wait函数还是保持不变，我们直接把它传入$.Deferred()：
　　$.Deferred(wait)
　　.done(function(){})
　　.fail(function(){});

或者

//直接在wait对象上部署deferred接口。
dtd.promise(wait);
　　wait.done(function(){})
　　.fail(function(){});
　　wait(dtd);