Quel est l'objet différé dans jquery ?

La signification d'un objet différé est de "retarder" l'exécution jusqu'à un certain point dans le futur. Il s'agit de la solution de fonction de rappel de jQuery, elle résout le problème de la gestion des opérations fastidieuses et offre un meilleur contrôle. ces opérations et une interface de programmation unifiée.

Recommandations associées : "Tutoriel jQuery"

1. Qu'est-ce qu'un objet différé ?

Dans le processus de développement d'un site internet, on rencontre souvent certaines opérations javascript qui prennent beaucoup de temps. Parmi elles, il existe à la fois des opérations asynchrones (telles que la lecture ajax des données du serveur) et des opérations synchrones (telles que la traversée d'un grand tableau), et les résultats ne sont pas disponibles immédiatement.

L'approche habituelle consiste à leur spécifier des fonctions de rappel. Autrement dit, spécifiez à l'avance quelles fonctions doivent être appelées une fois leur exécution terminée.

Cependant, jQuery est très faible en termes de fonctions de rappel. Afin de changer cela, l'équipe de développement jQuery a conçu l'objet différé.

Pour faire simple, l'objet différé est la solution de fonction de rappel de jQuery. En anglais, defer signifie « retard », donc la signification d'un objet différé est de « retarder » l'exécution jusqu'à un certain point dans le futur.

Il résout le problème de la gestion des opérations fastidieuses, offre un meilleur contrôle sur ces opérations et une interface de programmation unifiée. Ses principales fonctions peuvent être résumées en quatre points. Ci-dessous, nous apprendrons étape par étape à travers un exemple de code.

2. Écriture en chaîne de l'opération ajax

Tout d'abord, passons en revue l'écriture traditionnelle de l'opération ajax de jQuery :

　　$.ajax({
　　　　url: "test.html",
　　　　success: function(){　　　　　　alert("哈哈，成功了！");　　　　},
　　　　error:function(){　　　　　　alert("出错啦！");　　　　}
　　});

Dans le code ci-dessus, $.ajax() accepte un paramètre d'objet. Cet objet contient deux méthodes : la méthode success spécifie la fonction de rappel une fois l'opération réussie et la méthode d'erreur spécifie la fonction de rappel après l'échec de l'opération.

Une fois l'opération $.ajax() terminée, si vous utilisez une version de jQuery inférieure à 1.5.0, l'objet XHR sera renvoyé et vous ne pourrez pas effectuer d'opérations en chaîne s'il est supérieur ; version 1.5.0, ce qui est renvoyé est un objet différé, qui peut être chaîné.

Maintenant, la nouvelle méthode d'écriture est comme ceci :

　　$.ajax("test.html")
　　.done(function(){ alert("哈哈，成功了！"); })
　　.fail(function(){ alert("出错啦！"); });

Comme vous pouvez le voir, done() est équivalente à la méthode success, et fail() est équivalente à la méthode error. Après avoir adopté la méthode d'écriture en chaîne, la lisibilité du code est grandement améliorée.

3. Spécifiez plusieurs fonctions de rappel pour la même opération

L'un des grands avantages de l'objet différé est qu'il vous permet de librement ajouter plusieurs fonctions de rappel.

En prenant le code ci-dessus comme exemple, si une fois l'opération ajax réussie, en plus de la fonction de rappel d'origine, je souhaite exécuter une autre fonction de rappel, que dois-je faire ?

C'est très simple, il suffit de l'ajouter à la fin.

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

Vous pouvez ajouter autant de fonctions de rappel que vous le souhaitez, et elles seront exécutées dans l'ordre dans lequel elles sont ajoutées.

4. Spécifier des fonctions de rappel pour plusieurs opérations

Un autre grand avantage de l'objet différé est qu'il vous permet de spécifier des fonctions de rappel pour plusieurs opérations. events. Une fonction de rappel, qui ne peut pas être effectuée en écriture traditionnelle.

Veuillez regarder le code suivant, qui utilise une nouvelle méthode $.when() :

　　$.when($.ajax("test1.html"), $.ajax("test2.html"))
　　.done(function(){ alert("哈哈，成功了！"); })
　　.fail(function(){ alert("出错啦！"); });

La signification de ce code est d'effectuer d'abord deux opérations $.ajax("test1 .html ") et $.ajax("test2.html"), si les deux réussissent, la fonction de rappel spécifiée par done() sera exécutée ; si l'une d'elles échoue ou si les deux échouent, la fonction de rappel spécifiée par fail() sera exécutée.

5. Interface de fonction de rappel pour les opérations courantes (Partie 1)

Le plus grand avantage de l'objet différé est qu'il combine cet ensemble de Interfaces de fonction de rappel, étendues des opérations ajax à toutes les opérations. En d'autres termes, toute opération - qu'il s'agisse d'une opération ajax ou d'une opération locale, qu'il s'agisse d'une opération asynchrone ou synchrone - peut utiliser diverses méthodes de l'objet différé pour spécifier une fonction de rappel.

Regardons un exemple spécifique. Supposons qu'il y ait une attente d'opération qui prend du temps :

　　var wait = function(){
　　　　var tasks = function(){
　　　　　　alert("执行完毕！");
　　　　};
　　　　setTimeout(tasks,5000);
　　};

Nous spécifions une fonction de rappel pour cela, que devons-nous faire ?

Naturellement, vous penserez que vous pouvez utiliser $.when() :

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

Cependant, si vous l'écrivez ainsi, la méthode done() sera exécutée immédiatement et ne fonctionnera pas comme fonction de rappel. La raison en est que les paramètres de $.when() ne peuvent être que des objets différés, donc wait() doit être réécrit :

　　var dtd = $.Deferred(); // 新建一个deferred对象
　　var wait = function(dtd){
　　　　var tasks = function(){
　　　　　　alert("执行完毕！");
　　　　　　dtd.resolve(); // 改变deferred对象的执行状态
　　　　};
　　　　setTimeout(tasks,5000);
　　　　return dtd;
　　};

Maintenant, la fonction wait() renvoie un objet différé, qui peut être chaîné. .

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

Une fois la fonction wait() exécutée, la fonction de rappel spécifiée par la méthode done() sera automatiquement exécutée.

6. Méthode deferred.resolve() et méthode deferred.reject()

Si vous regardez attentivement, vous trouverez l'attente ci-dessus Il y a un autre endroit dans la fonction () que je n'ai pas expliqué. C'est ce que fait dtd.resolve() ?

要说清楚这个问题，就要引入一个新概念"执行状态"。jQuery规定，deferred对象有三种执行状态----未完成，已完成和已失败。如果执行状态是"已完成"（resolved）,deferred对象立刻调用done()方法指定的回调函数；如果执行状态是"已失败"，调用fail()方法指定的回调函数；如果执行状态是"未完成"，则继续等待，或者调用progress()方法指定的回调函数（jQuery1.7版本添加）。

前面部分的ajax操作时，deferred对象会根据返回结果，自动改变自身的执行状态；但是，在wait()函数中，这个执行状态必须由程序员手动指定。dtd.resolve()的意思是，将dtd对象的执行状态从"未完成"改为"已完成"，从而触发done()方法。

类似的，还存在一个deferred.reject()方法，作用是将dtd对象的执行状态从"未完成"改为"已失败"，从而触发fail()方法。

　　var dtd = $.Deferred(); // 新建一个Deferred对象
　　var wait = function(dtd){
　　　　var tasks = function(){
　　　　　　alert("执行完毕！");
　　　　　　dtd.reject(); // 改变Deferred对象的执行状态
　　　　};
　　　　setTimeout(tasks,5000);
　　　　return dtd;
　　};
　　$.when(wait(dtd))
　　.done(function(){ alert("哈哈，成功了！"); })
　　.fail(function(){ alert("出错啦！"); });

七、deferred.promise()方法

上面这种写法，还是有问题。那就是dtd是一个全局对象，所以它的执行状态可以从外部改变。

请看下面的代码：

　　var dtd = $.Deferred(); // 新建一个Deferred对象
　　var wait = function(dtd){
　　　　var tasks = function(){
　　　　　　alert("执行完毕！");
　　　　　　dtd.resolve(); // 改变Deferred对象的执行状态
　　　　};
　　　　setTimeout(tasks,5000);
　　　　return dtd;
　　};
　　$.when(wait(dtd))
　　.done(function(){ alert("哈哈，成功了！"); })
　　.fail(function(){ alert("出错啦！"); });
　　dtd.resolve();

我在代码的尾部加了一行dtd.resolve()，这就改变了dtd对象的执行状态，因此导致done()方法立刻执行，跳出"哈哈，成功了！"的提示框，等5秒之后再跳出"执行完毕！"的提示框。

为了避免这种情况，jQuery提供了deferred.promise()方法。它的作用是，在原来的deferred对象上返回另一个deferred对象，后者只开放与改变执行状态无关的方法（比如done()方法和fail()方法），屏蔽与改变执行状态有关的方法（比如resolve()方法和reject()方法），从而使得执行状态不能被改变。

请看下面的代码：

　　var dtd = $.Deferred(); // 新建一个Deferred对象
　　var wait = function(dtd){
　　　　var tasks = function(){
　　　　　　alert("执行完毕！");
　　　　　　dtd.resolve(); // 改变Deferred对象的执行状态
　　　　};

　　　　setTimeout(tasks,5000);
　　　　return dtd.promise(); // 返回promise对象
　　};
　　var d = wait(dtd); // 新建一个d对象，改为对这个对象进行操作
　　$.when(d)
　　.done(function(){ alert("哈哈，成功了！"); })
　　.fail(function(){ alert("出错啦！"); });
　　d.resolve(); // 此时，这个语句是无效的

在上面的这段代码中，wait()函数返回的是promise对象。然后，我们把回调函数绑定在这个对象上面，而不是原来的deferred对象上面。这样的好处是，无法改变这个对象的执行状态，要想改变执行状态，只能操作原来的deferred对象。

不过，更好的写法是allenm所指出的，将dtd对象变成wait(）函数的内部对象。

　　var wait = function(dtd){
　　　　var dtd = $.Deferred(); //在函数内部，新建一个Deferred对象
　　　　var tasks = function(){
　　　　　　alert("执行完毕！");
　　　　　　dtd.resolve(); // 改变Deferred对象的执行状态
　　　　};

　　　　setTimeout(tasks,5000);
　　　　return dtd.promise(); // 返回promise对象
　　};
　　$.when(wait())
　　.done(function(){ alert("哈哈，成功了！"); })
　　.fail(function(){ alert("出错啦！"); });

八、普通操作的回调函数接口（中）

另一种防止执行状态被外部改变的方法，是使用deferred对象的建构函数$.Deferred()。

这时，wait函数还是保持不变，我们直接把它传入$.Deferred()：

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

jQuery规定，$.Deferred()可以接受一个函数名（注意，是函数名）作为参数，$.Deferred()所生成的deferred对象将作为这个函数的默认参数。

九、普通操作的回调函数接口（下）

除了上面两种方法以外，我们还可以直接在wait对象上部署deferred接口。

　　var dtd = $.Deferred(); // 生成Deferred对象
　　var wait = function(dtd){
　　　　var tasks = function(){
　　　　　　alert("执行完毕！");
　　　　　　dtd.resolve(); // 改变Deferred对象的执行状态
　　　　};
　　　　setTimeout(tasks,5000);
　　};
　　dtd.promise(wait);
　　wait.done(function(){ alert("哈哈，成功了！"); })
　　.fail(function(){ alert("出错啦！"); });
　　wait(dtd);

这里的关键是dtd.promise(wait)这一行，它的作用就是在wait对象上部署Deferred接口。正是因为有了这一行，后面才能直接在wait上面调用done()和fail()。

十、小结：deferred对象的方法

前面已经讲到了deferred对象的多种方法，下面做一个总结：

　　（1） $.Deferred() 生成一个deferred对象。

　　（2） deferred.done() 指定操作成功时的回调函数

　　（3） deferred.fail() 指定操作失败时的回调函数

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

　　（5） deferred.resolve() 手动改变deferred对象的运行状态为"已完成"，从而立即触发done()方法。

　　（6）deferred.reject() 这个方法与deferred.resolve()正好相反，调用后将deferred对象的运行状态变为"已失败"，从而立即触发fail()方法。

　　（7） $.when() 为多个操作指定回调函数。

除了这些方法以外，deferred对象还有二个重要方法，上面的教程中没有涉及到。

　　（8）deferred.then()

有时为了省事，可以把done()和fail()合在一起写，这就是then()方法。

　　$.when($.ajax( "/main.php" ))
　　.then(successFunc, failureFunc );

如果then()有两个参数，那么第一个参数是done()方法的回调函数，第二个参数是fail()方法的回调方法。如果then()只有一个参数，那么等同于done()。

　　（9）deferred.always()

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

　　$.ajax( "test.html" )
　　.always( function() { alert("已执行！");} );

更多编程相关知识，请访问：编程课程！！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!