How to use jQuery's Promise correctly

How much do you know about how to use jQuery’s Promise? This article mainly shares with you how to use jQuery's Promise correctly, hoping to help you.

We previously learned about the Promise object of ES6, let’s take a look at Promise in jQuery, which is jQuery’s Deferred object.

Open the browser console first.

<script>
  var defer = $.Deferred();
  console.log(defer);
</script>

Running results:

looks a bit like the Promise object of ES6, and jQuery’s Deferred object also has resolve , reject, then methods, as well as done, fail, always... methods. jQuery uses this Deferred object to register callback functions for asynchronous operations, modify and transfer the status of asynchronous operations.

Play with Deferred:

<script>
  function runAsync(){
    var defer = $.Deferred();
    //做一些异步操作
    setTimeout(function(){
      console.log(&#39;执行完成&#39;);
      defer.resolve(&#39;异步请求成功之后返回的数据&#39;);
    }, 1000);
    return defer;
  }
  runAsync().then(function(data){
    console.log(data)
  });
</script>

After running, the instance defer of the Deferred object returns the parameter "data returned after the asynchronous request is successful" through the resolve method. Go to the then method to receive and print.

is similar to ES6 Promise, but there is a little difference. Let’s look at Promise again:

##

<script>
  function runAsync(){
    var p = new Promise(function(resolve, reject){
      
      setTimeout(function(){
        console.log(&#39;执行完成&#39;);
        resolve(&#39;异步请求成功之后返回的数据&#39;);
      }, 1000);
    });
    return p;      
  }

  runAsync().then(function(data){
    console.log(data);
  });
</script>

We found:

1. When creating a Deferred object, no parameters were passed; when creating a Promise object, parameters were passed (an anonymous function was passed, and the function also had two parameters: resolve, reject);

2. The Deferred object was called directly resolve method; while the Promise object is the resolve method called internally;

Description: The Deferred object itself has a resolve method, and the Promise object is assigned to the Promise object by executing the resolve method in the constructor. The status of the execution result.

This has a drawback: because the Deferred object has its own resolve method, after getting the Deferred object, you can call the resolve method at any time, and its status can be manually intervened

<script>
  function runAsync(){
    var defer = $.Deferred();
    //做一些异步操作
    setTimeout(function(){
      console.log(&#39;执行完成&#39;);
      defer.resolve(&#39;异步请求成功之后返回的数据&#39;);
    }, 1000);
    return defer;
  }
　　 var der = runAsync();
　 　der.then(function(data){
    console.log(data)
　 　});
 　　der.resolve(&#39;在外部结束&#39;); 
</script>

In this case, the status is set directly to the Deferred externally, printing "end externally", and printing "execution completed" after 1s, and "data returned after the asynchronous request is successful" will not be printed.

Obviously, this is not good. I sent an asynchronous request, but before the data was received, someone ended it for me externally. . . . . . .

Of course jQuery will definitely fill this pit. There is a promise method on the Deferred object, which is a restricted Deferred object

<script>
  function runAsync(){
    var def = $.Deferred();
    //做一些异步操作
    setTimeout(function(){
      console.log(&#39;执行完成&#39;);
      def.resolve(&#39;请求成功之后返回的数据&#39;);
    }, 2000);
    return def.promise(); //就在这里调用
  }
</script>

The so-called restricted The Deferred object is a Deferred object without resolve and reject methods. In this way, the state of the Deferred object cannot be changed outside.

The then method of the Deferred object and done and fail syntax sugar

We know that in the ES6 Promise specification, the then method accepts two parameters, namely execution completion and callback for execution failure, and jquery has been enhanced and can also accept the third parameter, which is the callback in the pending state, as follows:

deferred.then( doneFilter [, failFilter ] [ , progressFilter ] )

then method:

<script>
  function runAsync(){
    var def = $.Deferred();
    //做一些异步操作
    setTimeout(function(){
       var num = Math.ceil(Math.random()*10); //生成1-10的随机数
        if(num<=5){
          def.resolve(num);
        }
        else{
          def.reject(&#39;数字太大了&#39;);
        }
    }, 2000);
    return def.promise(); //就在这里调用
  }

  runAsync().then(function(d){
    console.log("resolve");
    console.log(d);
  },function(d){
    console.log("reject");
    console.log(d);
  })

</script>

The then method of the Deferred object can also perform chain operations.

done, fail syntax sugar, used to specify callbacks for execution completion and execution failure respectively, are equivalent to this code:

##

<script>
  function runAsync(){
    var def = $.Deferred();
    //做一些异步操作
    setTimeout(function(){
       var num = Math.ceil(Math.random()*10); //生成1-10的随机数
        if(num<=5){
          def.resolve(num);
        }
        else{
          def.reject(&#39;数字太大了&#39;);
        }
    }, 2000);
    return def.promise(); //就在这里调用
  }

  runAsync().done(function(d){
    console.log("resolve");
    console.log(d);
  }).fail(function(d){
    console.log("reject");
    console.log(d);
  })

</script>

Usage of always

There is also an always method on the Deferred object of jquery. Regardless of whether the execution is completed or failed, always will be executed, which is somewhat similar to complete in ajax.

#Usage of $.when

In jquery, there is also a $.when method to implement Promise. It has the same function as the all method in ES6 and performs asynchronous operations in parallel. , the callback function is executed only after all asynchronous operations have been executed. However, $.when is not defined in $.Deferred. You can tell by looking at the name, $.when, it is a separate method. It is slightly different from the all parameter of ES6. It does not accept an array, but multiple Deferred objects, as follows:

<script>
 function runAsync(){
    var def = $.Deferred();
    //做一些异步操作
    setTimeout(function(){
       var num = Math.ceil(Math.random()*10); //生成1-10的随机数
       def.resolve(num);  
    }, 2000);
    return def.promise(); //就在这里调用
  }
  $.when(runAsync(), runAsync(), runAsync()) .then(function(data1, data2, data3){
　　　　 console.log(&#39;全部执行完成&#39;);
　　　　 console.log(data1, data2, data3);
　　});
</script>

There is no race in jquery like in ES6 Method? It's the method based on the fastest one. Right, it doesn't exist in jquery.

The above are the common methods of Deferred objects in jquery.

In the previous article and this article, one-time timers were used instead of asynchronous requests for data processing. Why don't you use ajax? It's not because of trouble. Here I want to talk about the connection between ajax and Deferred:

jquery's ajax returns a restricted Deferred object, that is, there is no resolve method and reject method, and it cannot be used from the outside. To change the state, since it is a Deferred object, all the features we mentioned above can also be used with ajax. For example, chain calls, sending multiple requests continuously:

<script>
req1 = function(){
  return $.ajax(/* **** */);
}
req2 = function(){
  return $.ajax(/* **** */);
}
req3 = function(){ 
　　return $.ajax(/* **** */);
}
req1().then(req2).then(req3).done(function(){ console.log(&#39;请求发送完毕&#39;); });
</script>

success, error and complete

These three methods are our Commonly used ajax syntactic sugar.

$.ajax(/*...*/)
.success(function(){/*...*/})
.error(function(){/*...*/})
.complete(function(){/*...*/})

Sometimes I prefer to handle it internally as an attribute.

represents the callbacks of success, failure, and end of the ajax request respectively. What is the relationship between these three methods and Deferred? In fact, it is syntactic sugar, success corresponds to done, error corresponds to fail, and complete corresponds to always. That's it, just to keep the parameter names consistent with ajax.

Summary:

$.Deferred implements the Promise specification, then, done, fail, and always are the methods of the Deferred object. $.when is a global method used to run multiple asynchronous tasks in parallel, which is the same function as ES6's all. ajax returns a restricted Deferred object. Success, error, and complete are syntactic sugars provided by ajax. Their functions are consistent with done, fail, and always of the Deferred object.

Related recommendations:

Detailed explanation of promsie.all and promise sequence execution

Using Promise in JS to implement traffic light example code ( demo)

About the simple usage of promise objects

The above is the detailed content of How to use jQuery's Promise correctly. For more information, please follow other related articles on the PHP Chinese website!