Javascript/DOM: How to remove all event listeners of a DOM object?

dom, events, javascript

Solution

I am not sure what you mean with remove all events. Remove all handlers for a specific type of event or all event handlers for one type?

Remove all event handlers

If you want to remove all event handlers (of any type), you could clone the element and replace it with its clone:

var clone = element.cloneNode(true);

Note: This will preserve attributes and children, but it will not preserve any changes to DOM properties.

Remove "anonymous" event handlers of specific type

The other way is to use `removeEventListener()` but I guess you already tried this and it didn't work. Here is the catch:

Calling `addEventListener` to an anonymous function creates a new listener each time. Calling `removeEventListener` to an anonymous function has no effect. An anonymous function creates a unique object each time it is called, it is not a reference to an existing object though it may call one. When adding an event listener in this manner be sure it is added only once, it is permanent (cannot be removed) until the object it was added to, is destroyed.

You are essentially passing an anonymous function to `addEventListener` as `eventReturner` returns a function.

You have two possibilities to solve this:

Don't use a function that returns a function. Use the function directly:

 function handler() {
     dosomething();
 }

 div.addEventListener('click',handler,false);

Create a wrapper for `addEventListener` that stores a reference to the returned function and create some weird `removeAllEvents` function:

 var _eventHandlers = {}; // somewhere global

 const addListener = (node, event, handler, capture = false) => {
   if (!(event in _eventHandlers)) {
     _eventHandlers[event] = []
   }
   // here we track the events and their nodes (note that we cannot
   // use node as Object keys, as they'd get coerced into a string
   _eventHandlers[event].push({ node: node, handler: handler, capture: capture })
   node.addEventListener(event, handler, capture)
 }

 const removeAllListeners = (targetNode, event) => {
   // remove listeners from the matching nodes
   _eventHandlers[event]
     .filter(({ node }) => node === targetNode)
     .forEach(({ node, handler, capture }) => node.removeEventListener(event, handler, capture))

   // update _eventHandlers global
   _eventHandlers[event] = _eventHandlers[event].filter(
     ({ node }) => node !== targetNode,
   )
 }

And then you could use it with:

    addListener(div, 'click', eventReturner(), false)
    // and later
    removeAllListeners(div, 'click')

DEMO

Note: If your code runs for a long time and you are creating and removing a lot of elements, you would have to make sure to remove the elements contained in `_eventHandlers` when you destroy them.

Problem

Just question: Is there any way to completely remove all events of an object, e.g. a div? EDIT: I'm adding per `div.addEventListener('click',eventReturner(),false);` an event. ``` function eventReturner() { return function() { dosomething(); }; } ``` EDIT2: I found a way, which is working, but not possible to use for my case: ``` var returnedFunction; function addit() { var div = document.getElementById('div'); returnedFunction = eventReturner(); div.addEventListener('click',returnedFunction,false); //You HAVE to take here a var and not the direct call to eventReturner(), because the function address must be the same, and it would change, if the function was called again. } function removeit() { var div = document.getElementById('div'); div.removeEventListener('click',returnedFunction,false); } ```

Original source