නිදොස් කිරීමේදී හෝ ජාවාස්ක්‍රිප්ට් කේතයෙන් සිදුවීම් අසන්නන් DOM නෝඩ් එකකින් සොයා ගන්නේ කෙසේද?

සමහර සිදුවීම් සවන්දෙන්නන් ආදාන පෙට්ටිවලට සම්බන්ධ කර ඇති පෙට්ටි මා සතුව ඇත. විශේෂිත DOM නෝඩයක් නිරීක්ෂණය කරන්නේ කුමන සිදුවීම් සවන්දෙන්නන් සහ කුමන සිදුවීම සඳහාද යන්න සොයා ගැනීමට ක්‍රමයක් තිබේද?

සිදුවීම් අමුණා ඇත්තේ:

1. මූලාකෘති Event.observe ;
2. DOM ගේ addEventListener;
3. මූලද්‍රව්‍ය ගුණාංගයක් ලෙස element.onclick.

පිටුවක සිදුවන්නේ කුමක්ද යන්න පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම්, ඔබට දෘශ්‍ය සිදුවීම් පොත් සලකුණ උත්සාහ කළ හැකිය .

යාවත්කාලීන කිරීම : දෘශ්‍ය සිදුවීම් 2 ලබා ගත හැකිය.

ක්‍රෝම්, ෆයර්ෆොක්ස්, විවාල්ඩි සහ සෆාරි getEventListeners(domElement)ඔවුන්ගේ සංවර්ධක මෙවලම් කොන්සෝලය තුළ සහය දක්වයි .

නිදොස් කිරීමේ අරමුණු සඳහා, මෙය භාවිතා කළ හැකිය.

එය භාවිතා කිරීම සඳහා ඉතා හොඳ සඳහනක් පහත දැක්වේ: https://developers.google.com/web/tools/chrome-devtools/console/utilities#geteventlisteners

එය සිදුවීම් අමුණා ඇති ආකාරය මත රඳා පවතී. නිදර්ශන උපකල්පනය සඳහා අපට පහත ක්ලික් හසුරුවන්නා ඇත:

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

අපි එය විවිධ ක්‍රම භාවිතා කරමින් අපගේ මූලද්‍රව්‍යයට අනුයුක්ත කරන්නෙමු, සමහර ඒවා පරීක්ෂා කිරීමට ඉඩ දෙන අතර සමහරක් එසේ නොකරයි.

ක්රමය A) තනි සිදුවීම් හසුරුවන්නා

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

ක්රමය B) බහු සිදුවීම් හසුරුවන්නන්

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

ක්රමය C): jQuery

$(element).click(handler);

• 1.3.x.

  // inspect
  var clickEvents = $(element).data("events").click;
  jQuery.each(clickEvents, function(key, value) {
      alert(value) // alerts "function() { alert('clicked!') }"
  })
  

• 1.4.x (හසුරුවන්නා වස්තුවක් තුළ ගබඩා කරයි)

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

^{(බලන්න jQuery.fn.dataසහ jQuery.data)}

ක්රමය D): මූලාකෘති (අවුල් සහගත)

$(element).observe('click', handler);

• 1.5.x.

  // inspect
  Event.observers.each(function(item) {
      if(item[0] == element) {
          alert(item[2]) // alerts "function() { alert('clicked!') }"
      }
  })
  

• 1.6 සිට 1.6.0.3 දක්වා, ඇතුළත් (මෙහි ඉතා අපහසු විය)

  // 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){
      alert(wrapper.handler) // alerts "function() { alert('clicked!') }"
  })
  

• 1.6.1 (ටිකක් හොඳයි)

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

ක්‍රෝම් හෝ සෆාරි බ්‍රව්සර්වල වෙබ්කිට් පරීක්ෂක දැන් මෙය කරයි. ඔබ එය මූලද්‍රව්‍ය කවුළුව තුළ තෝරාගත් විට එය DOM මූලද්‍රව්‍යයක් සඳහා සිදුවීම් සවන්දෙන්නන් පෙන්වනු ඇත.

ජාවාස්ක්‍රිප්ට් හි සියලුම සිදුවීම් අසන්නන් ලැයිස්තුගත කළ හැකිය : එය එතරම් අපහසු නැත; ඔබට prototypeHTML මූලද්‍රව්‍යයන්ගේ ක්‍රමය ( සවන්දෙන්නන් එකතු කිරීමට පෙර ) හැක් කළ යුතුය.

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});
};

දැන් සෑම නැංගුරම් අංගයකම ( a) lastListenerInfoදේපළක් ඇති අතර එහි සියලු සවන්දෙන්නන් අඩංගු වේ. නිර්නාමික කාර්යයන් සහිත සවන්දෙන්නන් ඉවත් කිරීමට පවා එය ක්‍රියා කරයි.

Google Chrome හි getEventListeners භාවිතා කරන්න :

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

(ගේ පිළිතුර නැවත ලිවීම මෙම ප්රශ්නය එය මෙහි අදාළ කිරීමේ සිට.)

නිදොස්කරණය කිරීමේදී, ඔබට සිදුවීම් බැලීමට අවශ්‍ය නම්, මම නිර්දේශ කරමි ...

1. දෘශ්‍ය සිදුවීම
2. මෙම මූලිකාංග Chrome හි සංවර්ධන මෙවලම් වගන්තිය: (ෆයර්ෆොක්ස් සමාන වූ) පහළ දකුණු මත "සිදුවීම් අයට" සඳහා අංගයක් හා පෙනුම තෝරා

ඔබේ කේතයේ සිදුවීම් භාවිතා කිරීමට ඔබට අවශ්‍ය නම් සහ 1.8 අනුවාදයට පෙර ඔබ jQuery භාවිතා කරන්නේ නම් , ඔබට මෙය භාවිතා කළ හැකිය:

$(selector).data("events")

සිදුවීම් ලබා ගැනීමට. 1.8 අනුවාදය අනුව .data ("සිදුවීම්") භාවිතා කිරීම අත්හිටුවා ඇත ( මෙම දෝෂ ප්‍රවේශ පත්‍රය බලන්න ). ඔයාට පාවිච්චි කරන්න පුළුවන්:

$._data(element, "events")

තවත් උදාහරණයක්: සියලුම ක්ලික් සිදුවීම් එක්තරා සබැඳියක් කොන්සෝලය වෙත ලියන්න:

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

( වැඩ කරන උදාහරණයක් සඳහා http://jsfiddle.net/HmsQC/ බලන්න)

අවාසනාවකට මෙන්, $ ._ දත්ත භාවිතා කිරීම මෙය අභ්‍යන්තර jQuery ව්‍යුහයක් වන බැවින් නිදොස් කිරීම හැරෙන්නට නිර්දේශ නොකරයි . අවාසනාවට, සිදුවීම් වලට ප්‍රවේශ වීමට වෙනත් පහසු ක්‍රමයක් ගැන මම නොදනිමි.

1: Prototype.observeElement.addEventListener භාවිතා කරයි ( ප්‍රභව කේතය බලන්න )

2: Element.addEventListenerඑකතු කළ සවන්දෙන්නන් මතක තබා ගැනීමට ඔබට අභිබවා යා හැකිය ( EventListenerListDOM3 පිරිවිතර යෝජනාවෙන් පහසු දේපල ඉවත් කරන ලදි). ඕනෑම සිදුවීමක් ඇමිණීමට පෙර මෙම කේතය ක්‍රියාත්මක කරන්න:

(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);
  };
})();

සියලුම සිදුවීම් කියවන්න:

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

Element.removeEventListenerචාරිත්රයෙන් සිදුවීම ඉවත් කිරීම සඳහා අභිබවා යාමට අමතක නොකරන්න Element.eventListenerList.

3: Element.onclickදේපල සඳහා මෙහි විශේෂ සැලකිල්ලක් අවශ්‍යයි:

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

4: Element.onclickඅන්තර්ගත ගුණාංගය අමතක නොකරන්න : මේවා වෙනස් කරුණු දෙකකි:

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

එබැවින් ඔබ එය ද හැසිරවිය යුතුය:

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

දෘශ්‍ය සිදුවීම් පොත් සලකුණ (වඩාත්ම ජනප්‍රිය පිළිතුරෙහි සඳහන් කර ඇත) සොරකම් කරන්නේ අභිරුචි පුස්තකාල හසුරුවන්නාගේ හැඹිලිය පමණි:

විශේෂිත මූලද්‍රව්‍යයකට සවන්දෙන්නන් සම්බන්ධ වන්නේ කුමක් දැයි සොයා ගැනීමට W3C නිර්දේශිත DOM අතුරුමුහුණත මඟින් සපයන සම්මත ක්‍රමයක් නොමැති බව පෙනේ. මෙය අධීක්ෂණයක් ලෙස පෙනෙන්නට තිබුණද, 3 වන මට්ටමේ DOM පිරිවිතරයට eventListenerList නමින් දේපලක් ඇතුළත් කිරීමට යෝජනාවක් තිබුණද, අවාසනාවකට පසු කෙටුම්පත් වලින් එය ඉවත් කරන ලදී. එනිසා සාමාන්‍යයෙන් අමුණා ඇති සිදුවීම් වල හැඹිලියක් පවත්වා ගෙන යන තනි ජාවාස්ක්‍රිප්ට් පුස්තකාල දෙස බැලීමට අපට බල කෙරෙයි (එබැවින් ඒවා පසුව ඉවත් කර වෙනත් ප්‍රයෝජනවත් වියුක්ත කිරීම් සිදු කළ හැකිය).

එනිසා දෘශ්‍ය සිදුවීම් සිදුවීම් පෙන්වීමට නම්, සිදුවීම් තොරතුරු ජාවාස්ක්‍රිප්ට් පුස්තකාලයකින් විග්‍රහ කිරීමට එයට හැකි විය යුතුය.

මූලද්රව්ය අභිබවා යාම සැක සහිත විය හැකිය (එනම් JS හි කේතගත කළ නොහැකි සජීවී එකතු කිරීම් වැනි සමහර DOM විශේෂිත අංගයන් ඇත), නමුත් එය ස්වදේශීය වශයෙන් EventListenerList සහාය ලබා දෙන අතර එය Chrome, Firefox සහ Opera හි ක්‍රියා කරයි (IE7 හි ක්‍රියා නොකරයි ).

සිදුවීම් සවන්දෙන්නන් කළමනාකරණය කිරීම සඳහා ඔබට ස්වදේශීය DOM ක්‍රම ඔතා තැබිය හැකිය <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

ෆයර්ෆොක්ස් සංවර්ධක මෙවලම් දැන් මෙය කරයි. JQuery සහ DOM සිදුවීම් ඇතුළුව එක් එක් මූලද්‍රව්‍යයේ දර්ශනයේ දකුණු පස ඇති “ev” බොත්තම ක්ලික් කිරීමෙන් සිදුවීම් පෙන්වනු ලැබේ .

ඔබට ෆයර්බග් තිබේ නම් , ඔබට console.dir(object or array)ඕනෑම ජාවාස්ක්‍රිප්ට් පරිමාණයක්, අරාව හෝ වස්තුවක කොන්සෝල ලොගයේ ලස්සන ගසක් මුද්‍රණය කිරීමට භාවිතා කළ හැකිය .

උත්සාහ කරන්න:

console.dir(clickEvents);

හෝ

console.dir(window);

ජෑන් ටියුරන්ගේ පිළිතුර මත පදනම්ව සම්පුර්ණයෙන්ම වැඩ කරන විසඳුම - හැසිරෙන්නේ getEventListeners()කොන්සෝලයේ සිට ය:

(අනුපිටපත් සමඟ කුඩා දෝෂයක් ඇත. කෙසේ වෙතත් එය බොහෝ දුරට කැඩී යන්නේ නැත.)

(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];
  };
})();

භාවිතය:

someElement.getEventListeners([name]) - නම සකසා ඇත්නම්, එම අවස්ථාවට සවන්දෙන්නන්ගේ ආපසු පෙළක්

someElement.clearEventListeners([name]) - සියලු සිදුවීම් අසන්නන් ඉවත් කරන්න, නම සකසා ඇත්නම් එම සිදුවීම සඳහා සවන්දෙන්නන් පමණක් ඉවත් කරන්න

ඔපෙරා 12 (නවතම ක්‍රෝම් වෙබ්කිට් එන්ජිම මත පදනම් වූවක් නොවේ) ඩ්‍රැගන්ෆ්ලයිට මෙය ටික කලක් පැවතුන අතර එය පැහැදිලිවම DOM ව්‍යුහයේ ප්‍රදර්ශනය වේ. මගේ මතය අනුව එය සුපිරි නිදොස් කිරීමක් වන අතර මම තවමත් ඔපෙරා 12 පාදක අනුවාදය භාවිතා කිරීමට ඉතිරිව ඇති එකම හේතුව එයයි (v13, v14 අනුවාදයක් නොමැති අතර v15 වෙබ්කිට් මත පදනම් වූ ඩ්‍රැගන්ෆ්ලයි තවමත් නොමැත)

මූලාකෘති 1.7.1 මාර්ගය

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];
}

මම මෑතකදී සිදුවීම් සමඟ වැඩ කරමින් සිටි අතර පිටුවක ඇති සියලුම සිදුවීම් බැලීමට / පාලනය කිරීමට මට අවශ්‍ය විය. හැකි විසඳුම් දෙස බැලීමෙන් පසු, මගේම මාර්ගයට ගොස් සිදුවීම් අධීක්ෂණය කිරීම සඳහා අභිරුචි පද්ධතියක් නිර්මාණය කිරීමට මම තීරණය කර ඇත්තෙමි. ඉතින්, මම කරුණු තුනක් කළා.

පළමුව, පිටුවේ ඇති සියලුම සිදුවීම් අසන්නන් සඳහා මට කන්ටේනරයක් අවශ්‍ය විය: එය EventListenersවස්තුවයි. එය එය ප්රයෝජනවත් ක්රම තුනක් ඇත: add(), remove(), සහ get().

ඊළඟට, මම නිර්මාණය EventListenerමෙම අවස්ථාවට සඳහා අවශ්ය තොරතුරු පැවැත්වීමට වස්තුව, එනම්: target, type, callback, options, useCapture, wantsUntrusted, සහ ක්රමය එකතු remove()ශ්රවණය ඉවත් කිරීමට.

අවසාන වශයෙන්, මා විසින් නිර්මාණය කරන ලද ( සහ ) වස්තූන් සමඟ වැඩ කිරීමට ස්වදේශික addEventListener()හා removeEventListener()ක්‍රම දීර් extended කළෙමි .EventListenerEventListeners

භාවිතය:

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

// bodyClickEvent.remove();

addEventListener()EventListenerවස්තුවක් සාදයි , එය එකතු කර වස්තුව EventListenersආපසු ලබා දෙයි EventListener, එවිට එය පසුව ඉවත් කළ හැකිය.

EventListeners.get()පිටුවේ සවන්දෙන්නන් බැලීමට භාවිතා කළ හැකිය. එය EventTargetනූලක් හෝ නූලක් පිළිගනී (සිදුවීම් වර්ගය).

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

නිරූපණය

මෙම වත්මන් පිටුවෙහි සෑම සිදුවීම් අසන්නෙකුම දැන ගැනීමට අපට අවශ්‍ය යැයි කියමු. අපට එය කළ හැකිය (ඔබ මේ අවස්ථාවේ දී ස්ක්‍රිප්ට් මැනේජර් දිගුවක් භාවිතා කරන බව උපකල්පනය කරන්න, ටැම්පර්මොන්කි). පහත පිටපත මෙය කරයි:

// ==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);

අපි සියලු සවන්දෙන්නන් ලැයිස්තුගත කරන විට, එයින් කියවෙන්නේ සිදුවීම් අසන්නන් 299 ක් සිටින බවයි. එහි සමහර අනුපිටපත් ඇති බව පෙනේ, නමුත් ඒවා ඇත්ත වශයෙන්ම අනුපිටපත් දැයි මම නොදනිමි. සෑම සිදුවීම් වර්ගයක්ම අනුපිටපත් නොකෙරේ, එබැවින් එම “අනුපිටපත්” සියල්ලම තනි සවන්දෙන්නෙකු විය හැකිය.

කේතය මගේ ගබඩාවේ සොයාගත හැකිය . මට එය මෙහි පළ කිරීමට අවශ්‍ය නොවීය.

යාවත්කාලීන කිරීම: මෙය jQuery සමඟ වැඩ කරන බවක් නොපෙනේ. මම EventListener පරීක්‍ෂා කරන විට, ඇමතුම ආපසු ලබා දෙන බව මට පෙනේ

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

මම විශ්වාස කරන්නේ මෙය jQuery ට අයත් වන අතර එය සත්‍ය ඇමතුම නොවේ. jQuery විසින් EventTarget හි ගුණාංගවල සත්‍ය ඇමතුම් ලබා ගනී:

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

සිදුවීම් සවන්දෙන්නෙකු ඉවත් කිරීම සඳහා, සත්‍ය ඇමතුම removeEventListener()ක්‍රමයට ලබා දිය යුතුය . එබැවින් jQuery සමඟ මෙම කාර්යය කිරීමට නම්, එය තවදුරටත් වෙනස් කිරීම අවශ්‍ය වේ. මම අනාගතයේදී එය නිවැරදි කළ හැකිය.

මම එය jQuery 2.1 හි කිරීමට උත්සාහ කරමි, සහ " $().click() -> $(element).data("events").click;" ක්‍රමය සමඟ එය ක්‍රියා නොකරයි.

මගේ නඩුවේ ක්‍රියාත්මක වන්නේ $ ._ දත්ත () කාර්යයන් පමණක් බව මම තේරුම් ගතිමි:

	$(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>

ලස්සන jQuery සිදුවීම් දිගුව පවතී :

(මාතෘකා ප්‍රභවය )

මෙම කාර්යයන් වෙනස් කිරීමෙන් ඔබට සවන්දෙන්නන් ලොග් වීමට ඉඩ දෙනු ඇත:

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

ඉතිරි සවන්දෙන්නන් සමඟ කියවන්න

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

සියලුම සිදුවීම් ලැයිස්තු ඔවුන්ගේ මූලද්‍රව්‍ය සමඟ මුද්‍රණය කරන ලද පිටුවක ලබා ගැනීම

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