Prevent click event from firing when dblclick event fires

I'm handling both the click and dblclick event on a DOM element. Each one carries out a different command, but I find that when double clicking on the element, in addition to firing the double click event, the click event is also fired twice. What is the best approach for preventing this behavior?



In a comment, you said,

I delay the click handler by 300 ms (a noticeable and annoying delay) and even ...

So it sounds like what you want is that when you click then the DOM should geneate a click event immediately, except not if the click is the first click of a double-click.

To implement this feature, when you click, the DOM would need to be able to predict whether this is the final click or whether it's the first of a double-click (however I don't think is possible in general for the DOM to predict whether the user is about to click again).

What are the two distinct actions which you're trying to take on click and double-click? IMO, in a normal application you might want both events: e.g. single-click to focus on an element and then double-click to activate it.

When you must separate the events, some applications use something other than double-click: for example, they use right-click, or control-click.


In case anyone else stumbles on this (as I did) looking for an answer, the absolute best solution that I could come up with is the following:

      if(e.originalEvent.detail > 1){
        /* if you are returning a value from this
         function then return false or cancel 
         the event some other way */

Done. If there is more than one click back to back, the second, third,etc. will not fire. I definitely prefer this to using any sort of timers.

I got myself pointed in this direction by reading this.

Incidentally: I was first researching this problem because I accidentally double clicked a paginated link, and the event fired and finished twice before the callback could happen.

Before coming up with the code above, I had

 if e.originalEvent.detail === 2 //return

however, I was able to click on the link 3 times (a triple click), and though the second click didn't fire, the third did


In this case, it is best to delay the execution of the single click event slightly. Have your double click handler set a variable that the single click event will check. If that variable has a particular value, could be boolDoubleClick == true, then don't fire/handle the single click.


You can use UIEvent.detail if you want to detect how many times the element was clicked and fire events based on that.

A simple example:

element.addEventListener("click", function (e) {
  if (e.detail === 1) {
    // do something if the element was clicked once.
  } else if (e.detail === 2) {
    // do something else if the element was clicked twice

AFAIK DOM Level 2 Events makes no specification for double-click. It doesn't work for me on IE7 (there's a shock), but FF and Opera have no problem managing the spec, where I can attach all actions to the click event, but for double-click just wait till the "detail" attribute of the event object is 2. From the docs: "If multiple clicks occur at the same screen location, the sequence repeats with the detail attribute incrementing with each repetition."


Here is what I did to distinguish within a module

       node.on('click', function(e) {

            //Prepare for double click, continue to clickHandler doesn't come soon enough
            console.log("cleared timeout in click",_this.clickTimeout);
            _this.clickTimeout = setTimeout(function(){
                console.log("handling click");

        node.on('dblclick', function (e) {

            console.log("cleared timeout in dblclick",_this.clickTimeout);
            // Rest of the handler function

Thanks to all the other answers here as the combination of them seems to provide a reasonable solution for me when the interaction requires both, but mutually exclusive:

var pendingClick = 0;

function xorClick(e) {
    // kill any pending single clicks
    if (pendingClick) {
        pendingClick = 0;

    switch (e.detail) {
        case 1:
            pendingClick = setTimeout(function() {
                console.log('single click action here');
            }, 500);// should match OS multi-click speed
        case 2:
            console.log('double click action here');
            console.log('higher multi-click actions can be added as needed');

myElem.addEventListener('click', xorClick, false);

Update: I added a generalized version of this approach along with a click polyfill for touch devices to this Github repo with examples:


I know this is old as heck, but thought I'd post anyhow since I just ran into the same problem. Here's how I resolved it.

 $('#alerts-display, #object-display').on('click', ['.item-data-summary', '.item-marker'], function(e) {

    var id;

    id = setTimeout(() => {
       // code to run here
       return false;
    }, 150);


$('.panel-items-set-marker-view').on('dblclick', ['.summary', '.marker'], function(e) {
    for (let i = 0; i < timeoutIDForDoubleClick.length; i++) {

    // code to run on double click


  const toggle = () => {
      watchDouble += 1;
        if (watchDouble === 2) {
          console.log('double' + watchDouble)
        } else if (watchDouble === 1) {
          console.log("signle" + watchDouble)
        watchDouble = 0


I use this solution for my project to prevent click event action, if I had dblclick event that should do different thing.

Note: this solution is just for click and dblclick and not any other thing like tripleclick or etc.

To see proper time between click and double click see this

sorry for my bad English. I hope it helps :)

var button, isDblclick, timeoutTiming;
var clickTimeout, dblclickTimeout;
button = $('#button');
isDblclick = false;
the proper time between click and dblclick is not standardized,
and is cutsomizable by user apparently (but this is windows standard I guess!)
timeoutTiming = 500;
button.on('dblclick', function () {

  isDblclick = true;
  dblclickTimeout = setTimeout(function () {
    isDblclick = false;
  }, timeoutTiming);
  // here goes your dblclick codes
  console.log('double clicked! not click.');
}).on('click', function () {

  clickTimeout = setTimeout(function () {
    if(!isDblclick) {
      // here goes your click codes
      console.log('a simple click.');
  }, timeoutTiming);
<script src=""></script>
<button type="button" id="button">
click/dblclick on this to see the result


Here is my simple solution to prevent the second click. Of course, I could restart the timeout when a double click detected, but in reality I never need it.

clickTimeoutId = null;

onClick(e) {
    if (clickTimeoutId !== null) {
        // Double click, do nothing

    // Single click
    // TODO smth

    clickTimeoutId = setTimeout(() => {
        clickTimeoutId = null;
    }, 300);


Recent Questions

Top Questions

Home Tags Terms of Service Privacy Policy DMCA Contact Us

©2020 All rights reserved.