Best way to remove an event handler in jQuery?

Question

I have an input type="image". This acts like the cell notes in Microsoft Excel. If someone enters a number into the text box that this input-image is paired with, I setup an event handler for the input-image. Then when the user clicks the image, they get a little popup to add some notes to the data.

My problem is that when a user enters a zero into the text box, I need to disable the input-image's event handler. I have tried the following, but to no avail.

$('#myimage').click(function { return false; });

Drastic

Answer 1

jQuery ≥ 1.7

With jQuery 1.7 onward the event API has been updated, .bind()/.unbind() are still available for backwards compatibility, but the preferred method is using the on()/off() functions. The below would now be,

$('#myimage').click(function() { return false; }); // Adds another click event
$('#myimage').off('click');
$('#myimage').on('click.mynamespace', function() { /* Do stuff */ });
$('#myimage').off('click.mynamespace');

---

jQuery < 1.7

In your example code you are simply adding another click event to the image, not overriding the previous one:

$('#myimage').click(function() { return false; }); // Adds another click event

Both click events will then get fired.

As people have said you can use unbind to remove all click events:

$('#myimage').unbind('click');

If you want to add a single event and then remove it (without removing any others that might have been added) then you can use event namespacing:

$('#myimage').bind('click.mynamespace', function() { /* Do stuff */ });

and to remove just your event:

$('#myimage').unbind('click.mynamespace');

Agueweed

Is there a way to test if unbind() is working? I've added it and both events are still firing. – Tippet

Well if both events are still firing then obviously its not working. You'd have to give more info to get a proper answer. Try asking a separate question. – Agueweed

Old answer -also like the the included namespace information- but I forget; does on/off return the jQ object? If so, perhaps a more complete answer would be to daisy chain: $('#myimage').off('click').on('click',function(){...}) – Oppressive

Yes they do, so yes, if you wanted to clear all other click events and then add your own you could do the above chained call. – Agueweed

Using .unbind() helped me in a situation where I was toggling a bunch of checkboxes, but relized i was re-adding the .click() handler repeatedly, causing the app to hang. – Stalkinghorse

@samjudson: could you explain why we would like to use off instead of unbind? @the0ther mentions closure compiler but I'm not sure what this means nor whether this is the correct/only reason. thanks – Koan

I believe @theOther is stating a preference for bind() over click(), not bind() over on(). on/off have replaced bind/unbind as the preferred method in jQuery since 1.7 as stated above. I don't know what the closure compiler is so can't really comment on that. – Agueweed

just struck my comment from the record, it was three years old. on/off is the way to go. – Drastic

this one is a hack::: cleaning up all the events from the element regardless if they have set using .on(..) or even native .onclick = --- clone the element with .cloneNode(true) hide the original element, insert the copied one before it, optionally removing the original element afterwards. – Ma

@Agueweed if a button has attrib onclick="return false;" its jQuery click listener is still being fired..is that correct? – Weise

See jwhittenburg's comment below re DOM object having inline onclick="doFoo" - use .prop("onclick", null).attr("onclick", null) – Vitellin

Was previously unaware of jQuery event namespacing: api.jquery.com/event.namespace (pretty slim documentation tbh). But precisely what I needed, allows sets of events to be bound / unbound as a group. – Anthrax

For those for whom this does not work, it is important to note that the location of the on and off calls can prevent proper operation. Selecting the items again with $ may help solve the problem. – Cauterant

If you want to remove that only specific event listener, you'll need to supply the callback as the second argument of that off function. i.e., $(window).off('scroll', scrollEventHandler); – Lubricious

Answer 2

This wasn't available when this question was answered, but you can also use the live() method to enable/disable events.

$('#myimage:not(.disabled)').live('click', myclickevent);

$('#mydisablebutton').click( function () { $('#myimage').addClass('disabled'); });

What will happen with this code is that when you click #mydisablebutton, it will add the class disabled to the #myimage element. This will make it so that the selector no longer matches the element and the event will not be fired until the 'disabled' class is removed making the .live() selector valid again.

This has other benefits by adding styling based on that class as well.

Pastelki

Nice way to use live(), never thought about using it this way before ... Aside from coding convenience, is it faster or does it offer any other advantages to using bind/unbind? – Classical

If you are adding/removing elements, then there are definite performance advantages over bind as the binding with live is only done once. jQuery seems to be moving to more live and delegate events rather than binding to specific elements. – Pastelki

To disable live you can use die() – Rosalynrosalynd

"As of jQuery 1.7, the .live() method is deprecated. Use .on() to attach event handlers. Users of older versions of jQuery should use .delegate() in preference to .live()." api.jquery.com/live – Hypoxia

Ah, fickle jQuery, one day you bring 300 rep to a guy, the next day it's obsolete. – Addicted

Answer 3

This can be done by using the unbind function.

$('#myimage').unbind('click');

You can add multiple event handlers to the same object and event in jquery. This means adding a new one doesn't replace the old ones.

There are several strategies for changing event handlers, such as event namespaces. There are some pages about this in the online docs.

Look at this question (that's how I learned of unbind). There is some useful description of these strategies in the answers.

How to read bound hover callback functions in jquery

Limpkin

Answer 4

If you want to respond to an event just one time, the following syntax should be really helpful:

 $('.myLink').bind('click', function() {
   //do some things

   $(this).unbind('click', arguments.callee); //unbind *just this handler*
 });

Using arguments.callee, we can ensure that the one specific anonymous-function handler is removed, and thus, have a single time handler for a given event. Hope this helps others.

Cosmetician

Absolutely, though sometimes you may wish to have certain logic about when the handler should be unbound (e.g. don't unbind unless they filed out a text box first). – Cosmetician

arguments.callee is depraceted in strict mode! – Evermore

Answer 5

maybe the unbind method will work for you

$("#myimage").unbind("click");

Scabble

Answer 6

I had to set the event to null using the prop and the attr. I couldn't do it with one or the other. I also could not get .unbind to work. I am working on a TD element.

.prop("onclick", null).attr("onclick", null)

Gadolinite

I voted this up because I've been trying to unbind an onblur for about 30 mintues. '.unbind' didn't work, '.prop' didn't work, '.attr' didn't work, but this trick with both .prop and .attr together did the trick. odd. I'm using Chrome with jquery 1.7.2 – Enwomb

Same here! i tried to remove click event from simple <a> tag! Thanx for this. In my case .prop("onclick", null) was enough. – Larine

same here. unbind and off didn't work for me on FF with jq 1.7.2 and .prop("onclick", null) was also sufficient in my case – Abigael

I think the reason the above methods didn't work for you guys is because of how you set it up. If you wrote the event handler into the DOM then yes, clearing this attribute is necessary to clear the event handler, however, I think most people (including myself) wish to keep such things (javascrip, event handlers, etc.) out of the DOM, so when we want to set up an event handler we use something like $("#elementId").click(function(){//Event execution code goes here}); so that it is not in the html page at all. To clear that we actually need to use .unbind(), or the preferred .off() – Balthazar

Here's a like from someone who has just spent an hour to discover that properties added via jQuery don't show on Chrome's element panel. Been trying unbind and off and it wasn't solving the problem. Thank you very much! – Calculus

Im with the "unbind() didnt work for me" crowd, but this did, and I'm using latest jquery. Go figure – Jecho

Answer 7

If event is attached this way, and the target is to be unattached:

$('#container').on('click','span',function(eo){
    alert(1);

    $(this).off(); //seams easy, but does not work

    $('#container').off('click','span'); //clears click event for every span

    $(this).on("click",function(){return false;}); //this works.

});​

Leonialeonid

Answer 8

To remove ALL event-handlers, this is what worked for me:

To remove all event handlers mean to have the plain HTML structure without all the event handlers attached to the element and its child nodes. To do this, jQuery's clone() helped.

var original, clone;
// element with id my-div and its child nodes have some event-handlers
original = $('#my-div');
clone = original.clone();
//
original.replaceWith(clone);

With this, we'll have the clone in place of the original with no event-handlers on it.

Good Luck...

Legroom

Answer 9

If you use $(document).on() to add a listener to a dynamically created element then you may have to use the following to remove it:

// add the listener
$(document).on('click','.element',function(){
    // stuff
});

// remove the listener
$(document).off("click", ".element");

Detraction

I have a click event on jquery datatable row. The data being loaded from Web API. So, on my case and this solution worked perfectly :) – Appeasement

Answer 10

You may be adding the onclick handler as inline markup:

<input id="addreport" type="button" value="Add New Report" onclick="openAdd()" />

If so, the jquery .off() or .unbind() won't work. You need to add the original event handler in jquery as well:

$("#addreport").on("click", "", function (e) {
   openAdd();
});

Then the jquery has a reference to the event handler and can remove it:

$("#addreport").off("click")

VoidKing mentions this a little more obliquely in a comment above.

Houppelande

Answer 11

Updated for 2014

Using the latest version of jQuery, you're now able to unbind all events on a namespace by simply doing $( "#foo" ).off( ".myNamespace" );

Tibold

Answer 12

Best way to remove inline onclick event is $(element).prop('onclick', null);

Batfish

Answer 13

Thanks for the information. very helpful i used it for locking page interaction while in edit mode by another user. I used it in conjunction with ajaxComplete. Not necesarily the same behavior but somewhat similar.

function userPageLock(){
    $("body").bind("ajaxComplete.lockpage", function(){
        $("body").unbind("ajaxComplete.lockpage");
        executePageLock();      
    });
};  

function executePageLock(){
    //do something
}

Pyrargyrite

Answer 14

In case .on() method was previously used with particular selector, like in the following example:

$('body').on('click', '.dynamicTarget', function () {
    // Code goes here
});

Both unbind() and .off() methods are not going to work.

However, .undelegate() method could be used to completely remove handler from the event for all elements which match the current selector:

$("body").undelegate(".dynamicTarget", "click")

Phago

I scrolled entire page while for looking this solution, worked like a charm. – Swede

Answer 15

I know this comes in late, but why not use plain JS to remove the event?

var myElement = document.getElementById("your_ID");
myElement.onclick = null;

or, if you use a named function as an event handler:

function eh(event){...}
var myElement = document.getElementById("your_ID");
myElement.addEventListener("click",eh); // add event handler
myElement.removeEventListener("click",eh); //remove it

Leralerch

Good suggestion, I prefer to use native javascript when available – Dimorph

Answer 16

This also works fine .Simple and easy.see http://jsfiddle.net/uZc8w/570/

$('#myimage').removeAttr("click");

Arsenal

Answer 17

if you set the onclick via html you need to removeAttr ($(this).removeAttr('onclick'))

if you set it via jquery (as the after the first click in my examples above) then you need to unbind($(this).unbind('click'))

Canning

Answer 18

All the approaches described did not work for me because I was adding the click event with on() to the document where the element was created at run-time:

$(document).on("click", ".button", function() {
    doSomething();
});

My workaround:

As I could not unbind the ".button" class I just assigned another class to the button that had the same CSS styles. By doing so the live/on-event-handler ignored the click finally:

// prevent another click on the button by assigning another class
$(".button").attr("class","buttonOff");

Hope that helps.

Gambill

Answer 19

Hope my below code explains all. HTML:

(function($){

     $("#btn_add").on("click",function(){
       $("#btn_click").on("click",added_handler);
       alert("Added new handler to button 1");
     });

  
 
     $("#btn_remove").on("click",function(){
       $("#btn_click").off("click",added_handler);
       alert("Removed new handler to button 1");
     });

  
   function fixed_handler(){
    alert("Fixed handler");
  }
  
   function added_handler(){
    alert("new handler");
  }
  
  $("#btn_click").on("click",fixed_handler);
  $("#btn_fixed").on("click",fixed_handler);
  
  
})(jQuery);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<button id="btn_click">Button 1</button>
  <button id="btn_add">Add Handler</button>
  <button id="btn_remove">Remove Handler</button>
  <button id="btn_fixed">Fixed Handler</button>

Berezina

why are you passing in })(jQuery); into the IIFE when it can already be accessed globally? – Overeat

Good question Bryan. This method has been entered in my gene due to practice. - There can be some possibility for non jquery plugin to have the variable $, hence I cannot use $ directly. - Frequent use of the word "jQuery" in an js script file can increase the byte size of the file, where jQuery is a 6 byte string. Hence I prefer to use "$" or any variable of single byte. – Berezina

Answer 20

I had an interesting case relevant to this come up at work today where there was a scroll event handler for $(window).

// TO ELIMINATE THE RE-SELECTION AND 
//   RE-CREATION OF THE SAME OBJECT REDUNDANTLY IN THE FOLLOWING SNIPPETS
let $window = $(window);

$window.on('scroll', function() { .... });

But, to revoke that event handler, we can't just use

$window.off('scroll');

because there are likely other scroll event handlers on this very common target, and I'm not interested in hosing that other functionality (known or unknown) by turning off all of the scroll handlers.

My solution was to first abstract the handler functionality into a named function, and use that in the event listener setup.

function handleScrollingForXYZ() { ...... }

$window.on('scroll', handleScrollingForXYZ);

And then, conditionally, when we need to revoke that, I did this:

$window.off('scroll', $window, handleScrollingForXYZ);

The janky part is the 2nd parameter, which is redundantly selecting the original selector. But, the jquery documentation for .off() only provides one method signature for specifying the handler to remove, which requires this middle parameter to be

A selector which should match the one originally passed to .on() when attaching event handlers.

I haven't ventured to test it out with a null or '' as the 2nd parameter, but perhaps the redundant $window isn't necessary.

Fromenty