Co jest przeciwieństwem evt.preventDefault ();

Po zwolnieniu i evt.preventDefault()jak mogę wznowić domyślne działania?

Zgodnie z komentarzem @Prescott, przeciwieństwo:

evt.preventDefault();

Możliwe:

Zasadniczo równa się „zrób domyślnie” , ponieważ nie zapobiegamy już temu.

W przeciwnym razie chętnie wskażę odpowiedzi na inne komentarze i odpowiedzi:

Jak odznaczyć detektor wywołujący event.preventDefault () (przy użyciu jQuery)?

Jak ponownie włączyć event.preventDefault?

Zauważ, że drugi został zaakceptowany z przykładowym rozwiązaniem podanym przez redsquare (opublikowanym tutaj dla bezpośredniego rozwiązania na wypadek, gdyby nie zostało zamknięte jako duplikat):

$('form').submit( function(ev) {
     ev.preventDefault();
     //later you decide you want to submit
     $(this).unbind('submit').submit()
});

function(evt) {evt.preventDefault();}

i przeciwnie

function(evt) {return true;}

Twoje zdrowie!

Aby przetworzyć polecenie przed kontynuowaniem łącza ze clickzdarzenia w jQuery:

Na przykład: <a href="http://google.com/" class="myevent">Click me</a>

Zapobiegaj i wykonuj za pomocą jQuery:

$('a.myevent').click(function(event) {
    event.preventDefault();

    // Do my commands
    if( myEventThingFirst() )
    {
      // then redirect to original location
      window.location = this.href;
    }
    else
    {
      alert("Couldn't do my thing first");
    }
});

Lub po prostu biegnij window.location = this.href;zapreventDefault();

Musiałem opóźnić przesłanie formularza w jQuery, aby wykonać asynchroniczne wywołanie. Oto uproszczony kod ...

$("$theform").submit(function(e) {
    e.preventDefault();
    var $this = $(this);
    $.ajax('/path/to/script.php',
        {
        type: "POST",
        data: { value: $("#input_control").val() }
    }).done(function(response) {
        $this.unbind('submit').submit();
    });
});

DOBRZE ! działa w przypadku zdarzenia kliknięcia:

$("#submit").click(function(e){ 

   e.preventDefault();

  -> block the click of the sumbit ... do what you want

$("#submit").unbind('click').click(); // the html click submit work now !

});

event.preventDefault(); //or event.returnValue = false;

i jego przeciwieństwo (standard):

event.returnValue = true;

źródło: https://developer.mozilla.org/en-US/docs/Web/API/Event/returnValue

Sugerowałbym następujący wzór:

document.getElementById("foo").onsubmit = function(e) {
    if (document.getElementById("test").value == "test") {
        return true;
    } else {
        e.preventDefault();
    }
}

<form id="foo">
    <input id="test"/>
    <input type="submit"/>
</form>

... chyba że czegoś mi brakuje.

http://jsfiddle.net/DdvcX/

Nie ma przeciwnej metody event.preventDefault()zrozumienia, dlaczego najpierw trzeba spojrzeć na to, co się event.preventDefault()dzieje, kiedy się nazywa.

Pod maską funkcjonalność preventDefault zasadniczo nazywa zwracanie wartości false, co zatrzymuje dalsze wykonywanie. Jeśli znasz stare metody Javascript, kiedyś było modne użycie return false do anulowania zdarzeń na rzeczach takich jak przesyłanie formularzy i przyciski za pomocą return true (zanim jQuery był w pobliżu).

Jak zapewne mogłeś już wypracować na podstawie prostego wyjaśnienia powyżej: przeciwieństwo event.preventDefault()jest niczym. Po prostu nie zapobiegasz zdarzeniu, domyślnie przeglądarka zezwala na zdarzenie, jeśli mu nie zapobiegasz.

Poniżej wyjaśnienie:

;(function($, window, document, undefined)) {

    $(function() {
        // By default deny the submit
        var allowSubmit = false;

        $("#someform").on("submit", function(event) {

            if (!allowSubmit) {
                event.preventDefault();

                // Your code logic in here (maybe form validation or something)
                // Then you set allowSubmit to true so this code is bypassed

                allowSubmit = true;
            }

        });
    });

})(jQuery, window, document);

W powyższym kodzie zauważysz, że sprawdzamy, czy parametr allowSubmit jest fałszywy. Oznacza to, że nie będziemy mogli przesyłać formularza przy użyciu, event.preventDefaulta następnie wykonamy logikę sprawdzania poprawności, a jeśli będziemy zadowoleni, ustaw parametr allowSubmit na true.

Jest to naprawdę jedyna skuteczna metoda działania przeciwnego event.preventDefault()- możesz także spróbować usunąć zdarzenia, które zasadniczo doprowadziłyby do tego samego.

Oto coś przydatnego ...

Najpierw klikniemy na link, uruchomimy kod, a następnie wykonamy domyślną akcję. Będzie to możliwe przy użyciu event.currentTarget Spójrz. Tutaj spróbujemy uzyskać dostęp do Google na nowej karcie, ale zanim będziemy musieli uruchomić kod.

<a href="https://www.google.com.br" target="_blank" id="link">Google</a>

<script type="text/javascript">
    $(document).ready(function() {
        $("#link").click(function(e) {

            // Prevent default action
            e.preventDefault();

            // Here you'll put your code, what you want to execute before default action
            alert(123); 

            // Prevent infinite loop
            $(this).unbind('click');

            // Execute default action
            e.currentTarget.click();
        });
    });
</script>

Oto, co ustawiłem:

$("body").on('touchmove', function(e){ 
    e.preventDefault(); 
});

I aby to cofnąć:

$("body").unbind("touchmove");

Żadne z rozwiązań nie pomogło mi tutaj i zrobiłem to, aby rozwiązać moją sytuację.

<a onclick="return clickEvent(event);" href="/contact-us">

I funkcji clickEvent(),

function clickEvent(event) {
    event.preventDefault();
    // do your thing here

    // remove the onclick event trigger and continue with the event
    event.target.parentElement.onclick = null;
    event.target.parentElement.click();
}

Podejrzewam, że „przeciwieństwem” byłoby symulowanie zdarzenia. Możesz użyć.createEvent()

Idąc za przykładem Mozilli:

function simulateClick() {
  var evt = document.createEvent("MouseEvents");
  evt.initMouseEvent("click", true, true, window,
    0, 0, 0, 0, 0, false, false, false, false, 0, null);
  var cb = document.getElementById("checkbox"); 
  var cancelled = !cb.dispatchEvent(evt);
  if(cancelled) {
    // A handler called preventDefault
    alert("cancelled");
  } else {
    // None of the handlers called preventDefault
    alert("not cancelled");
  }
}

Patrz: document.createEvent

jQuery ma, .trigger()więc możesz wyzwalać zdarzenia na elementach - czasem przydatne.

$('#foo').bind('click', function() {
      alert($(this).text());
});

$('#foo').trigger('click');

jquery on () może być innym rozwiązaniem tego problemu. ucieleśniająco, jeśli chodzi o wykorzystanie przestrzeni nazw .

jquery on () to tylko bieżący sposób wiązania zdarzeń (zamiast bind ()). off () ma na celu ich usunięcie. a gdy używasz przestrzeni nazw, możesz dodawać i usuwać wiele różnych zdarzeń.

$( selector ).on("submit.my-namespace", function( event ) {
    //prevent the event
    event.preventDefault();

    //cache the selector
    var $this = $(this);

    if ( my_condition_is_true ) {
        //when 'my_condition_is_true' is met, the binding is removed and the event is triggered again.
        $this.off("submit.my-namespace").trigger("submit");
    }
});

teraz za pomocą przestrzeni nazw możesz dodać wiele z tych zdarzeń i możesz je usunąć, w zależności od potrzeb. Podczas gdy przesyłanie może nie być najlepszym przykładem, może się przydać po kliknięciu, naciśnięciu klawisza lub cokolwiek innego.

To nie jest bezpośrednia odpowiedź na pytanie, ale może komuś pomóc. Chodzi mi o to, że wywołujesz preventDefault () tylko w oparciu o niektóre warunki, ponieważ nie ma sensu mieć zdarzenia, jeśli wywołasz funkcję preventDefault () we wszystkich przypadkach. Zatem posiadanie if i wywoływanie preventDefault () tylko wtedy, gdy spełniony jest warunek / warunki, będzie działał w zwykły sposób dla pozostałych przypadków.

$('.btnEdit').click(function(e) {

   var status = $(this).closest('tr').find('td').eq(3).html().trim();
   var tripId = $(this).attr('tripId');

  if (status == 'Completed') {

     e.preventDefault();
     alert("You can't edit completed reservations");

 } else if (tripId != '') {

    e.preventDefault();
    alert("You can't edit a reservation which is already attached to a trip");
 }
 //else it will continue as usual

});

możesz użyć tego po metodzie „preventDefault”

// Tutaj evt.target zwraca domyślne zdarzenie (np .: defult url etc)

var defaultEvent=evt.target;

// Tutaj zapisujemy domyślne zdarzenie.

if("true")
{
//activate default event..
location.href(defaultEvent);
}

Zawsze możesz użyć tego skryptu dołączonego do jakiegoś zdarzenia kliknięcia:

location.href = this.href;

przykładem użycia jest:

jQuery('a').click(function(e) {
    location.href = this.href;
});

ten kod działał dla mnie w celu ponownego utworzenia zdarzenia po użyciu:

event.preventDefault(); to disable the event.


event.preventDefault = false;

Użyłem następującego kodu. Działa dla mnie dobrze.

$('a').bind('click', function(e) {
  e.stopPropagation();
});