


Explication détaillée de la façon d'utiliser la fonction jQuery.delegate()
La fonction
delegate()
est utilisée pour lier la fonction de traitement d'événements à un ou plusieurs événements de l'élément spécifié.
De plus, vous pouvez également transmettre certaines données supplémentaires requises à la fonction de gestionnaire d'événements.
Même s'il s'agit d'un élément nouvellement ajouté après l'exécution de la fonction délégué(), tant qu'il remplit les conditions, la fonction de gestion des événements liés est toujours valide pour lui.
De plus, cette fonction peut lier plusieurs gestionnaires d'événements au même élément et au même type d'événement. Lorsqu'un événement est déclenché, jQuery exécutera les fonctions de traitement des événements liés dans l'ordre de liaison.
Pour supprimer un événement lié via délégué(), utilisez la fonction unelegate().
À partir de jQuery 1.7, veuillez utiliser la fonction event on() au lieu de cette fonction.
Cette fonction appartient à l'objet (instance) jQuery.
Syntaxe
jQuery 1.4.2 Ajout de cette fonction. Il a principalement les deux formes d'utilisation suivantes :
Utilisation un :
jQueryObject.delegate( selector , events [, data ], handler )
Utilisation deux : jQuery 1.4.3 Ajout de la prise en charge de cette utilisation.
jQueryObject.delegate( selector, eventsMap )
Paramètres
Paramètre | Description | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
sélecteur |
| ||||||||||||
events | <🎜>Type de chaîne un ou plusieurs types d'événements séparés par des espaces et facultatif Espace de noms<🎜>, tel que "clic", "clic focus", "keydown.myPlugin". <🎜> | ||||||||||||
données | <🎜>Facultatif/Tout type de données qui doivent être transmises à la fonction de traitement d'événements via event.data lors du déclenchement un événement. <🎜> | ||||||||||||
handler | <🎜>La fonction de gestionnaire d'événements spécifiée par le type Functidelegate. <🎜> | ||||||||||||
eventsMap | <🎜>Objet de type un Object object<🎜>, chacun de ses attributs correspond au type d'événement et à l'espace de noms facultatif (événements de paramètre), et la valeur de l'attribut correspond à la fonction de traitement d'événement liée (gestionnaire de paramètres). <🎜> |
关于参数events中可选的命名空间,请参考最下面的示例代码。
关于参数selector,你可以简单地理解为:如果该参数等于null或被省略,则为当前匹配元素绑定事件;否则就是为当前匹配元素的后代元素中符合selector选择器的元素绑定事件。
参数handler中的this指向当前匹配元素的后代元素中触发该事件的DOM元素。如果参数selector等于null或被省略,则this指向当前匹配元素(也就是该元素)。
delegate()还会为handler传入一个参数:表示当前事件的Event对象。
参数handler的返回值与DOM原生事件的处理函数返回值作用一致。例如"submit"(表单提交)事件的事件处理函数返回false,可以阻止表单的提交。
如果事件处理函数handler仅仅只用于返回false值,可以直接将handler设为false。
返回值
delegate()
函数的返回值为jQuery类型,返回当前jQuery对象本身。
重要说明:delegate()
函数并不是为当前jQuery对象匹配的元素绑定事件处理函数,而是为它们的后代元素中符合选择器selector参数的元素绑定事件处理函数。delegate()函数并不是直接为这些后代元素挨个绑定事件,而是"委托"给当前jQuery对象的匹配元素来处理。由于DOM 2级的事件流机制,当后代元素selector触发事件时,该事件会在事件冒泡中传递给其所有的祖辈元素,当事件流传递到当前匹配元素时,jQuery会判断是哪个后代元素触发了事件,如果该元素符合选择器selector,jQuery就会捕获该事件,从而执行绑定的事件处理函数。
示例&说明
以点击事件("click")为例,以下是jQuery中事件函数的常规用法(某些函数也存在其它形式的用法,此处暂不列出):
// 这里的选择器selector用于指定可以触发事件的元素 // 这里的选择器ancestor应是selector的祖辈元素,selector触发的事件可以被其祖辈元素在事件流中捕获,从而以"代理"的形式触发事件。 // jQuery 1.0+ (1.4.3+支持参数data) $("selector").click( [ data ,] handler ); // jQuery 1.0+ (1.4.3+支持参数data) $("selector").bind( "click" [, data ], handler ); // jQuery 1.3+ (1.4+支持参数data) $("selector").live( "click" [, data ], handler ); // jQuery 1.4.2+ $("ancestor").delegate( "selector", "click" [, data ], handler ); // jQuery 1.7+ $("ancestor").on( "click", "selector" [, data ], handler );
请参考下面这段初始HTML代码:
<p id="n1"> <p id="n2"><span>CodePlayer</span></p> <p id="n3"><span>专注于编程开发技术分享</span></p> <em id="n4">http://www.365mini.com</em> </p> <p id="n5">Google</p>
我们为
中的所有
元素绑定点击事件:
// 为p中的所有p元素绑定click事件处理程序 // 只有n2、n3可以触发该事件 $("p").delegate("p", "click", function(){ // 这里的this指向触发点击事件的p元素(Element) alert( $(this).text() ); });
运行代码(其他代码请自行复制到演示页面运行)
如果要绑定所有的
元素,你可以编写如下jQuery代码:
//为所有p元素绑定click事件处理程序(body内的所有p元素,就包含所有的p元素) //n2、n3、n5均可触发该事件 $("body").delegate("p", "click", function(event){ // 这里的this指向触发点击事件的p元素(Element) alert( $(this).text() ); });
此外,我们还可以同时绑定多个事件,并为事件处理函数传递一些附加的数据,我们可以通过jQuery为事件处理函数传入的参数event
(Event事件对象)来进行处理:
var data = { id: 5, name: "李四" }; //为n5绑定mouseenter mouseleave两个事件,并为其传入附加数据data //附加数据可以是任意类型 $("body").delegate("#n5", "mouseenter mouseleave", data, function(event){ var $me = $(this); var options = event.data; // 这就是传入的附加数据 if( event.type == "mouseenter"){ $me.html( "你好," + options.name + "!"); }else if(event.type == "mouseleave" ){ $me.html( "再见," + options.name + "!"); } } );
此外,即使符合条件的元素是delegate()
函数执行后新添加,绑定事件对其依然有效。同样以初始HTML代码为例,我们可以编写如下jQuery代码:
//为p中的所有p元素绑定click事件处理程序 //只有n2、n3可以触发该事件 $("p").delegate("p", "click", function(event){ alert( $(this).text() ); }); //后添加的n6也可以触发上述click事件,因为它也是p中的p元素 $("#n1").append('<p id="n6">上述绑定的click事件对此元素也生效!</p>');
参数events
还支持为事件类型附加额外的命名空间。当为同一元素绑定多个相同类型的事件处理函数时。使用命名空间,可以在触发事件、移除事件时限定触发或移除的范围。
function clickHandler(event){ alert( "触发时的命名空间:[" + event.namespace + "]"); } var $p = $("p"); // A:为所有p元素绑定click事件,定义在foo和bar两个命名空间下 $("body").delegate( "p", "click.foo.bar", clickHandler ); // B:为所有p元素绑定click事件,定义在test命名空间下 $("body").delegate( "p", "click.test", clickHandler ); var $n2 = $("#n2"); // 触发所有click事件 $n2.trigger("click"); // 触发A和B (event.namespace = "") // 触发定义在foo命名空间下的click事件 $n2.trigger("click.foo"); // 触发A (event.namespace = "foo") // 触发定义在bar命名空间下的click事件 $n2.trigger("click.bar"); // 触发A (event.namespace = "bar") // 触发同时定义在foo和bar两个命名空间下的click事件 $n2.trigger("click.foo.bar"); // 触发A (event.namespace = "bar.foo") // 触发定义在test命名空间下的click事件 $n2.trigger("click.test"); // 触发B (event.namespace = "test") // 移除所有p元素定义在foo命名空间下的click事件处理函数 $p.undelegate( "click.foo" ); // 移除A
delegate()函数的参数eventsMap
是一个对象,可以"属性-值"的方式指定多个"事件类型-处理函数"。对应的示例代码如下:
var events = { "mouseenter": function(event){ $(this).html( "你好!"); }, "mouseleave": function(event){ $(this).html( "再见!"); } }; //为n5绑定mouseenter mouseleave两个事件,并为其传入附加数据data $("body").delegate("#n5", events);
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!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Le langage Go propose deux technologies de création de fonctions dynamiques : la fermeture et la réflexion. les fermetures permettent d'accéder aux variables dans la portée de la fermeture, et la réflexion peut créer de nouvelles fonctions à l'aide de la fonction FuncOf. Ces technologies sont utiles pour personnaliser les routeurs HTTP, mettre en œuvre des systèmes hautement personnalisables et créer des composants enfichables.

Dans la dénomination des fonctions C++, il est crucial de prendre en compte l’ordre des paramètres pour améliorer la lisibilité, réduire les erreurs et faciliter la refactorisation. Les conventions courantes d'ordre des paramètres incluent : action-objet, objet-action, signification sémantique et conformité de la bibliothèque standard. L'ordre optimal dépend de l'objectif de la fonction, des types de paramètres, de la confusion potentielle et des conventions du langage.

La clé pour écrire des fonctions Java efficaces et maintenables est la suivante : restez simple. Utilisez un nom significatif. Gérer des situations particulières. Utilisez une visibilité appropriée.

1. La fonction SOMME permet de sommer les nombres d'une colonne ou d'un groupe de cellules, par exemple : =SOMME(A1:J10). 2. La fonction MOYENNE permet de calculer la moyenne des nombres dans une colonne ou un groupe de cellules, par exemple : =AVERAGE(A1:A10). 3. Fonction COUNT, utilisée pour compter le nombre de nombres ou de texte dans une colonne ou un groupe de cellules, par exemple : =COUNT(A1:A10) 4. Fonction IF, utilisée pour effectuer des jugements logiques basés sur des conditions spécifiées et renvoyer le résultat correspondant.

Les avantages des paramètres par défaut dans les fonctions C++ incluent la simplification des appels, l’amélioration de la lisibilité et l’évitement des erreurs. Les inconvénients sont une flexibilité limitée et des restrictions de dénomination. Les avantages des paramètres variadiques incluent une flexibilité illimitée et une liaison dynamique. Les inconvénients incluent une plus grande complexité, des conversions de types implicites et des difficultés de débogage.

Les avantages des fonctions renvoyant des types référence en C++ incluent : Améliorations des performances : le passage par référence évite la copie d'objets, économisant ainsi de la mémoire et du temps. Modification directe : L'appelant peut modifier directement l'objet de référence renvoyé sans le réaffecter. Simplicité du code : le passage par référence simplifie le code et ne nécessite aucune opération d'affectation supplémentaire.

La gestion des exceptions en C++ peut être améliorée grâce à des classes d'exceptions personnalisées qui fournissent des messages d'erreur spécifiques, des informations contextuelles et effectuent des actions personnalisées en fonction du type d'erreur. Définissez une classe d'exception héritée de std::exception pour fournir des informations d'erreur spécifiques. Utilisez le mot-clé throw pour lancer une exception personnalisée. Utilisez Dynamic_cast dans un bloc try-catch pour convertir l'exception interceptée en un type d'exception personnalisé. Dans le cas réel, la fonction open_file lève une exception FileNotFoundException. La capture et la gestion de l'exception peuvent fournir un message d'erreur plus spécifique.

La différence entre les fonctions PHP personnalisées et les fonctions prédéfinies est la suivante : Portée : les fonctions personnalisées sont limitées à la portée de leur définition, tandis que les fonctions prédéfinies sont accessibles tout au long du script. Comment définir : les fonctions personnalisées sont définies à l'aide du mot-clé function, tandis que les fonctions prédéfinies sont définies par le noyau PHP. Passage de paramètres : les fonctions personnalisées reçoivent des paramètres, tandis que les fonctions prédéfinies peuvent ne pas nécessiter de paramètres. Extensibilité : des fonctions personnalisées peuvent être créées selon les besoins, tandis que les fonctions prédéfinies sont intégrées et ne peuvent pas être modifiées.
