Quel est le contraire de evt.preventDefault();

comme le commente @Prescott, le contraire de:

evt.preventDefault();

pourrait être:

correspond essentiellement à " do default " , puisque nous ne l'empêchons plus.

sinon je suis enclin à vous montrer les réponses fournies par d'autres commentaires et réponses:

comment débiter un auditeur qui est l'appel de l'événement.preventDefault () (utilisant jQuery)?

Comment réactiver l'événement.préventdefault?

notez que la seconde solution a été acceptée avec un exemple de solution, donné par redsquare (posté ici pour une solution directe au cas où ce n'est pas fermé en double):

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

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

et son opposé

function(evt) {return true;}

santé!

pour traiter une commande avant de poursuivre un lien à partir d'un click événement dans jQuery:

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

prévenir et poursuivre avec 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");
    }
});

ou tout simplement exécuter window.location = this.href; après le preventDefault();

j'ai dû retarder une soumission de formulaire dans jQuery afin d'exécuter un appel asynchrone. Voici le code simplifié...

$("$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 ! il fonctionne pour l'événement de clic:

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

});

je suggérerais le schéma suivant:

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>

...sauf si je suis en manque de quelque chose.

http://jsfiddle.net/DdvcX /

je pense que le" contraire " serait de simuler un événement. Vous pouvez utiliser .createEvent()

suivant L'exemple de Mozilla:

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 canceled = !cb.dispatchEvent(evt);
  if(canceled) {
    // A handler called preventDefault
    alert("canceled");
  } else {
    // None of the handlers called preventDefault
    alert("not canceled");
  }
}

Ref: document.createEvent

jQuery a .trigger() donc vous pouvez déclencher des événements sur des éléments -- parfois utile.

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

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

C'est ce que j'ai utilisé pour le définir:

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

et de le défaire:

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

jquery () pourrait être une autre solution à cette question. escpacially quand il s'agit de l'utilisation de namespaces .

jquery on () est juste la façon courante de lier les événements (au lieu de bind ()). off() est de les débiter. et lorsque vous utilisez un espace de noms, vous pouvez ajouter et supprimer plusieurs événements différents.

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

maintenant avec l'utilisation de namespace, vous pouvez ajouter plusieurs de ces événements et sont possibilité de les enlever, selon vos besoins.. bien que submit puisse ne pas être le meilleur exemple, cela peut s'avérer pratique sur un clic ou une touche ou n'importe quoi d'autre..

il n'y a pas de méthode opposée de event.preventDefault() pour comprendre pourquoi vous devez d'abord regarder dans ce que event.preventDefault() fait quand vous l'appelez.

sous le capot, la fonctionnalité de preventDefault appelle essentiellement un retour false qui arrête toute exécution ultérieure. Si vous êtes familier avec les anciennes méthodes de Javascript, il était une fois à la mode d'utiliser return false pour annuler des événements sur des choses comme les formulaires soumet et boutons en utilisant return true (avant jQuery a été même autour de vous).

comme vous avez probablement déjà travaillé sur la base de la simple explication ci-dessus: le contraire de event.preventDefault() n'est rien. Vous n'empêchez tout simplement pas l'événement, par défaut le navigateur autorisera l'événement si vous ne l'empêchez pas.

voir ci-dessous pour une explication:

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

dans le code ci-dessus, vous remarquerez que nous vérifions si allowSubmit est false. Cela signifie que nous allons empêcher notre formulaire de soumettre en utilisant event.preventDefault et puis nous allons faire un peu de logique de validation et si nous sommes heureux, définir allowSubmit à true.

C'est vraiment la seule méthode efficace de faire le contraire de event.preventDefault() – vous pouvez également essayer d'enlever événements qui, essentiellement, permettrait de réaliser la même chose.

voici quelque chose d'utile...

tout d'abord , nous cliquerons sur le lien, exécuterons du code, puis nous exécuterons l'action par défaut. Cela sera possible en utilisant l'événement .cible actuelle regardez. Ici, nous allons essayer D'accéder à Google sur un nouvel onglet, mais avant que nous avons besoin de lancer un peu de code.

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

vous pouvez utiliser cette méthode après "preventDefault

//Ici, evt.target return default event (par exemple : defult url etc)

var defaultEvent=evt.target;

/ / ici nous enregistrons l'événement par défaut ..

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

vous pouvez toujours utiliser ce attaché à un certain événement de clic dans votre script:

location.href = this.href;

exemple d'utilisation:

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

ce code m'a permis de Ré-instancier l'événement après que j'ai utilisé:

event.preventDefault(); to disable the event.


event.preventDefault = false;

j'ai utilisé le code suivant. Il fonctionne très bien pour moi.

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