JS的promise和extJS的promise的使用

平常我们写ajax是通过

Ext.Ajax.request({
    url: 'remove',  //请求的服务url
    method: 'POST',
    params: {
        num: num    //参数
    },
    success: function (response, opts) {
       //成功要做的事
    }
});

而promise对象，不收外界影响，代表异步操作

Pending（进行中）、Resolved（已完成，又称 Fulfilled）和 Rejected（已失败）

只有请求的结果，可以决定是上面三种状态，是哪一种。

主要作用：将异步操作，同步化。但是效率会高很多。

var promise = new Promise(function(resolve, reject) {
 if (/* 异步操作成功 */){
 resolve(value);
 } else {
 reject(error);
 }
});

promise.then(function(value) {
 // success
}, function(value) {
 // failure
});

Ext.Ajax.request({
    url: 'remove',  //请求的服务url
    method: 'POST',
    params: {
        num: num    //参数
    },
    
}).then(function(response,opts){}).otherwise(function(){}).always(function(){});

ExtJS的promise的实现方式

function getAjax (url) {
     // The function passed to Ext.Promise() is called immediately to start
     // the asynchronous action.
     //
     return new Ext.Promise(function (resolve, reject) {
         Ext.Ajax({
             url: url,

             success: function (response) {
                 // Use the provided "resolve" method to deliver the result.
                 //
                 resolve(response.responseText);
             },

             failure: function (response) {
                 // Use the provided "reject" method to deliver error message.
                 //
                 reject(response.status);
             }
         });
     });
 }

 getAjax('http://stuff').then(function (content) {
     // content is responseText of ajax response
 });
在写Ext.promise的时候

 reject: function (reason) {
            var deferred = new Ext.promise.Deferred();

            deferred.reject(reason);

            return deferred.promise;
        },

 
 

  
  
  
  
 resolve: function (value) {
            var deferred = new Ext.promise.Deferred();

            deferred.resolve(value);

            return deferred.promise;
        }
  
  
 constructor: function (action) {
        var deferred = new Ext.promise.Deferred();

        action(deferred.resolve.bind(deferred), deferred.reject.bind(deferred));

        return deferred.promise;
    }
  
  

 
 
那么什么是Deferred

这是一个延迟机制。在异步操作的函数体中使用，当操作成功，递延应该得到解决;如果操作失败，递延应予以驳回。

每个递延都有一个相关的promise。一个promise代表调用其递延当时的方法。

我们通过deferred.resolve() 就相当于直接执行，并返回成功。不会在执行then()里面的方法了。

相应的deferred.reject() 也是同样的原理

我在项目中使用：

先声明这个方法。
  getByCode: function (code, async) {
        var response = Ext.Ajax.request({
            url: this.baseUrl + "loadByCode.hd",
            method: 'GET',
            async: async,
            params: {
                code: code
            }
        });
        return Ext.decode(response.responseText, true);
    },
当然如果是promise必须是异步的，async:true

随后直接调用getByCode这个方法：

  FaEmpService.getByCode(value, true).then(function (response, opts) { //用异步方法调用，并增加遮罩
                var data = Ext.decode(response.responseText, true);
                if (Ext.isEmpty(data)) {
                   
                } else {
                   
                }
            }).done();
这里就是 成功之后执行then里面的方法。

为什么加.done()呢。因为这样如果出现异常 控制台是会报错的。