Was ist das Gegenteil von evt.preventDefault ();

evt.preventDefault()Wie kann ich die Standardaktionen wieder aufnehmen, nachdem ich eine ausgelöst habe ?

Laut Kommentar von @Prescott ist das Gegenteil von:

evt.preventDefault();

Könnte sein:

Im Wesentlichen gleichbedeutend mit "Standard ausführen" , da wir dies nicht mehr verhindern.

Ansonsten bin ich geneigt, Sie auf die Antworten anderer Kommentare und Antworten hinzuweisen:

Wie kann ich die Bindung eines Listeners aufheben, der event.preventDefault () aufruft (mit jQuery)?

Wie kann ich event.preventDefault wieder aktivieren?

Beachten Sie, dass die zweite mit einer Beispiellösung von redsquare akzeptiert wurde (hier für eine direkte Lösung angegeben, falls diese nicht als Duplikat geschlossen wird):

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

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

und sein Gegenteil

function(evt) {return true;}

Prost!

So verarbeiten Sie einen Befehl, bevor Sie einen Link von einem clickEreignis in jQuery fortsetzen:

Z.B: <a href="http://google.com/" class="myevent">Click me</a>

Verhindern und verfolgen Sie 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");
    }
});

Oder einfach window.location = this.href;hinter dem herlaufenpreventDefault();

Ich musste eine Formularübermittlung in jQuery verzögern, um einen asynchronen Aufruf auszuführen. Hier ist der vereinfachte Code ...

$("$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();
    });
});

OK ! Es funktioniert für das Klickereignis:

$("#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;

und sein Gegenteil (Standard):

event.returnValue = true;

Quelle: https://developer.mozilla.org/en-US/docs/Web/API/Event/returnValue

Ich würde folgendes Muster vorschlagen:

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>

... es sei denn, ich vermisse etwas.

http://jsfiddle.net/DdvcX/

Es gibt keine entgegengesetzte Methode, um event.preventDefault()zu verstehen, warum Sie zuerst untersuchen müssen, was event.preventDefault()passiert, wenn Sie es aufrufen.

Unter der Haube ruft die Funktionalität für PreventDefault im Wesentlichen eine Rückgabe false auf, die jede weitere Ausführung anhält. Wenn Sie mit den alten Methoden von Javascript vertraut sind, war es früher üblich, return false zum Abbrechen von Ereignissen für Dinge wie Formularübermittlungen und Schaltflächen mit return true zu verwenden (bevor es jQuery überhaupt gab).

Wie Sie wahrscheinlich bereits anhand der obigen einfachen Erklärung herausgefunden haben: Das Gegenteil von event.preventDefault()ist nichts. Sie verhindern das Ereignis einfach nicht. Standardmäßig lässt der Browser das Ereignis zu, wenn Sie es nicht verhindern.

Eine Erklärung finden Sie unten:

;(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);

Im obigen Code werden Sie feststellen, dass wir prüfen, ob allowSubmit falsch ist. Dies bedeutet, dass wir verhindern, dass unser Formular mit event.preventDefaultgesendet wird, und dann eine Validierungslogik durchführen. Wenn wir zufrieden sind, setzen Sie allowSubmit auf true.

Dies ist wirklich die einzig wirksame Methode, um das Gegenteil von zu tun. event.preventDefault()Sie können auch versuchen, Ereignisse zu entfernen, die im Wesentlichen dasselbe bewirken würden.

Hier ist etwas Nützliches ...

Zuerst klicken wir auf den Link, führen Code aus und führen dann die Standardaktion aus. Dies wird mit event.currentTarget möglich sein . Hier werden wir versuchen, über einen neuen Tab auf Google zuzugreifen, aber bevor wir Code ausführen müssen.

<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>

Dies ist, was ich verwendet habe, um es einzustellen:

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

Und um es rückgängig zu machen:

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

Keine der Lösungen hat mir hier geholfen und ich habe dies getan, um meine Situation zu lösen.

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

Und die Funktion 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();
}

Ich nehme an, das "Gegenteil" wäre, ein Ereignis zu simulieren. Du könntest benutzen.createEvent()

Nach Mozillas Beispiel:

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");
  }
}

Ref: document.createEvent

Mit jQuery .trigger()können Sie Ereignisse für Elemente auslösen - manchmal nützlich.

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

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

jquery on () könnte eine andere Lösung dafür sein. vor allem, wenn es um die Verwendung von Namespaces geht .

jquery on () ist nur die aktuelle Methode zum Binden von Ereignissen (anstelle von bind ()). off () soll diese lösen. Wenn Sie einen Namespace verwenden, können Sie mehrere verschiedene Ereignisse hinzufügen und entfernen.

$( 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");
    }
});

Mit dem Namespace können Sie jetzt mehrere dieser Ereignisse hinzufügen und diese je nach Ihren Anforderungen entfernen. Während das Senden möglicherweise nicht das beste Beispiel ist, kann dies bei einem Klick oder Tastendruck oder was auch immer nützlich sein.

Dies ist keine direkte Antwort auf die Frage, kann aber jemandem helfen. Mein Punkt ist, dass Sie PreventDefault () nur unter bestimmten Bedingungen aufrufen, da es keinen Sinn macht, ein Ereignis zu haben, wenn Sie PreventDefault () für alle Fälle aufrufen. Wenn Sie also if-Bedingungen haben und präventDefault () nur aufrufen, wenn die Bedingung (en) erfüllt sind, funktioniert die Funktion in den anderen Fällen auf die übliche Weise.

$('.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

});

Sie können dies nach der Methode "prepareDefault" verwenden

// Hier gibt evt.target das Standardereignis zurück (zB: defult url etc)

var defaultEvent=evt.target;

// Hier speichern wir das Standardereignis.

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

Sie können dies immer an ein Klickereignis in Ihrem Skript anhängen:

location.href = this.href;

Anwendungsbeispiel ist:

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

Dieser Code funktionierte für mich, um das Ereignis erneut zu instanziieren, nachdem ich Folgendes verwendet hatte:

event.preventDefault(); to disable the event.


event.preventDefault = false;

Ich habe den folgenden Code verwendet. Es funktioniert gut für mich.

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