¿Cómo encontrar detectores de eventos en un nodo DOM durante la depuración o desde el código JavaScript?

Tengo una página en la que se adjuntan algunos oyentes de eventos a cuadros de entrada y cuadros de selección. ¿Hay alguna manera de averiguar qué oyentes de eventos están observando un nodo DOM en particular y para qué evento?

Los eventos se adjuntan mediante:

  1. Prototipos Event.observe;
  2. DOM's addEventListener;
  3. Como atributo de elemento element.onclick.

preguntado el 15 de enero de 09 a las 12:01

¿Cómo se adjuntan los eventos en primer lugar? ¿Está utilizando una biblioteca (por ejemplo, Prototype, jQuery, etc.)? -

Es importante tener en cuenta que se pueden adjuntar múltiples funciones de devolución de llamada para el mismo tipo de evento a través de element.addEventListener(type, callback, [bubble]), mientras element.onclick = function sobrescribirá cada vez que asigne. -

Obtiene todos los eventos junto con su elemento respectivo: Array.from(document.querySelectorAll("*")).forEach(e => { const ev = getEventListeners(e); if (Object.keys(ev).length !== 0) {console.log(e, ev)} }) -

Puedes secuestrar el addEventListener y capturar una lista de todos los oyentes en el elemento DOM. Aquí hay un código de muestra stackoverflow.com/a/64484951/1812732 -

19 Respuestas

Si solo necesita inspeccionar lo que está sucediendo en una página, puede probar el Evento visual marcapáginas.

Noticias: Evento visual 2 disponible.

respondido 08 mar '20, 15:03

¡Perfecto! Vence a Firebug's EventBug enchufar. - petirrojo maben

Esto agrega un millón de elementos a la página, muchos de los cuales son imágenes. Su utilidad se reduce enormemente en una página con muchos controladores de eventos (el mío tiene 17k y Visual Event tardó unos 3 minutos en cargarse). - tony r

Creo que la extensión de Chrome que mencionó @ssharma es el que está disponible aquí - kmote

Visial Event no funciona si la página hace referencia a una biblioteca js de terceros. Genera un error: XMLHttpRequest no se puede cargar A.com/js/jquery-ui-1.10.3.custom.js?_=1384831682813. Origen B.com no está permitido por Access-Control-Allow-Origin. - Carretera

Las herramientas de desarrollo internas de Chrome y FF (F12) tienen un visor de eventos integrado. Chrome: en la pestaña "Elementos", seleccione un elemento y vea a la derecha que hay: Estilo, Computado, Oyentes de eventos - Oriadam

Compatibilidad con Chrome, Firefox, Vivaldi y Safari getEventListeners(domElement) en su consola de Herramientas para desarrolladores.

Para la mayoría de los propósitos de depuración, esto podría usarse.

A continuación se muestra una muy buena referencia para usarlo: https://developers.google.com/web/tools/chrome-devtools/console/utilities#geteventlisteners

Respondido 17 Oct 19, 19:10

+1. El código específico del navegador no es un problema para mí, porque estoy tratando de que una página que no controlo funcione correctamente. - grault

agradable, pero solo funciona en la línea de comandos de la consola Chrome :( - gillyespía

@Raghav ah gracias, el uso es getEventListeners(object) NOTA: obj getEventListeners() como pensé por primera vez :) - jave.web

Podrías haberme ahorrado 3 horas si me hubieras explicado cómo obtener el código fuente de un escucha de eventos. Esa "referencia" no explica nada. En caso de que alguien más tuviera pérdidas, aquí se explica cómo: var list = getEventListeners(document.getElementById("YOURIDHERE")); console.log(list["focus"][0]["listener"].toString()). Cambie "foco" al evento que desea inspeccionar y el número si hay varios oyentes en el mismo evento. - doABarrelRoll721

SUGERENCIA: getEventListeners($0) obtendrá los oyentes de eventos para el elemento en el que se ha centrado en las herramientas de desarrollo de Chrome. Uso esto todo el tiempo. Me encanta no tener que usar las funciones querySelector o get__By_ - cacodificador

Depende de cómo se adjuntan los eventos. A modo de ilustración, supongamos que tenemos el siguiente controlador de clics:

var handler = function() { alert('clicked!') };

Lo adjuntaremos a nuestro elemento usando diferentes métodos, algunos que permiten la inspección y otros que no.

Método A) controlador de evento único

element.onclick = handler;
// inspect
console.log(element.onclick); // "function() { alert('clicked!') }"

Método B) múltiples controladores de eventos

if(element.addEventListener) { // DOM standard
    element.addEventListener('click', handler, false)
} else if(element.attachEvent) { // IE
    element.attachEvent('onclick', handler)
}
// cannot inspect element to find handlers

Método C): jQuery

$(element).click(handler);
  • 1.3.x

     // inspect
     var clickEvents = $(element).data("events").click;
     jQuery.each(clickEvents, function(key, value) {
         console.log(value) // "function() { alert('clicked!') }"
     })
    
  • 1.4.x (almacena el controlador dentro de un objeto)

     // inspect
     var clickEvents = $(element).data("events").click;
     jQuery.each(clickEvents, function(key, handlerObj) {
         console.log(handlerObj.handler) // "function() { alert('clicked!') }"
         // also available: handlerObj.type, handlerObj.namespace
     })
    
  • 1.7+ (muy bueno)

    Hecho usando el conocimiento de este comentario.

     events = $._data(this, 'events');
     for (type in events) {
       events[type].forEach(function (event) {
         console.log(event['handler']);
       });
     }
    

(Véase jQuery.fn.data y jQuery.data)

Método D): Prototipo (desordenado)

$(element).observe('click', handler);
  • 1.5.x

     // inspect
     Event.observers.each(function(item) {
         if(item[0] == element) {
             console.log(item[2]) // "function() { alert('clicked!') }"
         }
     })
    
  • 1.6 a 1.6.0.3, inclusive (se volvió muy difícil aquí)

     // inspect. "_eventId" is for < 1.6.0.3 while 
     // "_prototypeEventID" was introduced in 1.6.0.3
     var clickEvents = Event.cache[element._eventId || (element._prototypeEventID || [])[0]].click;
     clickEvents.each(function(wrapper){
         console.log(wrapper.handler) // "function() { alert('clicked!') }"
     })
    
  • 1.6.1 (poco mejor)

     // inspect
     var clickEvents = element.getStorage().get('prototype_event_registry').get('click');
     clickEvents.each(function(wrapper){
         console.log(wrapper.handler) // "function() { alert('clicked!') }"
     })
    

Al hacer clic en la salida resultante en la consola (que muestra el texto de la función), la consola navegará directamente a la línea de la declaración de la función en el archivo JS relevante.

Respondido el 10 de enero de 21 a las 23:01

Gracias por actualizar esto. Es lamentable que tenga que iterar a través de cada tipo de controlador. - Keith Bentrup

En el "Método B" (addEventListener) aquí hay una respuesta sobre el estado de las funciones de enumeración para los controladores registrados con la API de eventos DOM pura: stackoverflow.com/questions/7810534/… - Nickolay

@John: gracias por el comentario. Tienes un ejemplo de "JavaScript real" para recuperar oyentes añadidos previamente a través de addEventListener? - Creciente Fresco

@Jan, esto no parece funcionar para jQuery 1.7.2, ¿hay un enfoque diferente para esa versión? - tomdemuyt

@tomdemuyt En jQuery, los eventos ahora se almacenan en una matriz de datos interna en lugar de ser accesibles a través de .data('events') como eran antes. Para acceder a los datos internos del evento, utilice $._data(elem, 'events'). Tenga en cuenta que esta función está marcada como "solo para uso interno" en la fuente de jQuery, por lo que no promete que siempre funcionará en el futuro, pero creo que ha funcionado desde jQuery 1.7 y todavía funciona. - matt browne

WebKit Inspector en los navegadores Chrome o Safari ahora hace esto. Mostrará los oyentes de eventos para un elemento DOM cuando lo seleccione en el panel Elementos.

Respondido el 17 de enero de 11 a las 07:01

No estoy seguro de que se vea todos las los controladores de eventos; solo el único controlador de eventos HTML. - Huyz

Debo mencionar el complemento EventBug para Firebug para completarsoftwareishard.com/blog/category/eventbug> - Nickolay

Esto acaba de alegrarme el día, algún código de prototipo heredado tenía múltiples funciones vinculadas al mismo evento en el mismo elemento y me moría tratando de rastrearlas. Muchas gracias Ishan. - Siliconrockstar

Es posible enumerar todos los oyentes de eventos. en JavaScript: no es tan difícil; solo tienes que hackear el prototypeEl método de los elementos HTML (antes agregando los oyentes).

function reportIn(e){
    var a = this.lastListenerInfo[this.lastListenerInfo.length-1];
    console.log(a)
}


HTMLAnchorElement.prototype.realAddEventListener = HTMLAnchorElement.prototype.addEventListener;

HTMLAnchorElement.prototype.addEventListener = function(a,b,c){
    this.realAddEventListener(a,reportIn,c); 
    this.realAddEventListener(a,b,c); 
    if(!this.lastListenerInfo){  this.lastListenerInfo = new Array()};
    this.lastListenerInfo.push({a : a, b : b , c : c});
};

Ahora cada elemento de anclaje (a) tendrá un lastListenerInfo propiedad que contiene todos sus oyentes. E incluso funciona para eliminar oyentes con funciones anónimas.

Respondido 30 Jul 12, 01:07

Este método no funcionará si está escribiendo una secuencia de comandos de usuario o una secuencia de comandos de contenido. No solo es probable que estén en un espacio aislado en estos días, sino que ¿cómo se puede garantizar el orden de ejecución? - Huyz

este método funciona con chrome / 19 y FF / 12. El orden de ejecución se puede garantizar si conecta esto antes que otros scripts: Tzury Bar Yochay

¿No podrías simplemente modificar Node.prototype ¿en lugar de? Ahí es donde HTMLAnchorElement hereda .addEventListener de todos modos. - Esailija

Está asumiendo que el agente de usuario implementa la herencia de prototipos para los objetos de host DOM y le permite modificarlos. Ninguna de esas son buenas ideas: no modifiques los objetos que no te pertenecen. - robar

Esto es bastante inútil: muestra qué EventListeners se agregaron, lo que puede ser bueno en algunos casos, pero no qué se eliminó. Entonces, si está tratando de depurar lo que se eliminó y lo que no, simplemente no hay forma. - gotofritz

Utilice getEventListeners en Google Chrome:

getEventListeners(document.getElementByID('btnlogin'));
getEventListeners($('#btnlogin'));

Respondido 04 Abr '18, 00:04

Error de referencia no detectado: getEventListeners no está definido - Bryan Gracia

getEventListeners solo funciona en la consola devtools de Chrome. Y este es un duplicado de esta respuesta más elaborada: stackoverflow.com/a/16544813/1026 - Nickolay

(Reescribiendo la respuesta de esta pregunta ya que es relevante aquí).

Al depurar, si solo desea ver los eventos, le recomiendo ...

  1. Evento visual
  2. El Elements sección de las herramientas para desarrolladores de Chrome: seleccione un elemento y busque "Event Listeners" en la parte inferior derecha (similar en Firefox)

Si desea usar los eventos en su código y está usando jQuery antes de la versión 1.8, puedes usar:

$(selector).data("events")

para conseguir los eventos. A partir de la versión 1.8, se descontinúa el uso de .data ("eventos") (consulte la sección del este boleto de error). Puedes usar:

$._data(element, "events")

Otro ejemplo: escriba todos los eventos de clic en un determinado enlace a la consola:

var $myLink = $('a.myClass');
console.log($._data($myLink[0], "events").click);

(consulte la sección del http://jsfiddle.net/HmsQC/ para un ejemplo de trabajo)

Desafortunadamente, usando $ ._ data esto no es recomendable excepto para la depuración, ya que es una estructura interna de jQuery y podría cambiar en futuras versiones. Desafortunadamente, no conozco ningún otro medio fácil de acceder a los eventos.

contestado el 23 de mayo de 17 a las 12:05

$._data(elem, "events") no parece funcionar con jQuery 1.10, al menos para eventos registrados usando $(elem).on('event', ...). ¿Alguien sabe cómo depurarlos? - Marius Gedminas

No soy positivo, pero creo que el primer parámetro de $._data puede necesitar ser un elemento y no un objeto jQuery. Así que necesito arreglar mi ejemplo anterior para que sea console.log($._data($myLink[0], "events").click); - Luke

1: Prototype.observe usa Element.addEventListener (ver el código fuente)

2: puede anular Element.addEventListener para recordar los oyentes agregados (propiedad útil EventListenerList fue eliminado de la propuesta de especificaciones DOM3). Ejecute este código antes de que se adjunte cualquier evento:

(function() {
  Element.prototype._addEventListener = Element.prototype.addEventListener;
  Element.prototype.addEventListener = function(a,b,c) {
    this._addEventListener(a,b,c);
    if(!this.eventListenerList) this.eventListenerList = {};
    if(!this.eventListenerList[a]) this.eventListenerList[a] = [];
    this.eventListenerList[a].push(b);
  };
})();

Lea todos los eventos por:

var clicks = someElement.eventListenerList.click;
if(clicks) clicks.forEach(function(f) {
  alert("I listen to this function: "+f.toString());
});

Y no te olvides de anular Element.removeEventListener para eliminar el evento de la costumbre Element.eventListenerList.

3: el Element.onclick la propiedad necesita un cuidado especial aquí:

if(someElement.onclick)
  alert("I also listen tho this: "+someElement.onclick.toString());

4: no olvides el Element.onclick atributo de contenido: estas son dos cosas diferentes:

someElement.onclick = someHandler; // IDL attribute
someElement.setAttribute("onclick","otherHandler(event)"); // content attribute

Así que también debes manejarlo:

var click = someElement.getAttribute("onclick");
if(click) alert("I even listen to this: "+click);

El bookmarklet Visual Event (mencionado en la respuesta más popular) solo roba la caché del controlador de la biblioteca personalizada:

Resulta que no existe un método estándar proporcionado por la interfaz DOM recomendada por W3C para averiguar qué detectores de eventos están conectados a un elemento en particular. Si bien esto puede parecer un descuido, hubo una propuesta para incluir una propiedad llamada eventListenerList en la especificación DOM de nivel 3, pero desafortunadamente se eliminó en borradores posteriores. Como tal, nos vemos obligados a mirar las bibliotecas de Javascript individuales, que generalmente mantienen un caché de eventos adjuntos (para que luego puedan eliminarse y realizar otras abstracciones útiles).

Como tal, para que Visual Event muestre eventos, debe poder analizar la información del evento desde una biblioteca de Javascript.

La anulación de elementos puede ser cuestionable (es decir, porque hay algunas características específicas de DOM como colecciones en vivo, que no se pueden codificar en JS), pero brinda soporte a eventListenerList de forma nativa y funciona en Chrome, Firefox y Opera (no funciona en IE7 ).

Respondido el 27 de junio de 15 a las 11:06

Puede ajustar los métodos DOM nativos para administrar los oyentes de eventos colocando esto en la parte superior de su <head>:

<script>
    (function(w){
        var originalAdd = w.addEventListener;
        w.addEventListener = function(){
            // add your own stuff here to debug
            return originalAdd.apply(this, arguments);
        };

        var originalRemove = w.removeEventListener;
        w.removeEventListener = function(){
            // add your own stuff here to debug
            return originalRemove.apply(this, arguments);
        };
    })(window);
</script>

H / T @ les2

respondido 06 nov., 15:17

Corríjame si me equivoco, pero ¿no es solo para los oyentes de eventos adjuntos a la ventana? - Maciej Krawczyk

@MaciejKrawczyk sí, y los que burbujean - jon z

Las herramientas para desarrolladores de Firefox ahora hacen esto. Los eventos se muestran haciendo clic en el botón "ev" a la derecha de la pantalla de cada elemento, incluido jQuery y DOM eventos.

Captura de pantalla del botón de escucha de eventos de las herramientas para desarrolladores de Firefox en la pestaña del inspector

Respondido el 29 de Septiembre de 16 a las 18:09

Miré uno de los elementos dom en la página a la que el marcador Visual Event 2 muestra un evento conectado, y vi el pequeño botón "ev" a la derecha, como se muestra. - Eric

El detector de eventos de Firefox podría descubrir los eventos delegados de jQuery, mientras que Chrome necesita un complemento para hacerlo. - Nick Tsai

Si tiene Firebug, puedes usar console.dir(object or array) para imprimir un bonito árbol en el registro de la consola de cualquier escalar, matriz u objeto de JavaScript.

Tratar:

console.dir(clickEvents);

or

console.dir(window);

Respondido el 29 de Septiembre de 16 a las 18:09

Solución totalmente funcional basada en respuesta de Jan Turon - se comporta como getEventListeners() desde la consola:

(Hay un pequeño error con los duplicados. De todos modos, no se rompe mucho).

(function() {
  Element.prototype._addEventListener = Element.prototype.addEventListener;
  Element.prototype.addEventListener = function(a,b,c) {
    if(c==undefined)
      c=false;
    this._addEventListener(a,b,c);
    if(!this.eventListenerList)
      this.eventListenerList = {};
    if(!this.eventListenerList[a])
      this.eventListenerList[a] = [];
    //this.removeEventListener(a,b,c); // TODO - handle duplicates..
    this.eventListenerList[a].push({listener:b,useCapture:c});
  };

  Element.prototype.getEventListeners = function(a){
    if(!this.eventListenerList)
      this.eventListenerList = {};
    if(a==undefined)
      return this.eventListenerList;
    return this.eventListenerList[a];
  };
  Element.prototype.clearEventListeners = function(a){
    if(!this.eventListenerList)
      this.eventListenerList = {};
    if(a==undefined){
      for(var x in (this.getEventListeners())) this.clearEventListeners(x);
        return;
    }
    var el = this.getEventListeners(a);
    if(el==undefined)
      return;
    for(var i = el.length - 1; i >= 0; --i) {
      var ev = el[i];
      this.removeEventListener(a, ev.listener, ev.useCapture);
    }
  };

  Element.prototype._removeEventListener = Element.prototype.removeEventListener;
  Element.prototype.removeEventListener = function(a,b,c) {
    if(c==undefined)
      c=false;
    this._removeEventListener(a,b,c);
      if(!this.eventListenerList)
        this.eventListenerList = {};
      if(!this.eventListenerList[a])
        this.eventListenerList[a] = [];

      // Find the event in the list
      for(var i=0;i<this.eventListenerList[a].length;i++){
          if(this.eventListenerList[a][i].listener==b, this.eventListenerList[a][i].useCapture==c){ // Hmm..
              this.eventListenerList[a].splice(i, 1);
              break;
          }
      }
    if(this.eventListenerList[a].length==0)
      delete this.eventListenerList[a];
  };
})();

Uso:

someElement.getEventListeners([name]) - lista de retorno de oyentes de eventos, si se establece el nombre, devuelve la matriz de oyentes para ese evento

someElement.clearEventListeners([name]) - eliminar todos los detectores de eventos, si se establece el nombre, solo eliminar los detectores de ese evento

contestado el 23 de mayo de 17 a las 13:05

Esta es una buena respuesta, pero no puedo hacer que funcione en el body y document elementos. - david bradshaw

¡Muy buena solución! - Dzhakhar Ukhaev

@Peter Mortensen, ¿por qué cambiaste el nombre de Jan? :) - n00b

@David Bradshaw: porque el cuerpo, el documento y la ventana tienen su propio prototipo y no el prototipo de Element ... - Stefan Steiger

@ n00b: Hay un error. Por eso hmmm. Utiliza el operador de coma en la instrucción if para el oyente y useCaption ... El operador de coma evalúa cada uno de sus operandos (de izquierda a derecha) y devuelve el valor del último operando. Así que eliminas el primer eventListener que coincide con useCapture, independientemente del tipo de evento ... Eso debería ser && en lugar de una coma. - Stefan Steiger

Opera 12 (no es el último motor Chrome Webkit basado en) Libélula ha tenido esto por un tiempo y obviamente se muestra en la estructura DOM. En mi opinión, es un depurador superior y es la única razón que queda por la que sigo usando la versión basada en Opera 12 (no hay versión v13, v14 y la versión basada en Webkit v15 todavía carece de Dragonfly)

enter image description here

respondido 28 nov., 13:16

Para obtener todos los EventListeners en una página impresa junto con sus elementos

Array.from(document.querySelectorAll("*")).forEach(e => {
    const ev = getEventListeners(e)
    if (Object.keys(ev).length !== 0) console.log(e, ev)
})

Respondido 22 Jul 20, 15:07

Prototipo 1.7.1 vía

function get_element_registry(element) {
    var cache = Event.cache;
    if(element === window) return 0;
    if(typeof element._prototypeUID === 'undefined') {
        element._prototypeUID = Element.Storage.UID++;
    }
    var uid =  element._prototypeUID;           
    if(!cache[uid]) cache[uid] = {element: element};
    return cache[uid];
}

Respondido el 17 de enero de 13 a las 17:01

Recientemente estuve trabajando con eventos y quería ver / controlar todos los eventos en una página. Habiendo analizado posibles soluciones, decidí seguir mi propio camino y crear un sistema personalizado para monitorear eventos. Entonces, hice tres cosas.

Primero, necesitaba un contenedor para todos los oyentes de eventos en la página: ese es elEventListeners objeto. Tiene tres métodos útiles: add(), remove() y get().

A continuación, creé un EventListener Objeto para contener la información necesaria para el evento, es decir: target, type, callback, options, useCapture, wantsUntrustedy agregó un método remove() para eliminar el oyente.

Por último, extendí el nativo addEventListener() y removeEventListener() métodos para que funcionen con los objetos que he creado (EventListener y EventListeners).

Uso:

var bodyClickEvent = document.body.addEventListener("click", function () {
    console.log("body click");
});

// bodyClickEvent.remove();

addEventListener() crea un EventListener objeto, lo agrega a EventListeners y devuelve el EventListener objeto, para que pueda eliminarse más tarde.

EventListeners.get() se puede utilizar para ver los oyentes en la página. Acepta un EventTarget o una cadena (tipo de evento).

// EventListeners.get(document.body);
// EventListeners.get("click");

Demo

Digamos que queremos conocer a todos los oyentes de eventos en esta página actual. Podemos hacer eso (asumiendo que está usando una extensión de administrador de scripts, Tampermonkey en este caso). El siguiente script hace esto:

// ==UserScript==
// @name         New Userscript
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       You
// @include      https://stackoverflow.com/*
// @grant        none
// ==/UserScript==

(function() {
    fetch("https://raw.githubusercontent.com/akinuri/js-lib/master/EventListener.js")
        .then(function (response) {
            return response.text();
        })
        .then(function (text) {
            eval(text);
            window.EventListeners = EventListeners;
        });
})(window);

Y cuando enumeramos todos los oyentes, dice que hay 299 oyentes de eventos. "Parece" haber algunos duplicados, pero no sé si son realmente duplicados. No todos los tipos de eventos están duplicados, por lo que todos esos "duplicados" pueden ser un oyente individual.

captura de pantalla de la consola que enumera todos los oyentes de eventos en esta página

El código se puede encontrar en mi repositorio. No quería publicarlo aquí porque es bastante largo.


Actualizar: Esto no parece funcionar con jQuery. Cuando examino el EventListener, veo que la devolución de llamada es

function(b){return"undefined"!=typeof r&&r.event.triggered!==b.type?r.event.dispatch.apply(a,arguments):void 0}

Creo que esto pertenece a jQuery y no es la devolución de llamada real. jQuery almacena la devolución de llamada real en las propiedades de EventTarget:

$(document.body).click(function () {
    console.log("jquery click");
});

enter image description here

Para eliminar un detector de eventos, la devolución de llamada real debe pasarse al removeEventListener() método. Entonces, para que esto funcione con jQuery, necesita más modificaciones. Podría arreglar eso en el futuro.

Respondido el 28 de junio de 18 a las 11:06

Estoy tratando de hacer eso en jQuery 2.1, y con el "$().click() -> $(element).data("events").click;"método que no funciona.

Me di cuenta de que solo las funciones $ ._ data () funcionan en mi caso:

	$(document).ready(function(){

		var node = $('body');
		
        // Bind 3 events to body click
		node.click(function(e) { alert('hello');  })
			.click(function(e) { alert('bye');  })
			.click(fun_1);

        // Inspect the events of body
		var events = $._data(node[0], "events").click;
		var ev1 = events[0].handler // -> function(e) { alert('hello')
		var ev2 = events[1].handler // -> function(e) { alert('bye')
		var ev3 = events[2].handler // -> function fun_1()
        
		$('body')
			.append('<p> Event1 = ' + eval(ev1).toString() + '</p>')
			.append('<p> Event2 = ' + eval(ev2).toString() + '</p>')
			.append('<p> Event3 = ' + eval(ev3).toString() + '</p>');        
	
	});

	function fun_1() {
		var txt = 'text del missatge';	 
		alert(txt);
	}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<body>
</body>

contestado el 19 de mayo de 15 a las 10:05

Existe bonito Extensión jQuery Events :

enter image description here (tema fuente)

contestado el 23 de mayo de 17 a las 13:05

cambiar estas funciones le permitirá registrar los oyentes agregados:

EventTarget.prototype.addEventListener
EventTarget.prototype.attachEvent
EventTarget.prototype.removeEventListener
EventTarget.prototype.detachEvent

leer al resto de los oyentes con

console.log(someElement.onclick);
console.log(someElement.getAttribute("onclick"));

Respondido 18 Abr '19, 15:04

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.