jQuery: Desvincular los controladores de eventos para vincularlos más tarde

Question

¿Alguien sabe cómo desvincular un conjunto de manejadores de eventos, pero memorizarlos para vincularlos más tarde? ¿Alguna sugerencia?

Answer 1

Hay un elemento de eventos en los datos del elemento. Esto debería comenzar, puedes leer tus elementos y almacenar los manejadores en una matriz antes de desvincularlos. Comente si necesita más ayuda. Obtuve esta idea al leer el método $ .fn.clone, así que échale un vistazo a eso también.

$(document).ready(function() { 
    $('#test').click(function(e) { 
     alert('test'); 
     var events = $('#test').data("events"); 
     $('#test').unbind('click', events.click[0]); 
    }); 
}); 

<a id="test">test</a> 

Answer 2

Para desvincular un controlador de eventos, debe pasar la función de controlador a desvincular(). Entonces ya tienes la función de controlador, todo lo que tienes que hacer es recordarlo.

Answer 3

En la actualidad existe un buen plugin de jQuery llamado copyEvents, que copia los eventos de un objeto a otro. Esto podría usarse muy fácilmente para "guardar" eventos de un elemento y traerlos de vuelta más tarde. Solo una opción más :)

Answer 4

Aquí se muestra cómo lograr eso, proporciona los métodos storeEvents y restoreEvents en una selección. storeEvents toma una instantánea de los eventos en el momento en que se llama. restoreEvents restaura a la última instantánea anterior. Puede que sea necesario girarlo un poco para parametrizar la anulación mientras se restaura, tal vez le gustaría conservar los eventos enlazados después de la última instantánea.

(function($){ 

    function obj_copy(obj){ 
      var out = {}; 
     for (i in obj) { 
      if (typeof obj[i] == 'object') { 
       out[i] = this.copy(obj[i]); 
      } 
      else 
       out[i] = obj[i]; 
     } 
     return out; 
    } 


    $.fn.extend({ 

     storeEvents:function(){ 
      this.each(function(){ 
       $.data(this,'storedEvents',obj_copy($(this).data('events'))); 
      }); 
      return this; 
     }, 

     restoreEvents:function(){ 
      this.each(function(){ 
       var events = $.data(this,'storedEvents'); 
       if (events){ 
        $(this).unbind(); 
        for (var type in events){ 
         for (var handler in events[type]){ 
          $.event.add(
           this, 
           type, 
           events[type][handler], 
           events[type][handler].data); 
         } 
        } 
       } 
      }); 
      return this; 
     } 

    }); 
})(jQuery); 

Answer 5

Dado que los cambios jQuery 1.4.2+ cómo se almacenan los controladores de eventos, esto parece relevante:

La mejor manera que encontré fue utilizar espacios de nombre del evento:

var ary_handlers = [ fn_highlight, fn_onpress, fn_cleanup ]; 
for (idx = 0; idx < ary_handlers.length; idx++){ 
    $('#test').bind('click.foobar',ary_handlers[idx]); 
} 

// and then later: 
$('#test').unbind('.foobar'); 

En el ejemplo anterior , todos los eventos foobar sin consolidar. Tenga en cuenta que si usted necesita un control de grano más fino, se puede namespace cada controlador de clic y correlacionar a su gama de manipuladores:

var ary_handlers = [ fn_highlight, fn_onpress, fn_cleanup ]; 
for (idx = 0; idx < ary_handlers.length; idx++){ 
    $('#test').bind('click.ns_' + String(idx), ary_handlers[idx]); 
} 

// and then later you could pick off a specific one to unbind 
$('#test').unbind('.ns_2'); 

Answer 6

Nick Craver parece tener el correct answer para jQuery 1.4.2+. También incluye un útil fiddle. Su solución le permite recuperar todos los manejadores de eventos adjuntos a un elemento jQuery y averiguar a qué controlador fueron asignados.

Answer 7

Se puede utilizar el parámetro event.handler:

$(document).ready(function() { 
    $('#test').click(function(e) { 
     e.preventDefault(); 
     alert('test'); 
     $('#test').unbind('click', e.handler); 
     //Do Something... 
     $('#test').click(); 
    }); 
}); 

<a id="test">test</a> 

event.handler devuelve el manejador actual que ha recibido el evento, por lo omitiendo que se podía mantener los otros manipuladores.