¿Qué es lo contrario de evt.preventDefault ();

Una vez que haya disparado evt.preventDefault(), ¿cómo puedo reanudar las acciones predeterminadas nuevamente?

Según lo comentado por @Prescott, lo contrario de:

evt.preventDefault();

Podría ser:

Esencialmente equivale a 'hacer predeterminado' , ya que ya no lo estamos evitando.

De lo contrario, me inclino a señalar las respuestas proporcionadas por otros comentarios y respuestas:

¿Cómo desvincular un escucha que está llamando a event.preventDefault () (usando jQuery)?

¿Cómo volver a habilitar event.preventDefault?

Tenga en cuenta que el segundo ha sido aceptado con una solución de ejemplo, dada por redsquare (publicado aquí para una solución directa en caso de que esto no se cierre como duplicado):

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

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

y su opuesto

function(evt) {return true;}

¡salud!

Para procesar un comando antes de continuar un enlace desde un clickevento en jQuery:

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

Prevenir y seguir con 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");
    }
});

O simplemente correr window.location = this.href;tras elpreventDefault();

Tuve que retrasar el envío de un formulario en jQuery para ejecutar una llamada asincrónica. Aquí está el código simplificado ...

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

OKAY ! funciona para el evento click:

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

y su opuesto (estándar):

event.returnValue = true;

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

Sugeriría el siguiente patrón:

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>

... a menos que me falte algo.

http://jsfiddle.net/DdvcX/

No hay un método opuesto event.preventDefault()para entender por qué primero tienes que mirar qué event.preventDefault()hace cuando lo llamas.

Debajo del capó, la funcionalidad para preventDefault es esencialmente llamar a un retorno falso que detiene cualquier ejecución posterior. Si está familiarizado con las viejas formas de Javascript, alguna vez estuvo de moda usar return false para cancelar eventos en cosas como envíos de formularios y botones usando return true (incluso antes de que jQuery existiera).

Como probablemente ya haya trabajado en base a la explicación simple anterior: lo contrario de event.preventDefault()es nada. Simplemente no evita el evento, de forma predeterminada el navegador lo permitirá si no lo está evitando.

Vea a continuación una explicación:

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

En el código anterior, notará que estamos verificando si allowSubmit es falso. Esto significa que event.preventDefaultevitaremos que nuestro formulario se envíe usando y luego haremos alguna lógica de validación y, si estamos contentos, establezca allowSubmit en verdadero.

Este es realmente el único método efectivo para hacer lo contrario event.preventDefault(): también puede intentar eliminar eventos que esencialmente lograrían lo mismo.

Aquí hay algo útil ...

En primer lugar, haremos clic en el enlace, ejecutaremos un código y luego realizaremos una acción predeterminada. Esto será posible usando event.currentTarget Echa un vistazo. Aquí intentaremos acceder a Google en una nueva pestaña, pero antes de que necesitemos ejecutar algún código.

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

Esto es lo que solía configurarlo:

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

Y para deshacerlo:

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

Ninguna de las soluciones me ayudó aquí e hice esto para resolver mi situación.

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

Y la función 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();
}

Supongo que lo "opuesto" sería simular un evento. Podrías usar.createEvent()

Siguiendo el ejemplo 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 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

jQuery tiene .trigger()para que pueda desencadenar eventos en elementos, a veces útiles.

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

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

jquery on () podría ser otra solución para esto. especialmente cuando se trata del uso de espacios de nombres .

jquery on () es solo la forma actual de vincular eventos (en lugar de bind ()). off () es desvincular estos. y cuando usa un espacio de nombres, puede agregar y eliminar múltiples eventos diferentes.

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

ahora con el uso del espacio de nombres, puede agregar varios de estos eventos y puede eliminarlos, según sus necesidades.

Esta no es una respuesta directa a la pregunta, pero puede ayudar a alguien. Mi punto es que solo llama a preventDefault () en función de algunas condiciones, ya que no tiene sentido tener un evento si llama a preventDefault () para todos los casos. Por lo tanto, tener condiciones if y llamar a preventDefault () solo cuando se cumplan las condiciones funcionará la función de la manera habitual para los otros casos.

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

});

puede usar esto después del método "preventDefault"

// Aquí evt.target return evento predeterminado (por ejemplo: url defult, etc.)

var defaultEvent=evt.target;

// Aquí guardamos el evento predeterminado ...

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

Siempre puede usar esto adjunto a algún evento de clic en su script:

location.href = this.href;

ejemplo de uso es:

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

este código me funcionó para volver a crear una instancia del evento después de haber usado:

event.preventDefault(); to disable the event.


event.preventDefault = false;

He usado el siguiente código. Funciona bien para mí.

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