Quel est l'intérêt d'utiliser les rappels dans jQuery ?

Les rappels sont une méthode introduite dans jQuery 1.7, qui est utilisée pour gérer un groupe de fonctions de rappel avec les mêmes paramètres de méthode. En plus d'ajouter, de supprimer et d'effacer des rappels tels que des tableaux, Callbacks propose également plusieurs modes spéciaux. Dans différents modes, le cycle de vie et l'ordre d'exécution des fonctions de rappel sont légèrement différents.

Générer une colonne de rappel (Callbacks)

var callbacks = $.Callbacks(flags);

Le paramètre falgs est une chaîne utilisée pour indiquer le mode des rappels. Par exemple, dans le mode "once stopOnFalse", le rappel sera uniquement. être exécuté une fois au plus. Si Si un rappel renvoie false pendant l'exécution, l'exécution de la colonne de rappel sera également interrompue.

Alors, où sont les scénarios d'utilisation de jQuery.Callbacks ?

Dans de nombreux cas, il est nécessaire de contrôler l'exécution séquentielle d'une série de fonctions. Ensuite, généralement, une fonction de file d'attente est nécessaire pour gérer ce problème

Regardons un morceau de code

function Aaron(List, callback) {
    setTimeout(function() {
      var task = List.shift();
      task(); //执行函数
      if (task.length > 0) {  //递归分解
        setTimeout(arguments.callee, 1000)
      } else {
        callback()
      }
    }, 25)
  }
  Aaron([function(){
    alert('a')
  },function(){
    alert('b')
  }],function(){
    alert('callback')
  })
 
分别弹出 ‘a’ , ‘b’ ,’callback’

Transmettez un ensemble de paramètres de fonction, comptons sur une analyse récursive et exécutons-les un par un. En fait, vous pouvez compter sur setTimeout Le principe d'ajouter une fonction à la fin de la file d'attente avant de l'exécuter

***** Mais est-ce gênant de l'écrire comme ça ? *****

Passons à la méthode fournie par jQuery

var callbacks = $.Callbacks();
  callbacks.add(function() {
    alert('a');
  })
  callbacks.add(function() {
    alert('b');
  })
  callbacks.fire(); //输出结果: 'a' 'b'

N'est-ce pas beaucoup plus pratique, et le code est très clair, donc c'est un objet polyvalent L'objet de liste de fonctions de rappel fournit un moyen puissant de gérer la file d'attente des fonctions de rappel.

Il fournit également plusieurs paramètres de traitement pratiques

une fois : assurez-vous que cette liste de rappel n'est exécutée (.fire()) qu'une seule fois (comme un différé différé).

mémoire : conserve la valeur précédente, la dernière valeur ajoutée à la fin de cette liste sera immédiatement exécutée en appelant n'importe quel rappel (comme un

unique : assurez-vous qu'un seul rappel peut être ajouté à la fois (). donc dans la liste Il n'y a pas de rappels en double).

stopOnFalse : Lorsqu'un rappel renvoie faux, interrompez l'appel

var callbacks = $.Callbacks('once');
  callbacks.add(function() {
    alert('a');
  })
  callbacks.add(function() {
    alert('b');
  })
  callbacks.fire(); //输出结果: 'a' 'b'
  callbacks.fire(); //未执行

une fois pour que la file d'attente de rappel ne s'exécute qu'une seule fois

Mode rappels

Mode par défaut : les rappels dans la colonne de rappel peuvent être exécutés plusieurs fois par défaut et la fonction de rappel peut être ajoutée à plusieurs reprises. Mais lors de l'exécution, le rappel nouvellement ajouté n'est pas exécuté.

une fois : chaque rappel dans la colonne est exécuté au plus une fois. Une fois l'exécution terminée, la colonne de la fonction de rappel est effacée.

mémoire : pendant le processus d'exécution du rappel, si un nouveau rappel est ajouté, le nouveau rappel peut également être exécuté.

Unique : le même rappel ne peut pas être ajouté à plusieurs reprises.

stopOnFalse : Si un rappel renvoie false, les rappels suivants ne seront pas exécutés, même en mode mémoire.

var callbacks = $.Callbacks("once memory");

Ordre d'exécution des rappels

Les rappels sont enregistrés dans le tableau puis parcourus à travers une boucle for, de sorte que les rappels dans la colonne sont exécutés dans l'ordre dans lequel ils sont ajoutés, et le le dernier ajouté est généralement exécuté en dernier.

// Fire the items on the list
var foo = function( value ) {
  console.log( "foo:" + value );
};
// Add another function to the list
var bar = function( value ){
  console.log( "bar:" + value );
};
var callbacks = $.Callbacks();
callbacks.add( foo );
callbacks.add( bar);
callbacks.fire("hello"); 
// output: foo: hello
// output: bar: hello

La seule exception est si la marque est mémoire et si fire() a déjà été appelé, alors le nouveau rappel sera exécuté immédiatement en utilisant les paramètres du feu précédent après son ajout par add( ). Cependant, le rappel appelé par fire() avant add() ne sera pas exécuté à nouveau immédiatement si fire() ou fireWith() n'est pas utilisé.

Autres points clés

Appel de Fire() ou fireWith() de rappels dans la fonction de rappel

Il existe une situation où il est rappelé dans la méthode fire() ou fireWith() de l'objet callback Callbacks, que dois-je faire dans ce cas ?

Jquery fait ceci : appelez fire() ou fireWith() dans le rappel, l'objet Callbacks enregistre simplement les paramètres de fire() ou fireWith(), et n'exécute pas immédiatement le rappel dans la colonne. Une fois que tous les rappels dans les rappels ont été exécutés, réexécutez tous les rappels dans l'objet Callbacks avec de nouveaux paramètres.

Remarque : Si la marque est une fois, l'exécution de fire ou fireWith() dans le rappel n'a aucun effet.

function fn1( value ){
   console.log( value );
 
   if (value == "bar!") return false;
 
   callbacks.fire("bar!");
}
 
function fn2( value ){
  console.log( "fn2 says: " + value);
}
 
var callbacks =$.Callbacks("stopOnFalse");
 
callbacks.add( fn1 );
callbacks.add( fn2 );
 
// Outputs: foo!
// Outputs: fn2 says:foo!
// Outputs: bar!
callbacks.fire("foo!" );

Après avoir appelé callbacks.disable(), les rappels ne peuvent plus être activés

Après avoir appelé Disable(), la liste des fonctions de rappel est effacée à ce moment, en utilisant fire ou fireWith. ne fonctionne pas. Il n'y aura pas de réponse. Par conséquent, les rappels ne fournissent pas de méthode d'activation car tous les rappels ont été effacés et il n'est pas nécessaire de les réactiver.

callbacks.lock()

La colonne de rappel est verrouillée et l'appel de callbacks.fire() ou callbacks.fireWith() ne sera pas valide.

Si callbacks.lock() est appelé dans un rappel, il y a une chose à noter :

les rappels ont une balise mémoire : il n'y a aucun rappel exécuté dans le fire() ou fireWith actuel () L'exécution de la méthode continuera, mais callbacks.fire() et callbacks.fireWith() dans le rappel ne fonctionneront plus.

Les rappels n'ont pas de balise mémoire : tous les rappels sont effacés, ce qui signifie que les rappels suivants ne seront plus exécutés.

Ce qui est étrange, c'est que les Callbacks ne fournissent pas de méthode de déverrouillage. C'est-à-dire qu'une fois verrouillés, les Callbacks perdent définitivement la possibilité d'appeler fire() ou fireWith().

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!