Come forzare una convalida del modulo html5 senza inviarlo tramite jQuery


286

Ho questo modulo nella mia app e lo invierò tramite AJAX, ma voglio usare HTML5 per la convalida lato client. Quindi voglio essere in grado di forzare la convalida del modulo, forse tramite jQuery.

Voglio innescare la convalida senza inviare il modulo. È possibile?


Puoi specificare in quale momento desideri convalidare il modulo? Cosa attiva la convalida? Vuoi validare ogni campo quando l'utente digita, entra / esce dal campo, cambia valore?
Peter Pajchl,

6
Vorrei poter fare qualcosa del genere: $ ("# my_form"). TriggerHtml5Validation ()
razenha

Questa pagina potrebbe aiutare il collegamento
Dan Bray,

Puoi farlo senza jQuery. Vedi la mia soluzione
Dan Bray,

Risposte:


444

Per verificare se un determinato campo è valido, utilizzare:

$('#myField')[0].checkValidity(); // returns true/false

Per verificare se il modulo è valido, utilizzare:

$('#myForm')[0].checkValidity(); // returns true/false

Se si desidera visualizzare i messaggi di errore nativi di alcuni browser (come Chrome), purtroppo l'unico modo per farlo è inviare il modulo, in questo modo:

var $myForm = $('#myForm');

if(! $myForm[0].checkValidity()) {
  // If the form is invalid, submit it. The form won't actually submit;
  // this will just cause the browser to display the native HTML5 error messages.
  $myForm.find(':submit').click();
}

Spero che questo ti aiuti. Tieni presente che la convalida HTML5 non è supportata in tutti i browser.


1
Ho provato la tua soluzione, ma invia comunque il modulo quando viene eseguita la riga $ myForm.submit ().
Yashpal Singla,

27
Prova a sostituire $myForm.submit()con$myForm.find(':submit').click()
Abraham il

8
Abramo ha ragione. Devi effettivamente fare clic sul pulsante di invio (a livello di codice). La chiamata di $ myForm.submit () non attiverà la convalida.
Kevin Tighe,

75
Se il tuo modulo non ha un pulsante di invio, puoi falsificarne uno:$('<input type="submit">').hide().appendTo($myForm).click().remove();
philfreo

15
Questa risposta è molto utile per via del suggerimento checkValidity(), ma presenta anche un errore pericoloso. checkValidity()è ciò che attiva i messaggi di errore del browser nativo, non il clic sul pulsante Invia. Se hai un listener di eventi che ascolta il clic del pulsante di invio, lo attiverai quando esegui `$ myForm.find (': submit'). Click ()`, che si attiverà e causerà una ricorsione infinita.
Richiesta non

30

Ho trovato questa soluzione che funziona per me. Basta chiamare una funzione JavaScript come questa:

action="javascript:myFunction();"

Quindi hai la validazione html5 ... davvero semplice :-)


3
Questo ha funzionato anche per me e penso che questa sia la risposta migliore. Ho impostato action="javascript:0"l' evento <form>associato a e tutto ha funzionato alla grande. Tengo tutto JS fuori da HTML. può quindi testare per continuare. click<button>MyFunction()MyFunctionform.checkValidity()
orad,

3
Il codice di esempio è sempre utile.
BJ Patel,

10
Associare al modulo onsubmit()è quasi sempre meglio che associare a un pulsante onclick(), poiché esistono altri modi per inviare un modulo. (In particolare premendo la returnchiave.)
alttag

+1 Questo è fantastico. non più convalida del metodo javascript se il campo è vuoto o se si tratta di un'email. Il browser può farlo per noi! Questo browser è compatibile?
Jo E.

2
action="javascript:myFunction();"o action="javascript:0"opere più nell'ultimo Firefox (67). Funziona su Chrome però.
Bobz,

23
    if $("form")[0].checkValidity()
      $.ajax(
        url: "url"
        type: "post"
        data: {

        }
        dataType: "json"
        success: (data) ->

      )
    else
      #important
      $("form")[0].reportValidity()

da: convalida del modulo html5


4
reportValidityè supportato solo da Chrome 40.0
MM

Questo è CoffeeScript.
anfetamachina,

1
reportValidity ora è supportato da Firefox dalla versione 49
Giustino il

Mi piace questa parte $("form")[0].reportValidity(). Ho bisogno che nel caso in cui il controllo di validità fallisca.
fsevenm,

Grande! Grazie!
stefo91,


16

Ecco un modo più generale che è un po 'più pulito:

Crea il tuo modulo in questo modo (può essere un modulo fittizio che non fa nulla):

<form class="validateDontSubmit">
...

Associa tutti i moduli che non vuoi veramente inviare:

$(document).on('submit','.validateDontSubmit',function (e) {
    //prevent the form from doing a submit
    e.preventDefault();
    return false;
})

Ora supponiamo che tu abbia <a>(all'interno del <form>) che su clic vuoi convalidare il modulo:

$('#myLink').click(function(e){
  //Leverage the HTML5 validation w/ ajax. Have to submit to get em. Wont actually submit cuz form
  //has .validateDontSubmit class
  var $theForm = $(this).closest('form');
  //Some browsers don't implement checkValidity
  if (( typeof($theForm[0].checkValidity) == "function" ) && !$theForm[0].checkValidity()) {
     return;
  }

  //if you've gotten here - play on playa'
});

Alcune note qui:

  • Ho notato che non è necessario inviare effettivamente il modulo affinché avvenga la convalida: la chiamata a checkValidity()è sufficiente (almeno in Chrome). Se altri potessero aggiungere commenti testando questa teoria su altri browser, aggiornerò questa risposta.
  • La cosa che attiva la convalida non deve essere all'interno di <form>. Questo era solo un modo pulito e flessibile per avere una soluzione di uso generale.

12

Potrebbe essere in ritardo alla festa, ma in qualche modo ho trovato questa domanda mentre cercavo di risolvere un problema simile. Poiché nessun codice di questa pagina ha funzionato per me, nel frattempo ho trovato una soluzione che funziona come specificato.

Il problema è quando il tuo <form>DOM contiene un singolo <button>elemento, una volta attivato, che <button>riassumerà automaticamente il modulo. Se giochi con AJAX, probabilmente dovrai impedire l'azione predefinita. Ma c'è un problema: se lo fai, impedirai anche la convalida HTML5 di base. Pertanto, è consigliabile evitare impostazioni predefinite su quel pulsante solo se il modulo è valido. In caso contrario, la convalida HTML5 ti proteggerà dall'invio. jQuery checkValidity()ti aiuterà in questo:

jQuery:

$(document).ready(function() {
  $('#buttonID').on('click', function(event) {
    var isvalidate = $("#formID")[0].checkValidity();
    if (isvalidate) {
      event.preventDefault();
      // HERE YOU CAN PUT YOUR AJAX CALL
    }
  });
});

Il codice sopra descritto ti consentirà di utilizzare la convalida HTML5 di base (con corrispondenza di tipo e modello) SENZA modulo di invio.


6

Parli di due cose diverse "convalida HTML5" e convalida del modulo HTML usando javascript / jquery.

HTML5 "ha" opzioni integrate per la convalida di un modulo. Ad esempio l'uso dell'attributo "obbligatorio" su un campo, che potrebbe (in base all'implementazione del browser) non riuscire a inviare l'invio senza utilizzare javascript / jquery.

Con javascrip / jquery puoi fare qualcosa del genere

$('your_form_id').bind('submit', function() {
   // validate your form here
   return (valid) ? true : false;
});

2
Voglio innescare la convalida senza inviare il modulo.
razenha

Secondo il tuo aggiornamento, penso ancora che questa sia la soluzione corretta. Non hai specificato come vuoi attivare la triggerHtml5Validation()funzione. Il codice sopra riportato allega l'evento di invio al tuo modulo; all'invio intercetti l'evento e convalidi il modulo. Se non vuoi mai inviare il modulo, semplicemente return false;e l'invio non avverrà mai.
Peter Pajchl,

7
return (valid) ? true : false=== return valid. :)
Davi Koscianski Vidal il

1
Oops, ho fatto +1 su @davi perché all'inizio pensavo esattamente la stessa cosa. Ma non è proprio lo stesso, in quanto return validnon restituisce false per valori null / indefiniti. Ma non importa, la risposta era comunque lo pseudo-codice, il punto è: utilizzare return false per non inviare il modulo ^^
T_D

5
var $myForm = $('#myForm ');
if (!$myForm[0].checkValidity()) {
  $('<input type="submit">').hide().appendTo($myForm).click().remove();
}

non funziona su Chrome 74. Potrei far luce su di esso?
codexplorer,

3

Per controllare tutti i campi obbligatori del modulo senza utilizzare il pulsante Invia è possibile utilizzare la funzione seguente.

Devi assegnare l' attributo richiesto ai controlli.

  $("#btnSave").click(function () {
    $(":input[required]").each(function () {                     
        var myForm = $('#form1');
        if (!$myForm[0].checkValidity()) 
          {                
            $(myForm).submit();              
          }
        });
  });

3

Non è necessario jQuery per raggiungere questo obiettivo. Nel tuo modulo aggiungi:

onsubmit="return buttonSubmit(this)

o in JavaScript:

myform.setAttribute("onsubmit", "return buttonSubmit(this)");

Nella tua buttonSubmitfunzione (o come lo chiami), puoi inviare il modulo usando AJAX. buttonSubmitverrà chiamato solo se il modulo è convalidato in HTML5.

Se questo aiuta qualcuno, ecco la mia buttonSubmitfunzione:

function buttonSubmit(e)
{
    var ajax;
    var formData = new FormData();
    for (i = 0; i < e.elements.length; i++)
    {
        if (e.elements[i].type == "submit")
        {
            if (submitvalue == e.elements[i].value)
            {
                submit = e.elements[i];
                submit.disabled = true;
            }
        }
        else if (e.elements[i].type == "radio")
        {
            if (e.elements[i].checked)
                formData.append(e.elements[i].name, e.elements[i].value);
        }
        else
            formData.append(e.elements[i].name, e.elements[i].value);
    }
    formData.append("javascript", "javascript");
    var action = e.action;
    status = action.split('/').reverse()[0] + "-status";
    ajax = new XMLHttpRequest();
    ajax.addEventListener("load", manageLoad, false);
    ajax.addEventListener("error", manageError, false);
    ajax.open("POST", action);
    ajax.send(formData);
    return false;
}

Alcuni dei miei moduli contengono più pulsanti di invio, quindi questa riga if (submitvalue == e.elements[i].value). Ho impostato il valore submitvaluedell'utilizzo di un evento clic.


2

Ho avuto una situazione piuttosto complessa, in cui avevo bisogno di più pulsanti di invio per elaborare cose diverse. Ad esempio, Salva ed Elimina.

La base era che era anche discreto, quindi non potevo semplicemente renderlo un pulsante normale. Ma volevo anche utilizzare la validazione html5.

Inoltre l'evento di invio è stato ignorato nel caso in cui l'utente abbia premuto invio per attivare l'invio predefinito previsto; in questo esempio salva.

Ecco gli sforzi dell'elaborazione del modulo per continuare a lavorare con / senza javascript e con la convalida html5, con eventi di invio e clic.

Demo jsFiddle - Convalida HTML5 con sostituzioni di invio e clic

xHTML

<form>
    <input type="text" required="required" value="" placeholder="test" />
    <button type="submit" name="save">Save</button>
    <button type="submit" name="delete">Delete</button>
</form>

JavaScript

//wrap our script in an annonymous function so that it can not be affected by other scripts and does not interact with other scripts
//ensures jQuery is the only thing declared as $
(function($){
    var isValid = null;
    var form = $('form');
    var submitButton = form.find('button[type="submit"]')
    var saveButton = submitButton.filter('[name="save"]');
    var deleteButton = submitButton.filter('[name="delete"]');

    //submit form behavior
    var submitForm = function(e){
        console.log('form submit');
        //prevent form from submitting valid or invalid
        e.preventDefault();
        //user clicked and the form was not valid
        if(isValid === false){
            isValid = null;
            return false;
        }
        //user pressed enter, process as if they clicked save instead
        saveButton.trigger('click');
    };

    //override submit button behavior
    var submitClick = function(e){
        //Test form validitiy (HTML5) and store it in a global variable so both functions can use it
        isValid = form[0].checkValidity();
        if(false === isValid){
            //allow the browser's default submit event behavior 
            return true;
        }
        //prevent default behavior
        e.preventDefault();
        //additional processing - $.ajax() etc
        //.........
        alert('Success');
    };

    //override submit form event
    form.submit(submitForm);

    //override submit button click event
    submitButton.click(submitClick);
})(jQuery);

L'avvertenza nell'uso di Javascript è che il clic predefinito del browser deve propagarsi all'evento di invio DEVE verificarsi per visualizzare i messaggi di errore senza supportare ciascun browser nel codice. Altrimenti se l'evento click viene sovrascritto con event.preventDefault () o restituisce false, non si propagherà mai all'evento di invio del browser.

La cosa da sottolineare è che in alcuni browser non attiverà l'invio del modulo quando l'utente preme invio, invece attiverà il primo pulsante di invio nel modulo. Quindi c'è un console.log ('form submit') per mostrare che non si innesca.


Siamo consapevoli che ciò potrebbe essere fatto senza jQuery, ma OP ha creato il titolo di questo argomento: "Come forzare una convalida del modulo html5 senza inviarlo tramite jQuery", suggerendo esplicitamente che jQuery deve essere utilizzato.
vzr

@vzr La mia risposta usa jQueryesplicitamente. Differisce dal fatto che gestisce l'elaborazione della convalida HTML5 con più pulsanti di invio e impedisce l'invio del modulo AJAX quando non è valido. L'impostazione predefinita savedell'azione quando l'utente preme il entertasto sulla tastiera. Che al momento della mia pubblicazione nessuna delle risposte fornite era una soluzione per più pulsanti di invio o l'acquisizione della chiave di invio per impedire l'invio di Ajax.
Fyrye,

2

Puoi farlo senza inviare il modulo.

Ad esempio, se il pulsante di invio del modulo con ID "cerca" si trova nell'altro modulo. Puoi chiamare l'evento click su quel pulsante di invio e chiamare ev.preventDefault successivamente. Per il mio caso, convalido il modulo B dalla presentazione del modulo A. Come questo

function validateFormB(ev){ // DOM Event object
  //search is in Form A
  $("#search").click();
  ev.preventDefault();
  //Form B validation from here on
}

2

In questo modo funziona bene per me:

  1. Aggiungi l' onSubmitattributo nel tuo form, non dimenticare di includerlo returnnel valore.

    <form id='frm-contact' method='POST' action='' onSubmit="return contact()">
  2. Definire la funzione

    function contact(params) {
        $.ajax({
            url: 'sendmail.php',
            type: "POST",
            dataType: "json",
            timeout: 5000,
            data: { params:params },
            success: function (data, textStatus, jqXHR) {
                // callback
            },
            error: function(jqXHR, textStatus, errorThrown) {
                console.log(jqXHR.responseText);
            }
        });
    
        return false;
    }

1
$("#form").submit(function() { $("#saveButton").attr("disabled", true); });

non è una risposta migliore ma funziona per me.


1

So che è già stata data una risposta, ma ho un'altra possibile soluzione.

Se si utilizza jquery, è possibile farlo.

Innanzitutto crea un paio di estensioni su jquery in modo da poterle riutilizzare secondo necessità.

$.extend({
    bypassDefaultSubmit: function (formName, newSubmitMethod) {
        $('#'+formName).submit(function (event) {
            newSubmitMethod();
            event.preventDefault();
        }
    }
});

Quindi fai qualcosa del genere dove vuoi usarlo.

<script type="text/javascript">
    /*if you want to validate the form on a submit call, 
      and you never want the form to be submitted via
      a normal submit operation, or maybe you want handle it.
    */
    $(function () {
        $.bypassDefaultSubmit('form1', submit);
    });
    function submit(){ 
        //do something, or nothing if you just want the validation
    }

</script>

1
$(document).on("submit", false);

submitButton.click(function(e) {
    if (form.checkValidity()) {
        form.submit();
    }
});

$ (documento) .on ("submit", false); // questo ha funzionato perfettamente, questo è quello che stavo cercando :)
Akshay Shrivastav

1

Questo ha funzionato da me per visualizzare i messaggi di errore HTML 5 nativi con la convalida del modulo.

<button id="btnRegister" class="btn btn-success btn btn-lg" type="submit"> Register </button>



$('#RegForm').on('submit', function () 
{

if (this.checkValidity() == false) 
{

 // if form is not valid show native error messages 

return false;

}
else
{

 // if form is valid , show please wait message and disable the button

 $("#btnRegister").html("<i class='fa fa-spinner fa-spin'></i> Please Wait...");

 $(this).find(':submit').attr('disabled', 'disabled');

}


});

Nota: RegForm è ilform id .

Riferimento

La speranza aiuta qualcuno.


devi aggiungere un evento per abilitare il pulsante di invio disabilitato
talsibony,

1

Questo è un modo piuttosto semplice per far sì che HTML5 esegua la convalida per qualsiasi modulo, pur mantenendo il controllo JS moderno sul modulo. L'unica avvertenza è che il pulsante di invio deve trovarsi all'interno di <form>.

html

<form id="newUserForm" name="create">
Email<input type="email" name="username" id="username" size="25" required>
Phone<input type="tel" id="phone" name="phone" pattern="(?:\(\d{3}\)|\d{3})[- ]?\d{3}[- ]?\d{4}" size="12" maxlength="12" required>
<input id="submit" type="submit" value="Create Account" >
</form>

js

// bind in ready() function
jQuery( "#submit" ).click( newAcctSubmit );

function newAcctSubmit()
{
  var myForm = jQuery( "#newUserForm" );

  // html 5 is doing the form validation for us,
  // so no need here (but backend will need to still for security)
  if ( ! myForm[0].checkValidity() )
  {
    // bonk! failed to validate, so return true which lets the
    // browser show native validation messages to the user
    return true;
  }

  // post form with jQuery or whatever you want to do with a valid form!
  var formVars = myForm.serialize();
  etc...
}

0

Penso che l'approccio migliore

utilizzerà il plug-in di convalida jQuery che utilizza le migliori pratiche per la convalida dei moduli e ha anche un buon supporto per il browser. Quindi non devi preoccuparti di problemi di compatibilità del browser.

E possiamo usare la funzione valid () validation di jQuery che controlla se il modulo selezionato è valido o se tutti gli elementi selezionati sono validi senza inviare il modulo.

<form id="myform">
   <input type="text" name="name" required>
   <br>
   <button type="button">Validate!</button>
</form>
<script>
  var form = $( "#myform" );
  form.validate();
  $( "button" ).click(function() {
    console.log( "Valid: " + form.valid() );
  });
</script>

0

Secondo la domanda, la validità di html5 dovrebbe essere validata usando jQuery all'inizio e nella maggior parte della risposta ciò non sta accadendo e la ragione di ciò è la seguente:

durante la convalida utilizzando la funzione predefinita del modulo html5

checkValidity();// returns true/false

dobbiamo capire che jQuery restituisce array di oggetti, selezionando in questo modo

$("#myForm")

pertanto, è necessario specificare il primo indice per far funzionare la funzione checkValidity ()

$('#myForm')[0].checkValidity()

ecco la soluzione completa:

<button type="button" name="button" onclick="saveData()">Save</button>

function saveData()
{
    if($('#myForm')[0].checkValidity()){
        $.ajax({
          type: "POST",
          url: "save.php",
          data: data,
          success: function(resp){console.log("Response: "+resp);}
        });
    }
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.