o evento click () está chamando duas vezes no jquery

Eu configurei um elemento de link e chamei seu evento click no jquery, mas o evento click está chamando duas vezes, por favor veja abaixo o código do jquery.

$("#link_button")
.button()
.click(function () {
   $("#attachmentForm").slideToggle("fast");
});

Por favor informar.

Obrigado.

Certifique-se e verifique se você não incluiu acidentalmente seu script duas vezes em sua página HTML.

Faça desassociar antes do clique;

$("#link_button").unbind('click');
$("#link_button")
.button()
.click(function () {
   $("#attachmentForm").slideToggle("fast");
});

Isso significa que seu código incluiu o script jquery duas vezes. Mas tente isto:

$("#btn").unbind("click").click(function(){

//your code

});

Eu tentei e.stopImmediatePropagation(),; Isso parece funcionar para mim.

No meu caso, usei o script abaixo para resolver o problema

$('#id').off().on('click',function(){
    //...
});

off()desassocia todos os eventos vinculados #id. Se você deseja desvincular apenas o clickevento, use off('click').

Basta chamar .off () antes de chamar .on ().

Isso removerá todos os manipuladores de eventos:

$(element).off().on('click', function() {
// function body
});

Para remover apenas manipuladores de eventos de 'clique' registrados:

$(element).off('click').on('click', function() {
// function body
});

Uma solução bastante comum para o problema de dois cliques é colocar

e.stopPropagation()

no final de sua função (supondo que você use function(e)isso). Isso evita que o evento borbulhe, o que pode levar a uma segunda execução da função.

Eu tive o mesmo problema, mas você pode tentar alterar este código

$("#link_button")
.button()
.click(function () {
   $("#attachmentForm").slideToggle("fast");
});

para isso:

$("#link_button").button();
$("#link_button").unbind("click").click(function () {
   $("#attachmentForm").slideToggle("fast");
});

Para mim, esse código resolveu o problema. Mas tome cuidado para não incluir acidentalmente o script duas vezes na página HTML. Acho que se você estiver fazendo essas duas coisas corretamente, seu código funcionará corretamente. obrigado

por favor tente isso

$('#ddlSupervisor').live('change', function (e) {
    if (e.handled !== true) { //this makes event to fire only once
    getEmployeesbySupervisor();
    e.handled = true;
   }
});

Este é definitivamente um bug, especialmente quando é FireFox. Eu pesquisei muito, tentei todas as respostas acima e finalmente descobri como bug por muitos especialistas em SO. Então, eu finalmente tive essa ideia declarando uma variável como

var called = false;
$("#ColorPalete li").click(function() {
    if(!called)
    {
             called = true;
             setTimeout(function(){ //<-----This can be an ajax request but keep in mind to set called=false when you get response or when the function has successfully executed.
                 alert('I am called');
                 called = false;
             },3000);

    }
});

Desta forma, ele primeiro verifica se a função foi chamada anteriormente ou não.

Adicionar e.preventDefault();no início da minha função funcionou para mim.

Esta é uma questão mais antiga, mas se você estiver usando a delegação de eventos, foi isso que a causou.

Depois de removê- .delegate-twolo, a execução parou duas vezes. Acredito que isso aconteça se os dois delegados estiverem presentes na mesma página.

$('.delegate-one, .delegate-two').on('click', '.button', function() {
    /* CODE */
});

este trecho de código não contém nada de ruim. É outra parte do seu script, como disse @karim

No meu caso, estava funcionando bem no Chrome e o IE estava ligando .click()duas vezes. se esse era o seu problema, corrigi-lo com return false, após chamar o .click()evento

   $("#txtChat").keypress(function(event) {
        if (event.which == 13) {
            $('#btnChat').click();
            $('#txtChat').val('');
            return false;
        }
    });

Ligar unbindresolveu meu problema:

$("#btn").unbind("click").click(function() {
    // your code
});

Não tenho certeza do porquê, mas tive esse problema com

$(document).on("click", ".my-element", function (e) { });

Quando mudei para

$(".my-element").click(function () { });

O problema foi resolvido. Mas definitivamente algo errado no meu código.

Fui enganado por uma seleção que combinava vários itens, então cada um foi clicado. :firstajudou:

$('.someClass[data-foo="'+notAlwaysUniqueID+'"]:first').click();

Eu também tive esse problema no FF. Minha etiqueta, entretanto, estava ligada a uma <a>etiqueta. Embora a <a>etiqueta não fosse a lugar nenhum, ainda deu um clique duplo. Troquei a <a>tag por uma <span>tag e o problema do clique duplo desapareceu.

Outra alternativa é remover o atributo href completamente se o link não levar a lugar nenhum.

Enfrentei esse problema porque meu $(elem).click(function(){});script foi colocado embutido em um div que foi definido como style="display:none;".

Quando a exibição css foi alterada para block, o script adicionaria o ouvinte de evento uma segunda vez. Mudei o script para um arquivo .js separado e o ouvinte de evento duplicado não foi mais iniciado.

Quando uso esse método na página de carregamento com jquery, escrevo $('#obj').off('click');antes de definir a função de clique, para que a bolha não ocorra. Funciona para mim.

Minha resposta simples foi transformar o click bind em uma função e chamá-la a partir do onclick do elemento - funcionou muito bem! Considerando que nenhuma das opções acima

Se o seu evento estiver chamando duas ou três vezes, ou mais, isso pode ajudar.

Se você estiver usando algo assim para acionar eventos ...

$('.js-someclass').click();

… Então preste atenção ao número de .js-someclasselementos que você tem na página, porque isso acionará o evento de clique para todos os elementos - e não apenas uma vez!

Uma solução simples é certificar-se de que você acionou o clique apenas uma vez, selecionando apenas o primeiro elemento , por exemplo:

$('.js-someclass:first').click();

Claro que em algum outro lugar em seu (s) script (s) o evento "click" está sendo vinculado novamente ao mesmo elemento, como várias outras respostas / comentários estão sugerindo.

Tive um problema semelhante e para verificar isso, simplesmente adicionei um console.logcomando ao meu script, como no seguinte snippet:

$("#link_button")
    .button()
    .click(function () {
        console.log("DEBUG: sliding toggle...");
        $("#attachmentForm").slideToggle("fast");
    });

Se, ao clicar no botão, você obtiver algo semelhante à imagem abaixo no console do desenvolvedor do seu navegador (como eu fiz), então você sabe com certeza que o click()evento foi vinculado duas vezes ao mesmo botão.

Se você precisar de um patch rápido, a solução proposta por outros comentaristas de usar o offmétodo (btw unbindestá obsoleto desde o jQuery 3.0) para desvincular o evento antes de (re) vinculá-lo funciona bem, e eu a recomendo também:

$("#link_button")
    .button()
    .off("click")
    .click(function () {
        $("#attachmentForm").slideToggle("fast");
    });

Infelizmente, este é apenas um patch temporário! Uma vez que o problema de fazer seu chefe feliz for resolvido, você deve realmente cavar um pouco mais em seu código e corrigir o problema da "ligação duplicada".

A solução real depende, é claro, do seu caso de uso específico. No meu caso, por exemplo, houve um problema de "contexto". Minha função estava sendo invocada como resultado de uma chamada Ajax aplicada a uma parte específica do documento: recarregar todo o documento era, na verdade, recarregar os contextos de "página" e "elemento", resultando no evento sendo vinculado ao elemento duas vezes .

Minha solução para este problema foi a alavancar o jQuery uma função, que é o mesmo que no com a ressalva de que o evento é automaticamente desacoplado após a sua primeira chamada. Isso era ideal para meu caso de uso, mas, novamente, pode não ser a solução para outros casos de uso.

Tive o mesmo problema. Isso funcionou para mim -

$('selector').once().click(function() {});

Espero que isso ajude alguém.

No meu caso, o HTML foi organizado assim:

<div class="share">
  <div class="wrapper">
    <div class="share">
    </div>
  </div>
</div>

E meu jQuery era assim:

jQuery('.share').toggle();

Isso me confundiu porque nada parecia estar acontecendo. O problema era que os .shares internos toggle cancelariam os .shares externos toggle.

Resolvi esse problema alterando o tipo de elemento. em vez de botão eu coloco entrada, e esse problema não ocorre mais.

em vez de:

<button onclick="doSomthing()">click me</button>

substituir com:

<input onclick="doSomthing()" value="click me">