jQuery validate 及自定义验证规则

﹏ヽ暗。殇╰゛Y 2022-05-22 12:56 716阅读 0赞

jQuery validate.js

  1. /*!
  2.  * jQuery Validation Plugin v1.14.0
  3.  *
  4.  * http://jqueryvalidation.org/
  5.  *
  6.  * Copyright (c) 2015 Jörn Zaefferer
  7.  * Released under the MIT license
  8.  */
  9. (function( factory ) {
  10.     if ( typeof define === "function" && define.amd ) {
  11.         define( ["jquery"], factory );
  12.     } else {
  13.         factory( jQuery );
  14.     }
  15. }(function( $ ) {
  17. $.extend($.fn, {
  18.     // http://jqueryvalidation.org/validate/
  19.     validate: function( options ) {
  21.         // if nothing is selected, return nothing; can't chain anyway
  22.         if ( !this.length ) {
  23.             if ( options && options.debug && window.console ) {
  24.                 console.warn( "Nothing selected, can't validate, returning nothing." );
  25.             }
  26.             return;
  27.         }
  29.         // check if a validator for this form was already created
  30.         var validator = $.data( this[ 0 ], "validator" );
  31.         if ( validator ) {
  32.             return validator;
  33.         }
  35.         // Add novalidate tag if HTML5.
  36.         this.attr( "novalidate", "novalidate" );
  38.         validator = new $.validator( options, this[ 0 ] );
  39.         $.data( this[ 0 ], "validator", validator );
  41.         if ( validator.settings.onsubmit ) {
  43.             this.on( "click.validate", ":submit", function( event ) {
  44.                 if ( validator.settings.submitHandler ) {
  45.                     validator.submitButton = event.target;
  46.                 }
  48.                 // allow suppressing validation by adding a cancel class to the submit button
  49.                 if ( $( this ).hasClass( "cancel" ) ) {
  50.                     validator.cancelSubmit = true;
  51.                 }
  53.                 // allow suppressing validation by adding the html5 formnovalidate attribute to the submit button
  54.                 if ( $( this ).attr( "formnovalidate" ) !== undefined ) {
  55.                     validator.cancelSubmit = true;
  56.                 }
  57.             });
  59.             // validate the form on submit
  60.             this.on( "submit.validate", function( event ) {
  61.                 if ( validator.settings.debug ) {
  62.                     // prevent form submit to be able to see console output
  63.                     event.preventDefault();
  64.                 }
  65.                 function handle() {
  66.                     var hidden, result;
  67.                     if ( validator.settings.submitHandler ) {
  68.                         if ( validator.submitButton ) {
  69.                             // insert a hidden input as a replacement for the missing submit button
  70.                             hidden = $( "<input type='hidden'/>" )
  71.                                 .attr( "name", validator.submitButton.name )
  72.                                 .val( $( validator.submitButton ).val() )
  73.                                 .appendTo( validator.currentForm );
  74.                         }
  75.                         result = validator.settings.submitHandler.call( validator, validator.currentForm, event );
  76.                         if ( validator.submitButton ) {
  77.                             // and clean up afterwards; thanks to no-block-scope, hidden can be referenced
  78.                             hidden.remove();
  79.                         }
  80.                         if ( result !== undefined ) {
  81.                             return result;
  82.                         }
  83.                         return false;
  84.                     }
  85.                     return true;
  86.                 }
  88.                 // prevent submit for invalid forms or custom submit handlers
  89.                 if ( validator.cancelSubmit ) {
  90.                     validator.cancelSubmit = false;
  91.                     return handle();
  92.                 }
  93.                 if ( validator.form() ) {
  94.                     if ( validator.pendingRequest ) {
  95.                         validator.formSubmitted = true;
  96.                         return false;
  97.                     }
  98.                     return handle();
  99.                 } else {
  100.                     validator.focusInvalid();
  101.                     return false;
  102.                 }
  103.             });
  104.         }
  106.         return validator;
  107.     },
  108.     // http://jqueryvalidation.org/valid/
  109.     valid: function() {
  110.         var valid, validator, errorList;
  112.         if ( $( this[ 0 ] ).is( "form" ) ) {
  113.             valid = this.validate().form();
  114.         } else {
  115.             errorList = [];
  116.             valid = true;
  117.             validator = $( this[ 0 ].form ).validate();
  118.             this.each( function() {
  119.                 valid = validator.element( this ) && valid;
  120.                 errorList = errorList.concat( validator.errorList );
  121.             });
  122.             validator.errorList = errorList;
  123.         }
  124.         return valid;
  125.     },
  127.     // http://jqueryvalidation.org/rules/
  128.     rules: function( command, argument ) {
  129.         var element = this[ 0 ],
  130.             settings, staticRules, existingRules, data, param, filtered;
  132.         if ( command ) {
  133.             settings = $.data( element.form, "validator" ).settings;
  134.             staticRules = settings.rules;
  135.             existingRules = $.validator.staticRules( element );
  136.             switch ( command ) {
  137.             case "add":
  138.                 $.extend( existingRules, $.validator.normalizeRule( argument ) );
  139.                 // remove messages from rules, but allow them to be set separately
  140.                 delete existingRules.messages;
  141.                 staticRules[ element.name ] = existingRules;
  142.                 if ( argument.messages ) {
  143.                     settings.messages[ element.name ] = $.extend( settings.messages[ element.name ], argument.messages );
  144.                 }
  145.                 break;
  146.             case "remove":
  147.                 if ( !argument ) {
  148.                     delete staticRules[ element.name ];
  149.                     return existingRules;
  150.                 }
  151.                 filtered = {};
  152.                 $.each( argument.split( /\s/ ), function( index, method ) {
  153.                     filtered[ method ] = existingRules[ method ];
  154.                     delete existingRules[ method ];
  155.                     if ( method === "required" ) {
  156.                         $( element ).removeAttr( "aria-required" );
  157.                     }
  158.                 });
  159.                 return filtered;
  160.             }
  161.         }
  163.         data = $.validator.normalizeRules(
  164.         $.extend(
  165.             {},
  166.             $.validator.classRules( element ),
  167.             $.validator.attributeRules( element ),
  168.             $.validator.dataRules( element ),
  169.             $.validator.staticRules( element )
  170.         ), element );
  172.         // make sure required is at front
  173.         if ( data.required ) {
  174.             param = data.required;
  175.             delete data.required;
  176.             data = $.extend( { required: param }, data );
  177.             $( element ).attr( "aria-required", "true" );
  178.         }
  180.         // make sure remote is at back
  181.         if ( data.remote ) {
  182.             param = data.remote;
  183.             delete data.remote;
  184.             data = $.extend( data, { remote: param });
  185.         }
  187.         return data;
  188.     }
  189. });
  191. // Custom selectors
  192. $.extend( $.expr[ ":" ], {
  193.     // http://jqueryvalidation.org/blank-selector/
  194.     blank: function( a ) {
  195.         return !$.trim( "" + $( a ).val() );
  196.     },
  197.     // http://jqueryvalidation.org/filled-selector/
  198.     filled: function( a ) {
  199.         return !!$.trim( "" + $( a ).val() );
  200.     },
  201.     // http://jqueryvalidation.org/unchecked-selector/
  202.     unchecked: function( a ) {
  203.         return !$( a ).prop( "checked" );
  204.     }
  205. });
  207. // constructor for validator
  208. $.validator = function( options, form ) {
  209.     this.settings = $.extend( true, {}, $.validator.defaults, options );
  210.     this.currentForm = form;
  211.     this.init();
  212. };
  214. // http://jqueryvalidation.org/jQuery.validator.format/
  215. $.validator.format = function( source, params ) {
  216.     if ( arguments.length === 1 ) {
  217.         return function() {
  218.             var args = $.makeArray( arguments );
  219.             args.unshift( source );
  220.             return $.validator.format.apply( this, args );
  221.         };
  222.     }
  223.     if ( arguments.length > 2 && params.constructor !== Array  ) {
  224.         params = $.makeArray( arguments ).slice( 1 );
  225.     }
  226.     if ( params.constructor !== Array ) {
  227.         params = [ params ];
  228.     }
  229.     $.each( params, function( i, n ) {
  230.         source = source.replace( new RegExp( "\\{" + i + "\\}", "g" ), function() {
  231.             return n;
  232.         });
  233.     });
  234.     return source;
  235. };
  237. $.extend( $.validator, {
  239.     defaults: {
  240.         messages: {},
  241.         groups: {},
  242.         rules: {},
  243.         errorClass: "error",
  244.         validClass: "valid",
  245.         errorElement: "label",
  246.         focusCleanup: false,
  247.         focusInvalid: true,
  248.         errorContainer: $( [] ),
  249.         errorLabelContainer: $( [] ),
  250.         onsubmit: true,
  251.         ignore: ":hidden",
  252.         ignoreTitle: false,
  253.         onfocusin: function( element ) {
  254.             this.lastActive = element;
  256.             // Hide error label and remove error class on focus if enabled
  257.             if ( this.settings.focusCleanup ) {
  258.                 if ( this.settings.unhighlight ) {
  259.                     this.settings.unhighlight.call( this, element, this.settings.errorClass, this.settings.validClass );
  260.                 }
  261.                 this.hideThese( this.errorsFor( element ) );
  262.             }
  263.         },
  264.         onfocusout: function( element ) {
  265.             if ( !this.checkable( element ) && ( element.name in this.submitted || !this.optional( element ) ) ) {
  266.                 this.element( element );
  267.             }
  268.         },
  269.         onkeyup: function( element, event ) {
  270.             // Avoid revalidate the field when pressing one of the following keys
  271.             // Shift       => 16
  272.             // Ctrl        => 17
  273.             // Alt         => 18
  274.             // Caps lock   => 20
  275.             // End         => 35
  276.             // Home        => 36
  277.             // Left arrow  => 37
  278.             // Up arrow    => 38
  279.             // Right arrow => 39
  280.             // Down arrow  => 40
  281.             // Insert      => 45
  282.             // Num lock    => 144
  283.             // AltGr key   => 225
  284.             var excludedKeys = [
  285.                 16, 17, 18, 20, 35, 36, 37,
  286.                 38, 39, 40, 45, 144, 225
  287.             ];
  289.             if ( event.which === 9 && this.elementValue( element ) === "" || $.inArray( event.keyCode, excludedKeys ) !== -1 ) {
  290.                 return;
  291.             } else if ( element.name in this.submitted || element === this.lastElement ) {
  292.                 this.element( element );
  293.             }
  294.         },
  295.         onclick: function( element ) {
  296.             // click on selects, radiobuttons and checkboxes
  297.             if ( element.name in this.submitted ) {
  298.                 this.element( element );
  300.             // or option elements, check parent select in that case
  301.             } else if ( element.parentNode.name in this.submitted ) {
  302.                 this.element( element.parentNode );
  303.             }
  304.         },
  305.         highlight: function( element, errorClass, validClass ) {
  306.             if ( element.type === "radio" ) {
  307.                 this.findByName( element.name ).addClass( errorClass ).removeClass( validClass );
  308.             } else {
  309.                 $( element ).addClass( errorClass ).removeClass( validClass );
  310.             }
  311.         },
  312.         unhighlight: function( element, errorClass, validClass ) {
  313.             if ( element.type === "radio" ) {
  314.                 this.findByName( element.name ).removeClass( errorClass ).addClass( validClass );
  315.             } else {
  316.                 $( element ).removeClass( errorClass ).addClass( validClass );
  317.             }
  318.         }
  319.     },
  321.     // http://jqueryvalidation.org/jQuery.validator.setDefaults/
  322.     setDefaults: function( settings ) {
  323.         $.extend( $.validator.defaults, settings );
  324.     },
  326.     messages: {
  327.         required: "This field is required.",
  328.         remote: "Please fix this field.",
  329.         email: "Please enter a valid email address.",
  330.         url: "Please enter a valid URL.",
  331.         date: "Please enter a valid date.",
  332.         dateISO: "Please enter a valid date ( ISO ).",
  333.         number: "Please enter a valid number.",
  334.         digits: "Please enter only digits.",
  335.         creditcard: "Please enter a valid credit card number.",
  336.         equalTo: "Please enter the same value again.",
  337.         maxlength: $.validator.format( "Please enter no more than {0} characters." ),
  338.         minlength: $.validator.format( "Please enter at least {0} characters." ),
  339.         rangelength: $.validator.format( "Please enter a value between {0} and {1} characters long." ),
  340.         range: $.validator.format( "Please enter a value between {0} and {1}." ),
  341.         max: $.validator.format( "Please enter a value less than or equal to {0}." ),
  342.         min: $.validator.format( "Please enter a value greater than or equal to {0}." )
  343.     },
  345.     autoCreateRanges: false,
  347.     prototype: {
  349.         init: function() {
  350.             this.labelContainer = $( this.settings.errorLabelContainer );
  351.             this.errorContext = this.labelContainer.length && this.labelContainer || $( this.currentForm );
  352.             this.containers = $( this.settings.errorContainer ).add( this.settings.errorLabelContainer );
  353.             this.submitted = {};
  354.             this.valueCache = {};
  355.             this.pendingRequest = 0;
  356.             this.pending = {};
  357.             this.invalid = {};
  358.             this.reset();
  360.             var groups = ( this.groups = {} ),
  361.                 rules;
  362.             $.each( this.settings.groups, function( key, value ) {
  363.                 if ( typeof value === "string" ) {
  364.                     value = value.split( /\s/ );
  365.                 }
  366.                 $.each( value, function( index, name ) {
  367.                     groups[ name ] = key;
  368.                 });
  369.             });
  370.             rules = this.settings.rules;
  371.             $.each( rules, function( key, value ) {
  372.                 rules[ key ] = $.validator.normalizeRule( value );
  373.             });
  375.             function delegate( event ) {
  376.                 var validator = $.data( this.form, "validator" );
  377.                 if ( !validator ) {
  378.                     validator = new $.validator( {}, this.form );
  379.                     $.data( this.form, "validator", validator );
  380.                 }
  381.                 var    eventType = "on" + event.type.replace( /^validate/, "" ),
  382.                     settings = validator.settings;
  383.                 if ( settings[ eventType ] && !$( this ).is( settings.ignore ) ) {
  384.                     settings[ eventType ].call( validator, this, event );
  385.                 }
  386.             }
  388.             $( this.currentForm )
  389.                 .on( "focusin.validate focusout.validate keyup.validate",
  390.                     ":text, [type='password'], [type='file'], select, textarea, [type='number'], [type='search'], " +
  391.                     "[type='tel'], [type='url'], [type='email'], [type='datetime'], [type='date'], [type='month'], " +
  392.                     "[type='week'], [type='time'], [type='datetime-local'], [type='range'], [type='color'], " +
  393.                     "[type='radio'], [type='checkbox']", delegate)
  394.                 // Support: Chrome, oldIE
  395.                 // "select" is provided as event.target when clicking a option
  396.                 .on("click.validate", "select, option, [type='radio'], [type='checkbox']", delegate);
  398.             if ( this.settings.invalidHandler ) {
  399.                 $( this.currentForm ).on( "invalid-form.validate", this.settings.invalidHandler );
  400.             }
  402.             // Add aria-required to any Static/Data/Class required fields before first validation
  403.             // Screen readers require this attribute to be present before the initial submission http://www.w3.org/TR/WCAG-TECHS/ARIA2.html
  404.             $( this.currentForm ).find( "[required], [data-rule-required], .required" ).attr( "aria-required", "true" );
  405.         },
  407.         // http://jqueryvalidation.org/Validator.form/
  408.         form: function() {
  409.             this.checkForm();
  410.             $.extend( this.submitted, this.errorMap );
  411.             this.invalid = $.extend({}, this.errorMap );
  412.             if ( !this.valid() ) {
  413.                 $( this.currentForm ).triggerHandler( "invalid-form", [ this ]);
  414.             }
  415.             this.showErrors();
  416.             return this.valid();
  417.         },
  419.         checkForm: function() {
  420.             this.prepareForm();
  421.             for ( var i = 0, elements = ( this.currentElements = this.elements() ); elements[ i ]; i++ ) {
  422.                 this.check( elements[ i ] );
  423.             }
  424.             return this.valid();
  425.         },
  427.         // http://jqueryvalidation.org/Validator.element/
  428.         element: function( element ) {
  429.             var cleanElement = this.clean( element ),
  430.                 checkElement = this.validationTargetFor( cleanElement ),
  431.                 result = true;
  433.             this.lastElement = checkElement;
  435.             if ( checkElement === undefined ) {
  436.                 delete this.invalid[ cleanElement.name ];
  437.             } else {
  438.                 this.prepareElement( checkElement );
  439.                 this.currentElements = $( checkElement );
  441.                 result = this.check( checkElement ) !== false;
  442.                 if ( result ) {
  443.                     delete this.invalid[ checkElement.name ];
  444.                 } else {
  445.                     this.invalid[ checkElement.name ] = true;
  446.                 }
  447.             }
  448.             // Add aria-invalid status for screen readers
  449.             $( element ).attr( "aria-invalid", !result );
  451.             if ( !this.numberOfInvalids() ) {
  452.                 // Hide error containers on last error
  453.                 this.toHide = this.toHide.add( this.containers );
  454.             }
  455.             this.showErrors();
  456.             return result;
  457.         },
  459.         // http://jqueryvalidation.org/Validator.showErrors/
  460.         showErrors: function( errors ) {
  461.             if ( errors ) {
  462.                 // add items to error list and map
  463.                 $.extend( this.errorMap, errors );
  464.                 this.errorList = [];
  465.                 for ( var name in errors ) {
  466.                     this.errorList.push({
  467.                         message: errors[ name ],
  468.                         element: this.findByName( name )[ 0 ]
  469.                     });
  470.                 }
  471.                 // remove items from success list
  472.                 this.successList = $.grep( this.successList, function( element ) {
  473.                     return !( element.name in errors );
  474.                 });
  475.             }
  476.             if ( this.settings.showErrors ) {
  477.                 this.settings.showErrors.call( this, this.errorMap, this.errorList );
  478.             } else {
  479.                 this.defaultShowErrors();
  480.             }
  481.         },
  483.         // http://jqueryvalidation.org/Validator.resetForm/
  484.         resetForm: function() {
  485.             if ( $.fn.resetForm ) {
  486.                 $( this.currentForm ).resetForm();
  487.             }
  488.             this.submitted = {};
  489.             this.lastElement = null;
  490.             this.prepareForm();
  491.             this.hideErrors();
  492.             var i, elements = this.elements()
  493.                 .removeData( "previousValue" )
  494.                 .removeAttr( "aria-invalid" );
  496.             if ( this.settings.unhighlight ) {
  497.                 for ( i = 0; elements[ i ]; i++ ) {
  498.                     this.settings.unhighlight.call( this, elements[ i ],
  499.                         this.settings.errorClass, "" );
  500.                 }
  501.             } else {
  502.                 elements.removeClass( this.settings.errorClass );
  503.             }
  504.         },
  506.         numberOfInvalids: function() {
  507.             return this.objectLength( this.invalid );
  508.         },
  510.         objectLength: function( obj ) {
  511.             /* jshint unused: false */
  512.             var count = 0,
  513.                 i;
  514.             for ( i in obj ) {
  515.                 count++;
  516.             }
  517.             return count;
  518.         },
  520.         hideErrors: function() {
  521.             this.hideThese( this.toHide );
  522.         },
  524.         hideThese: function( errors ) {
  525.             errors.not( this.containers ).text( "" );
  526.             this.addWrapper( errors ).hide();
  527.         },
  529.         valid: function() {
  530.             return this.size() === 0;
  531.         },
  533.         size: function() {
  534.             return this.errorList.length;
  535.         },
  537.         focusInvalid: function() {
  538.             if ( this.settings.focusInvalid ) {
  539.                 try {
  540.                     $( this.findLastActive() || this.errorList.length && this.errorList[ 0 ].element || [])
  541.                     .filter( ":visible" )
  542.                     .focus()
  543.                     // manually trigger focusin event; without it, focusin handler isn't called, findLastActive won't have anything to find
  544.                     .trigger( "focusin" );
  545.                 } catch ( e ) {
  546.                     // ignore IE throwing errors when focusing hidden elements
  547.                 }
  548.             }
  549.         },
  551.         findLastActive: function() {
  552.             var lastActive = this.lastActive;
  553.             return lastActive && $.grep( this.errorList, function( n ) {
  554.                 return n.element.name === lastActive.name;
  555.             }).length === 1 && lastActive;
  556.         },
  558.         elements: function() {
  559.             var validator = this,
  560.                 rulesCache = {};
  562.             // select all valid inputs inside the form (no submit or reset buttons)
  563.             return $( this.currentForm )
  564.             .find( "input, select, textarea" )
  565.             .not( ":submit, :reset, :image, :disabled" )
  566.             .not( this.settings.ignore )
  567.             .filter( function() {
  568.                 if ( !this.name && validator.settings.debug && window.console ) {
  569.                     console.error( "%o has no name assigned", this );
  570.                 }
  572.                 // select only the first element for each name, and only those with rules specified
  573.                 if ( this.name in rulesCache || !validator.objectLength( $( this ).rules() ) ) {
  574.                     return false;
  575.                 }
  577.                 rulesCache[ this.name ] = true;
  578.                 return true;
  579.             });
  580.         },
  582.         clean: function( selector ) {
  583.             return $( selector )[ 0 ];
  584.         },
  586.         errors: function() {
  587.             var errorClass = this.settings.errorClass.split( " " ).join( "." );
  588.             return $( this.settings.errorElement + "." + errorClass, this.errorContext );
  589.         },
  591.         reset: function() {
  592.             this.successList = [];
  593.             this.errorList = [];
  594.             this.errorMap = {};
  595.             this.toShow = $( [] );
  596.             this.toHide = $( [] );
  597.             this.currentElements = $( [] );
  598.         },
  600.         prepareForm: function() {
  601.             this.reset();
  602.             this.toHide = this.errors().add( this.containers );
  603.         },
  605.         prepareElement: function( element ) {
  606.             this.reset();
  607.             this.toHide = this.errorsFor( element );
  608.         },
  610.         elementValue: function( element ) {
  611.             var val,
  612.                 $element = $( element ),
  613.                 type = element.type;
  615.             if ( type === "radio" || type === "checkbox" ) {
  616.                 return this.findByName( element.name ).filter(":checked").val();
  617.             } else if ( type === "number" && typeof element.validity !== "undefined" ) {
  618.                 return element.validity.badInput ? false : $element.val();
  619.             }
  621.             val = $element.val();
  622.             if ( typeof val === "string" ) {
  623.                 return val.replace(/\r/g, "" );
  624.             }
  625.             return val;
  626.         },
  628.         check: function( element ) {
  629.             element = this.validationTargetFor( this.clean( element ) );
  631.             var rules = $( element ).rules(),
  632.                 rulesCount = $.map( rules, function( n, i ) {
  633.                     return i;
  634.                 }).length,
  635.                 dependencyMismatch = false,
  636.                 val = this.elementValue( element ),
  637.                 result, method, rule;
  639.             for ( method in rules ) {
  640.                 rule = { method: method, parameters: rules[ method ] };
  641.                 try {
  643.                     result = $.validator.methods[ method ].call( this, val, element, rule.parameters );
  645.                     // if a method indicates that the field is optional and therefore valid,
  646.                     // don't mark it as valid when there are no other rules
  647.                     if ( result === "dependency-mismatch" && rulesCount === 1 ) {
  648.                         dependencyMismatch = true;
  649.                         continue;
  650.                     }
  651.                     dependencyMismatch = false;
  653.                     if ( result === "pending" ) {
  654.                         this.toHide = this.toHide.not( this.errorsFor( element ) );
  655.                         return;
  656.                     }
  658.                     if ( !result ) {
  659.                         this.formatAndAdd( element, rule );
  660.                         return false;
  661.                     }
  662.                 } catch ( e ) {
  663.                     if ( this.settings.debug && window.console ) {
  664.                         console.log( "Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method.", e );
  665.                     }
  666.                     if ( e instanceof TypeError ) {
  667.                         e.message += ".  Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method.";
  668.                     }
  670.                     throw e;
  671.                 }
  672.             }
  673.             if ( dependencyMismatch ) {
  674.                 return;
  675.             }
  676.             if ( this.objectLength( rules ) ) {
  677.                 this.successList.push( element );
  678.             }
  679.             return true;
  680.         },
  682.         // return the custom message for the given element and validation method
  683.         // specified in the element's HTML5 data attribute
  684.         // return the generic message if present and no method specific message is present
  685.         customDataMessage: function( element, method ) {
  686.             return $( element ).data( "msg" + method.charAt( 0 ).toUpperCase() +
  687.                 method.substring( 1 ).toLowerCase() ) || $( element ).data( "msg" );
  688.         },
  690.         // return the custom message for the given element name and validation method
  691.         customMessage: function( name, method ) {
  692.             var m = this.settings.messages[ name ];
  693.             return m && ( m.constructor === String ? m : m[ method ]);
  694.         },
  696.         // return the first defined argument, allowing empty strings
  697.         findDefined: function() {
  698.             for ( var i = 0; i < arguments.length; i++) {
  699.                 if ( arguments[ i ] !== undefined ) {
  700.                     return arguments[ i ];
  701.                 }
  702.             }
  703.             return undefined;
  704.         },
  706.         defaultMessage: function( element, method ) {
  707.             return this.findDefined(
  708.                 this.customMessage( element.name, method ),
  709.                 this.customDataMessage( element, method ),
  710.                 // title is never undefined, so handle empty string as undefined
  711.                 !this.settings.ignoreTitle && element.title || undefined,
  712.                 $.validator.messages[ method ],
  713.                 "<strong>Warning: No message defined for " + element.name + "</strong>"
  714.             );
  715.         },
  717.         formatAndAdd: function( element, rule ) {
  718.             var message = this.defaultMessage( element, rule.method ),
  719.                 theregex = /\$?\{(\d+)\}/g;
  720.             if ( typeof message === "function" ) {
  721.                 message = message.call( this, rule.parameters, element );
  722.             } else if ( theregex.test( message ) ) {
  723.                 message = $.validator.format( message.replace( theregex, "{$1}" ), rule.parameters );
  724.             }
  725.             this.errorList.push({
  726.                 message: message,
  727.                 element: element,
  728.                 method: rule.method
  729.             });
  731.             this.errorMap[ element.name ] = message;
  732.             this.submitted[ element.name ] = message;
  733.         },
  735.         addWrapper: function( toToggle ) {
  736.             if ( this.settings.wrapper ) {
  737.                 toToggle = toToggle.add( toToggle.parent( this.settings.wrapper ) );
  738.             }
  739.             return toToggle;
  740.         },
  742.         defaultShowErrors: function() {
  743.             var i, elements, error;
  744.             for ( i = 0; this.errorList[ i ]; i++ ) {
  745.                 error = this.errorList[ i ];
  746.                 if ( this.settings.highlight ) {
  747.                     this.settings.highlight.call( this, error.element, this.settings.errorClass, this.settings.validClass );
  748.                 }
  749.                 this.showLabel( error.element, error.message );
  750.             }
  751.             if ( this.errorList.length ) {
  752.                 this.toShow = this.toShow.add( this.containers );
  753.             }
  754.             if ( this.settings.success ) {
  755.                 for ( i = 0; this.successList[ i ]; i++ ) {
  756.                     this.showLabel( this.successList[ i ] );
  757.                 }
  758.             }
  759.             if ( this.settings.unhighlight ) {
  760.                 for ( i = 0, elements = this.validElements(); elements[ i ]; i++ ) {
  761.                     this.settings.unhighlight.call( this, elements[ i ], this.settings.errorClass, this.settings.validClass );
  762.                 }
  763.             }
  764.             this.toHide = this.toHide.not( this.toShow );
  765.             this.hideErrors();
  766.             this.addWrapper( this.toShow ).show();
  767.         },
  769.         validElements: function() {
  770.             return this.currentElements.not( this.invalidElements() );
  771.         },
  773.         invalidElements: function() {
  774.             return $( this.errorList ).map(function() {
  775.                 return this.element;
  776.             });
  777.         },
  779.         showLabel: function( element, message ) {
  780.             var place, group, errorID,
  781.                 error = this.errorsFor( element ),
  782.                 elementID = this.idOrName( element ),
  783.                 describedBy = $( element ).attr( "aria-describedby" );
  784.             if ( error.length ) {
  785.                 // refresh error/success class
  786.                 error.removeClass( this.settings.validClass ).addClass( this.settings.errorClass );
  787.                 // replace message on existing label
  788.                 error.html( message );
  789.             } else {
  790.                 // create error element
  791.                 error = $( "<" + this.settings.errorElement + ">" )
  792.                     .attr( "id", elementID + "-error" )
  793.                     .addClass( this.settings.errorClass )
  794.                     .html( message || "" );
  796.                 // Maintain reference to the element to be placed into the DOM
  797.                 place = error;
  798.                 if ( this.settings.wrapper ) {
  799.                     // make sure the element is visible, even in IE
  800.                     // actually showing the wrapped element is handled elsewhere
  801.                     place = error.hide().show().wrap( "<" + this.settings.wrapper + "/>" ).parent();
  802.                 }
  803.                 if ( this.labelContainer.length ) {
  804.                     this.labelContainer.append( place );
  805.                 } else if ( this.settings.errorPlacement ) {
  806.                     this.settings.errorPlacement( place, $( element ) );
  807.                 } else {
  808.                     place.insertAfter( element );
  809.                 }
  811.                 // Link error back to the element
  812.                 if ( error.is( "label" ) ) {
  813.                     // If the error is a label, then associate using 'for'
  814.                     error.attr( "for", elementID );
  815.                 } else if ( error.parents( "label[for='" + elementID + "']" ).length === 0 ) {
  816.                     // If the element is not a child of an associated label, then it's necessary
  817.                     // to explicitly apply aria-describedby
  819.                     errorID = error.attr( "id" ).replace( /(:|\.|\[|\]|\$)/g, "\\$1");
  820.                     // Respect existing non-error aria-describedby
  821.                     if ( !describedBy ) {
  822.                         describedBy = errorID;
  823.                     } else if ( !describedBy.match( new RegExp( "\\b" + errorID + "\\b" ) ) ) {
  824.                         // Add to end of list if not already present
  825.                         describedBy += " " + errorID;
  826.                     }
  827.                     $( element ).attr( "aria-describedby", describedBy );
  829.                     // If this element is grouped, then assign to all elements in the same group
  830.                     group = this.groups[ element.name ];
  831.                     if ( group ) {
  832.                         $.each( this.groups, function( name, testgroup ) {
  833.                             if ( testgroup === group ) {
  834.                                 $( "[name='" + name + "']", this.currentForm )
  835.                                     .attr( "aria-describedby", error.attr( "id" ) );
  836.                             }
  837.                         });
  838.                     }
  839.                 }
  840.             }
  841.             if ( !message && this.settings.success ) {
  842.                 error.text( "" );
  843.                 if ( typeof this.settings.success === "string" ) {
  844.                     error.addClass( this.settings.success );
  845.                 } else {
  846.                     this.settings.success( error, element );
  847.                 }
  848.             }
  849.             this.toShow = this.toShow.add( error );
  850.         },
  852.         errorsFor: function( element ) {
  853.             var name = this.idOrName( element ),
  854.                 describer = $( element ).attr( "aria-describedby" ),
  855.                 selector = "label[for='" + name + "'], label[for='" + name + "'] *";
  857.             // aria-describedby should directly reference the error element
  858.             if ( describer ) {
  859.                 selector = selector + ", #" + describer.replace( /\s+/g, ", #" );
  860.             }
  861.             return this
  862.                 .errors()
  863.                 .filter( selector );
  864.         },
  866.         idOrName: function( element ) {
  867.             return this.groups[ element.name ] || ( this.checkable( element ) ? element.name : element.id || element.name );
  868.         },
  870.         validationTargetFor: function( element ) {
  872.             // If radio/checkbox, validate first element in group instead
  873.             if ( this.checkable( element ) ) {
  874.                 element = this.findByName( element.name );
  875.             }
  877.             // Always apply ignore filter
  878.             return $( element ).not( this.settings.ignore )[ 0 ];
  879.         },
  881.         checkable: function( element ) {
  882.             return ( /radio|checkbox/i ).test( element.type );
  883.         },
  885.         findByName: function( name ) {
  886.             return $( this.currentForm ).find( "[name='" + name + "']" );
  887.         },
  889.         getLength: function( value, element ) {
  890.             switch ( element.nodeName.toLowerCase() ) {
  891.             case "select":
  892.                 return $( "option:selected", element ).length;
  893.             case "input":
  894.                 if ( this.checkable( element ) ) {
  895.                     return this.findByName( element.name ).filter( ":checked" ).length;
  896.                 }
  897.             }
  898.             return value.length;
  899.         },
  901.         depend: function( param, element ) {
  902.             return this.dependTypes[typeof param] ? this.dependTypes[typeof param]( param, element ) : true;
  903.         },
  905.         dependTypes: {
  906.             "boolean": function( param ) {
  907.                 return param;
  908.             },
  909.             "string": function( param, element ) {
  910.                 return !!$( param, element.form ).length;
  911.             },
  912.             "function": function( param, element ) {
  913.                 return param( element );
  914.             }
  915.         },
  917.         optional: function( element ) {
  918.             var val = this.elementValue( element );
  919.             return !$.validator.methods.required.call( this, val, element ) && "dependency-mismatch";
  920.         },
  922.         startRequest: function( element ) {
  923.             if ( !this.pending[ element.name ] ) {
  924.                 this.pendingRequest++;
  925.                 this.pending[ element.name ] = true;
  926.             }
  927.         },
  929.         stopRequest: function( element, valid ) {
  930.             this.pendingRequest--;
  931.             // sometimes synchronization fails, make sure pendingRequest is never < 0
  932.             if ( this.pendingRequest < 0 ) {
  933.                 this.pendingRequest = 0;
  934.             }
  935.             delete this.pending[ element.name ];
  936.             if ( valid && this.pendingRequest === 0 && this.formSubmitted && this.form() ) {
  937.                 $( this.currentForm ).submit();
  938.                 this.formSubmitted = false;
  939.             } else if (!valid && this.pendingRequest === 0 && this.formSubmitted ) {
  940.                 $( this.currentForm ).triggerHandler( "invalid-form", [ this ]);
  941.                 this.formSubmitted = false;
  942.             }
  943.         },
  945.         previousValue: function( element ) {
  946.             return $.data( element, "previousValue" ) || $.data( element, "previousValue", {
  947.                 old: null,
  948.                 valid: true,
  949.                 message: this.defaultMessage( element, "remote" )
  950.             });
  951.         },
  953.         // cleans up all forms and elements, removes validator-specific events
  954.         destroy: function() {
  955.             this.resetForm();
  957.             $( this.currentForm )
  958.                 .off( ".validate" )
  959.                 .removeData( "validator" );
  960.         }
  962.     },
  964.     classRuleSettings: {
  965.         required: { required: true },
  966.         email: { email: true },
  967.         url: { url: true },
  968.         date: { date: true },
  969.         dateISO: { dateISO: true },
  970.         number: { number: true },
  971.         digits: { digits: true },
  972.         creditcard: { creditcard: true }
  973.     },
  975.     addClassRules: function( className, rules ) {
  976.         if ( className.constructor === String ) {
  977.             this.classRuleSettings[ className ] = rules;
  978.         } else {
  979.             $.extend( this.classRuleSettings, className );
  980.         }
  981.     },
  983.     classRules: function( element ) {
  984.         var rules = {},
  985.             classes = $( element ).attr( "class" );
  987.         if ( classes ) {
  988.             $.each( classes.split( " " ), function() {
  989.                 if ( this in $.validator.classRuleSettings ) {
  990.                     $.extend( rules, $.validator.classRuleSettings[ this ]);
  991.                 }
  992.             });
  993.         }
  994.         return rules;
  995.     },
  997.     normalizeAttributeRule: function( rules, type, method, value ) {
  999.         // convert the value to a number for number inputs, and for text for backwards compability
  1000.         // allows type="date" and others to be compared as strings
  1001.         if ( /min|max/.test( method ) && ( type === null || /number|range|text/.test( type ) ) ) {
  1002.             value = Number( value );
  1004.             // Support Opera Mini, which returns NaN for undefined minlength
  1005.             if ( isNaN( value ) ) {
  1006.                 value = undefined;
  1007.             }
  1008.         }
  1010.         if ( value || value === 0 ) {
  1011.             rules[ method ] = value;
  1012.         } else if ( type === method && type !== "range" ) {
  1014.             // exception: the jquery validate 'range' method
  1015.             // does not test for the html5 'range' type
  1016.             rules[ method ] = true;
  1017.         }
  1018.     },
  1020.     attributeRules: function( element ) {
  1021.         var rules = {},
  1022.             $element = $( element ),
  1023.             type = element.getAttribute( "type" ),
  1024.             method, value;
  1026.         for ( method in $.validator.methods ) {
  1028.             // support for <input required> in both html5 and older browsers
  1029.             if ( method === "required" ) {
  1030.                 value = element.getAttribute( method );
  1032.                 // Some browsers return an empty string for the required attribute
  1033.                 // and non-HTML5 browsers might have required="" markup
  1034.                 if ( value === "" ) {
  1035.                     value = true;
  1036.                 }
  1038.                 // force non-HTML5 browsers to return bool
  1039.                 value = !!value;
  1040.             } else {
  1041.                 value = $element.attr( method );
  1042.             }
  1044.             this.normalizeAttributeRule( rules, type, method, value );
  1045.         }
  1047.         // maxlength may be returned as -1, 2147483647 ( IE ) and 524288 ( safari ) for text inputs
  1048.         if ( rules.maxlength && /-1|2147483647|524288/.test( rules.maxlength ) ) {
  1049.             delete rules.maxlength;
  1050.         }
  1052.         return rules;
  1053.     },
  1055.     dataRules: function( element ) {
  1056.         var rules = {},
  1057.             $element = $( element ),
  1058.             type = element.getAttribute( "type" ),
  1059.             method, value;
  1061.         for ( method in $.validator.methods ) {
  1062.             value = $element.data( "rule" + method.charAt( 0 ).toUpperCase() + method.substring( 1 ).toLowerCase() );
  1063.             this.normalizeAttributeRule( rules, type, method, value );
  1064.         }
  1065.         return rules;
  1066.     },
  1068.     staticRules: function( element ) {
  1069.         var rules = {},
  1070.             validator = $.data( element.form, "validator" );
  1071.         if ( !validator ) {
  1072.             validator = new $.validator( {}, element.form );
  1073.             $.data( element.form, "validator", validator );
  1074.         }
  1075.         if ( validator.settings.rules ) {
  1076.             rules = $.validator.normalizeRule( validator.settings.rules[ element.name ] ) || {};
  1077.         }
  1078.         return rules;
  1079.     },
  1081.     normalizeRules: function( rules, element ) {
  1082.         // handle dependency check
  1083.         $.each( rules, function( prop, val ) {
  1084.             // ignore rule when param is explicitly false, eg. required:false
  1085.             if ( val === false ) {
  1086.                 delete rules[ prop ];
  1087.                 return;
  1088.             }
  1089.             if ( val.param || val.depends ) {
  1090.                 var keepRule = true;
  1091.                 switch ( typeof val.depends ) {
  1092.                 case "string":
  1093.                     keepRule = !!$( val.depends, element.form ).length;
  1094.                     break;
  1095.                 case "function":
  1096.                     keepRule = val.depends.call( element, element );
  1097.                     break;
  1098.                 }
  1099.                 if ( keepRule ) {
  1100.                     rules[ prop ] = val.param !== undefined ? val.param : true;
  1101.                 } else {
  1102.                     delete rules[ prop ];
  1103.                 }
  1104.             }
  1105.         });
  1107.         // evaluate parameters
  1108.         $.each( rules, function( rule, parameter ) {
  1109.             rules[ rule ] = $.isFunction( parameter ) ? parameter( element ) : parameter;
  1110.         });
  1112.         // clean number parameters
  1113.         $.each([ "minlength", "maxlength" ], function() {
  1114.             if ( rules[ this ] ) {
  1115.                 rules[ this ] = Number( rules[ this ] );
  1116.             }
  1117.         });
  1118.         $.each([ "rangelength", "range" ], function() {
  1119.             var parts;
  1120.             if ( rules[ this ] ) {
  1121.                 if ( $.isArray( rules[ this ] ) ) {
  1122.                     rules[ this ] = [ Number( rules[ this ][ 0 ]), Number( rules[ this ][ 1 ] ) ];
  1123.                 } else if ( typeof rules[ this ] === "string" ) {
  1124.                     parts = rules[ this ].replace(/[\[\]]/g, "" ).split( /[\s,]+/ );
  1125.                     rules[ this ] = [ Number( parts[ 0 ]), Number( parts[ 1 ] ) ];
  1126.                 }
  1127.             }
  1128.         });
  1130.         if ( $.validator.autoCreateRanges ) {
  1131.             // auto-create ranges
  1132.             if ( rules.min != null && rules.max != null ) {
  1133.                 rules.range = [ rules.min, rules.max ];
  1134.                 delete rules.min;
  1135.                 delete rules.max;
  1136.             }
  1137.             if ( rules.minlength != null && rules.maxlength != null ) {
  1138.                 rules.rangelength = [ rules.minlength, rules.maxlength ];
  1139.                 delete rules.minlength;
  1140.                 delete rules.maxlength;
  1141.             }
  1142.         }
  1144.         return rules;
  1145.     },
  1147.     // Converts a simple string to a {string: true} rule, e.g., "required" to {required:true}
  1148.     normalizeRule: function( data ) {
  1149.         if ( typeof data === "string" ) {
  1150.             var transformed = {};
  1151.             $.each( data.split( /\s/ ), function() {
  1152.                 transformed[ this ] = true;
  1153.             });
  1154.             data = transformed;
  1155.         }
  1156.         return data;
  1157.     },
  1159.     // http://jqueryvalidation.org/jQuery.validator.addMethod/
  1160.     addMethod: function( name, method, message ) {
  1161.         $.validator.methods[ name ] = method;
  1162.         $.validator.messages[ name ] = message !== undefined ? message : $.validator.messages[ name ];
  1163.         if ( method.length < 3 ) {
  1164.             $.validator.addClassRules( name, $.validator.normalizeRule( name ) );
  1165.         }
  1166.     },
  1168.     methods: {
  1170.         // http://jqueryvalidation.org/required-method/
  1171.         required: function( value, element, param ) {
  1172.             // check if dependency is met
  1173.             if ( !this.depend( param, element ) ) {
  1174.                 return "dependency-mismatch";
  1175.             }
  1176.             if ( element.nodeName.toLowerCase() === "select" ) {
  1177.                 // could be an array for select-multiple or a string, both are fine this way
  1178.                 var val = $( element ).val();
  1179.                 return val && val.length > 0;
  1180.             }
  1181.             if ( this.checkable( element ) ) {
  1182.                 return this.getLength( value, element ) > 0;
  1183.             }
  1184.             return value.length > 0;
  1185.         },
  1187.         // http://jqueryvalidation.org/email-method/
  1188.         email: function( value, element ) {
  1189.             // From https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address
  1190.             // Retrieved 2014-01-14
  1191.             // If you have a problem with this implementation, report a bug against the above spec
  1192.             // Or use custom methods to implement your own email validation
  1193.             return this.optional( element ) || /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test( value );
  1194.         },
  1196.         // http://jqueryvalidation.org/url-method/
  1197.         url: function( value, element ) {
  1199.             // Copyright (c) 2010-2013 Diego Perini, MIT licensed
  1200.             // https://gist.github.com/dperini/729294
  1201.             // see also https://mathiasbynens.be/demo/url-regex
  1202.             // modified to allow protocol-relative URLs
  1203.             return this.optional( element ) || /^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})).?)(?::\d{2,5})?(?:[/?#]\S*)?$/i.test( value );
  1204.         },
  1206.         // http://jqueryvalidation.org/date-method/
  1207.         date: function( value, element ) {
  1208.             return this.optional( element ) || !/Invalid|NaN/.test( new Date( value ).toString() );
  1209.         },
  1211.         // http://jqueryvalidation.org/dateISO-method/
  1212.         dateISO: function( value, element ) {
  1213.             return this.optional( element ) || /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test( value );
  1214.         },
  1216.         // http://jqueryvalidation.org/number-method/
  1217.         number: function( value, element ) {
  1218.             return this.optional( element ) || /^(?:-?\d+|-?\d{1,3}(?:,\d{3})+)?(?:\.\d+)?$/.test( value );
  1219.         },
  1221.         // http://jqueryvalidation.org/digits-method/
  1222.         digits: function( value, element ) {
  1223.             return this.optional( element ) || /^\d+$/.test( value );
  1224.         },
  1226.         // http://jqueryvalidation.org/creditcard-method/
  1227.         // based on http://en.wikipedia.org/wiki/Luhn_algorithm
  1228.         creditcard: function( value, element ) {
  1229.             if ( this.optional( element ) ) {
  1230.                 return "dependency-mismatch";
  1231.             }
  1232.             // accept only spaces, digits and dashes
  1233.             if ( /[^0-9 \-]+/.test( value ) ) {
  1234.                 return false;
  1235.             }
  1236.             var nCheck = 0,
  1237.                 nDigit = 0,
  1238.                 bEven = false,
  1239.                 n, cDigit;
  1241.             value = value.replace( /\D/g, "" );
  1243.             // Basing min and max length on
  1244.             // http://developer.ean.com/general_info/Valid_Credit_Card_Types
  1245.             if ( value.length < 13 || value.length > 19 ) {
  1246.                 return false;
  1247.             }
  1249.             for ( n = value.length - 1; n >= 0; n--) {
  1250.                 cDigit = value.charAt( n );
  1251.                 nDigit = parseInt( cDigit, 10 );
  1252.                 if ( bEven ) {
  1253.                     if ( ( nDigit *= 2 ) > 9 ) {
  1254.                         nDigit -= 9;
  1255.                     }
  1256.                 }
  1257.                 nCheck += nDigit;
  1258.                 bEven = !bEven;
  1259.             }
  1261.             return ( nCheck % 10 ) === 0;
  1262.         },
  1264.         // http://jqueryvalidation.org/minlength-method/
  1265.         minlength: function( value, element, param ) {
  1266.             var length = $.isArray( value ) ? value.length : this.getLength( value, element );
  1267.             return this.optional( element ) || length >= param;
  1268.         },
  1270.         // http://jqueryvalidation.org/maxlength-method/
  1271.         maxlength: function( value, element, param ) {
  1272.             var length = $.isArray( value ) ? value.length : this.getLength( value, element );
  1273.             return this.optional( element ) || length <= param;
  1274.         },
  1276.         // http://jqueryvalidation.org/rangelength-method/
  1277.         rangelength: function( value, element, param ) {
  1278.             var length = $.isArray( value ) ? value.length : this.getLength( value, element );
  1279.             return this.optional( element ) || ( length >= param[ 0 ] && length <= param[ 1 ] );
  1280.         },
  1282.         // http://jqueryvalidation.org/min-method/
  1283.         min: function( value, element, param ) {
  1284.             return this.optional( element ) || value >= param;
  1285.         },
  1287.         // http://jqueryvalidation.org/max-method/
  1288.         max: function( value, element, param ) {
  1289.             return this.optional( element ) || value <= param;
  1290.         },
  1292.         // http://jqueryvalidation.org/range-method/
  1293.         range: function( value, element, param ) {
  1294.             return this.optional( element ) || ( value >= param[ 0 ] && value <= param[ 1 ] );
  1295.         },
  1297.         // http://jqueryvalidation.org/equalTo-method/
  1298.         equalTo: function( value, element, param ) {
  1299.             // bind to the blur event of the target in order to revalidate whenever the target field is updated
  1300.             // TODO find a way to bind the event just once, avoiding the unbind-rebind overhead
  1301.             var target = $( param );
  1302.             if ( this.settings.onfocusout ) {
  1303.                 target.off( ".validate-equalTo" ).on( "blur.validate-equalTo", function() {
  1304.                     $( element ).valid();
  1305.                 });
  1306.             }
  1307.             return value === target.val();
  1308.         },
  1310.         // http://jqueryvalidation.org/remote-method/
  1311.         remote: function( value, element, param ) {
  1312.             if ( this.optional( element ) ) {
  1313.                 return "dependency-mismatch";
  1314.             }
  1316.             var previous = this.previousValue( element ),
  1317.                 validator, data;
  1319.             if (!this.settings.messages[ element.name ] ) {
  1320.                 this.settings.messages[ element.name ] = {};
  1321.             }
  1322.             previous.originalMessage = this.settings.messages[ element.name ].remote;
  1323.             this.settings.messages[ element.name ].remote = previous.message;
  1325.             param = typeof param === "string" && { url: param } || param;
  1327.             if ( previous.old === value ) {
  1328.                 return previous.valid;
  1329.             }
  1331.             previous.old = value;
  1332.             validator = this;
  1333.             this.startRequest( element );
  1334.             data = {};
  1335.             data[ element.name ] = value;
  1336.             $.ajax( $.extend( true, {
  1337.                 mode: "abort",
  1338.                 port: "validate" + element.name,
  1339.                 dataType: "json",
  1340.                 data: data,
  1341.                 context: validator.currentForm,
  1342.                 success: function( response ) {
  1343.                     var valid = response === true || response === "true",
  1344.                         errors, message, submitted;
  1346.                     validator.settings.messages[ element.name ].remote = previous.originalMessage;
  1347.                     if ( valid ) {
  1348.                         submitted = validator.formSubmitted;
  1349.                         validator.prepareElement( element );
  1350.                         validator.formSubmitted = submitted;
  1351.                         validator.successList.push( element );
  1352.                         delete validator.invalid[ element.name ];
  1353.                         validator.showErrors();
  1354.                     } else {
  1355.                         errors = {};
  1356.                         message = response || validator.defaultMessage( element, "remote" );
  1357.                         errors[ element.name ] = previous.message = $.isFunction( message ) ? message( value ) : message;
  1358.                         validator.invalid[ element.name ] = true;
  1359.                         validator.showErrors( errors );
  1360.                     }
  1361.                     previous.valid = valid;
  1362.                     validator.stopRequest( element, valid );
  1363.                 }
  1364.             }, param ) );
  1365.             return "pending";
  1366.         }
  1367.     }
  1369. });
  1371. // ajax mode: abort
  1372. // usage: $.ajax({ mode: "abort"[, port: "uniqueport"]});
  1373. // if mode:"abort" is used, the previous request on that port (port can be undefined) is aborted via XMLHttpRequest.abort()
  1375. var pendingRequests = {},
  1376.     ajax;
  1377. // Use a prefilter if available (1.5+)
  1378. if ( $.ajaxPrefilter ) {
  1379.     $.ajaxPrefilter(function( settings, _, xhr ) {
  1380.         var port = settings.port;
  1381.         if ( settings.mode === "abort" ) {
  1382.             if ( pendingRequests[port] ) {
  1383.                 pendingRequests[port].abort();
  1384.             }
  1385.             pendingRequests[port] = xhr;
  1386.         }
  1387.     });
  1388. } else {
  1389.     // Proxy ajax
  1390.     ajax = $.ajax;
  1391.     $.ajax = function( settings ) {
  1392.         var mode = ( "mode" in settings ? settings : $.ajaxSettings ).mode,
  1393.             port = ( "port" in settings ? settings : $.ajaxSettings ).port;
  1394.         if ( mode === "abort" ) {
  1395.             if ( pendingRequests[port] ) {
  1396.                 pendingRequests[port].abort();
  1397.             }
  1398.             pendingRequests[port] = ajax.apply(this, arguments);
  1399.             return pendingRequests[port];
  1400.         }
  1401.         return ajax.apply(this, arguments);
  1402.     };
  1403. }
  1405. }));

自定义规则

  1. /*!
  2.  * jQuery Validation Plugin v1.14.0
  3.  *
  4.  * http://jqueryvalidation.org/
  5.  *
  6.  * Copyright (c) 2015 Jörn Zaefferer
  7.  * Released under the MIT license
  8.  * by  zzh   add
  9.  * shenfenzheng 
  10.  */
  11. // 字符验证
  13. jQuery.validator.addMethod("checkUseTags", function() {
  14.     return $("#use_tags").val()!="" || $("#other_tags").val()!="";
  15. }, "请选择或填写赎回用途！");
  16.   jQuery.validator.addMethod("stringCheck", function(value, element) { 
  17.      return this.optional(element) || /^[\u0391-\uFFE5\w]+$/.test(value); 
  18.   }, "只能包括中文字、英文字母、数字和下划线"); 
  19.   // 中文字两个字节 
  20.   jQuery.validator.addMethod("byteRangeLength", function(value, element, param) { 
  21.      var length = value.length; 
  22.     for(var i = 0; i < value.length; i++){ 
  23.   if(value.charCodeAt(i) > 127){ 
  24.   length++; 
  25.   } 
  26.   } 
  27.   return this.optional(element) || ( length >= param[0] && length <= param[1] ); 
  28. }, "请确保输入的值在3-15个字节之间(一个中文字算2个字节)"); 
  30. // 身份证号码验证 
  31. jQuery.validator.addMethod("isIdCardNo", function(value, element) { 
  32.   return this.optional(element) || idCardNoUtil.checkIdCardNo(value);     
  33. }, "请正确输入您的身份证号码"); 
  34. //护照编号验证
  35.  jQuery.validator.addMethod("passport", function(value, element) { 
  36.   return this.optional(element) || checknumber(value);     
  37. }, "请正确输入您的护照编号"); 
  39. // 手机号码验证 
  40. jQuery.validator.addMethod("isMobile", function(value, element) { 
  41.   var length = value.length; 
  42.   var mobile = /^(13[0-9]|14[0-9]|15[0-9]|18[0-9]|17[0-9])\d{8}$/; 
  43.   return this.optional(element) || (length == 11 && mobile.test(value)); 
  44. }, "请正确填写您的手机号码"); 
  46. // 电话号码验证 
  47. jQuery.validator.addMethod("isTel", function(value, element) { 
  48.   var tel = /^\d{3,4}-?\d{7,9}$/; //电话号码格式010-12345678 
  49.   return this.optional(element) || (tel.test(value)); 
  50. }, "请正确填写您的电话号码"); 
  52. // 联系电话(手机/电话皆可)验证 
  53. jQuery.validator.addMethod("isPhone", function(value,element) { 
  54.   var length = value.length; 
  55.   var mobile = /^(((13[0-9]{1})|(15[0-9]{1}))+\d{8})$/; 
  56.   var tel = /^\d{3,4}-?\d{7,9}$/; 
  57.   return this.optional(element) || (tel.test(value) || mobile.test(value)); 
  59. }, "请正确填写您的联系电话"); 
  61. // 邮政编码验证 
  62. jQuery.validator.addMethod("isZipCode", function(value, element) { 
  63.   var tel = /^[0-9]{6}$/; 
  64.   return this.optional(element) || (tel.test(value)); 
  65. }, "请正确填写您的邮政编码"); 
  68.     // 验证值小数位数不能超过两位
  69. jQuery.validator.addMethod("decimal", function(value, element) {
  70.     var decimal = /^-?\d+(\.\d{1,2})?$/;
  71.     return this.optional(element) || (decimal.test(value));
  72. }, "小数位数不能超过两位!");
  74. // 验证值必须大于特定值(不能等于)
  75. jQuery.validator.addMethod("gt", function(value, element, param) {
  76. return value > param;
  77. },"输入值必须大于{0}!");
  78. // 验证日期大于等于特定值
  79. jQuery.validator.addMethod("gtDate", function(value, element, param) {
  80.     return Date.parse(value) >= Date.parse(param);
  81. },"输入值必须大于{0}!");
  83. // 验证两次输入值是否不相同
  84. jQuery.validator.addMethod("notEqualTo", function(value, element, param) {
  85. return value != $(param).val();
  86. }, "两次输入不能相同!");
  87. // 验证值不允许与特定值等于
  88. jQuery.validator.addMethod("notEqual", function(value, element, param) {
  89. return value != param;
  90. },"输入值不允许为{0}!");
  98. var idCardNoUtil = {
  99. provinceAndCitys: {11:"北京",12:"天津",13:"河北",14:"山西",15:"内蒙古",21:"辽宁",22:"吉林",23:"黑龙江",
  100. 31:"上海",32:"江苏",33:"浙江",34:"安徽",35:"福建",36:"江西",37:"山东",41:"河南",42:"湖北",43:"湖南",44:"广东",
  101. 45:"广西",46:"海南",50:"重庆",51:"四川",52:"贵州",53:"云南",54:"西藏",61:"陕西",62:"甘肃",63:"青海",64:"宁夏",
  102. 65:"新疆",71:"台湾",81:"香港",82:"澳门",91:"国外"},
  104. powers: ["7","9","10","5","8","4","2","1","6","3","7","9","10","5","8","4","2"],
  106. parityBit: ["1","0","X","9","8","7","6","5","4","3","2"],
  108. genders: {male:"男",female:"女"},
  110. checkAddressCode: function(addressCode){
  111. var check = /^[1-9]\d{5}$/.test(addressCode);
  112. if(!check) return false;
  113. if(idCardNoUtil.provinceAndCitys[parseInt(addressCode.substring(0,2))]){
  114. return true;
  115. }else{
  116. return false;
  117. }
  118. },
  120. checkBirthDayCode: function(birDayCode){
  121. var check = /^[1-9]\d{3}((0[1-9])|(1[0-2]))((0[1-9])|([1-2][0-9])|(3[0-1]))$/.test(birDayCode);
  122. if(!check) return false;
  123. var yyyy = parseInt(birDayCode.substring(0,4),10);
  124. var mm = parseInt(birDayCode.substring(4,6),10);
  125. var dd = parseInt(birDayCode.substring(6),10);
  126. var xdata = new Date(yyyy,mm-1,dd);
  127. if(xdata > new Date()){
  128. return false;//生日不能大于当前日期
  129. }else if ( ( xdata.getFullYear() == yyyy ) && ( xdata.getMonth () == mm - 1 ) && ( xdata.getDate() == dd ) ){
  130. return true;
  131. }else{
  132. return false;
  133. }
  134. },
  136. getParityBit: function(idCardNo){
  137. var id17 = idCardNo.substring(0,17);
  138. var power = 0;
  139. for(var i=0;i<17;i++){
  140. power += parseInt(id17.charAt(i),10) * parseInt(idCardNoUtil.powers[i]);
  141. }
  142. var mod = power % 11;
  143. return idCardNoUtil.parityBit[mod];
  144. },
  146. checkParityBit: function(idCardNo){
  147. var parityBit = idCardNo.charAt(17).toUpperCase();
  148. if(idCardNoUtil.getParityBit(idCardNo) == parityBit){
  149. return true;
  150. }else{
  151. return false;
  152. }
  153. },
  155. checkIdCardNo: function(idCardNo){
  156. //15位和18位身份证号码的基本校验
  157. var check = /^\d{15}|(\d{17}(\d|x|X))$/.test(idCardNo);
  158. if(!check) return false;
  159. //判断长度为15位或18位
  160. if(idCardNo.length==15){
  161. return idCardNoUtil.check15IdCardNo(idCardNo);
  162. }else if(idCardNo.length==18){
  163. return idCardNoUtil.check18IdCardNo(idCardNo);
  164. }else{
  165. return false;
  166. }
  167. },
  168. //校验15位的身份证号码
  169. check15IdCardNo: function(idCardNo){
  170. //15位身份证号码的基本校验
  171. var check = /^[1-9]\d{7}((0[1-9])|(1[0-2]))((0[1-9])|([1-2][0-9])|(3[0-1]))\d{3}$/.test(idCardNo);
  172. if(!check) return false;
  173. //校验地址码
  174. var addressCode = idCardNo.substring(0,6);
  175. check = idCardNoUtil.checkAddressCode(addressCode);
  176. if(!check) return false;
  177. var birDayCode = '19' + idCardNo.substring(6,12);
  178. //校验日期码
  179. return idCardNoUtil.checkBirthDayCode(birDayCode);
  180. },
  181. //校验18位的身份证号码
  182. check18IdCardNo: function(idCardNo){
  183. //18位身份证号码的基本格式校验
  184. var check = /^[1-9]\d{5}[1-9]\d{3}((0[1-9])|(1[0-2]))((0[1-9])|([1-2][0-9])|(3[0-1]))\d{3}(\d|x|X)$/.test(idCardNo);
  185. if(!check) return false;
  186. //校验地址码
  187. var addressCode = idCardNo.substring(0,6);
  188. check = idCardNoUtil.checkAddressCode(addressCode);
  189. if(!check) return false;
  190. //校验日期码
  191. var birDayCode = idCardNo.substring(6,14);
  192. check = idCardNoUtil.checkBirthDayCode(birDayCode);
  193. if(!check) return false;
  194. //验证校检码
  195. return idCardNoUtil.checkParityBit(idCardNo);
  196. },
  197. formateDateCN: function(day){
  198. var yyyy =day.substring(0,4);
  199. var mm = day.substring(4,6);
  200. var dd = day.substring(6);
  201. return yyyy + '-' + mm +'-' + dd;
  202. },
  203. //获取信息
  204. getIdCardInfo: function(idCardNo){
  205. var idCardInfo = {
  206. gender:"", //性别
  207. birthday:"" // 出生日期(yyyy-mm-dd)
  208. };
  209. if(idCardNo.length==15){
  210. var aday = '19' + idCardNo.substring(6,12);
  211. idCardInfo.birthday=idCardNoUtil.formateDateCN(aday);
  212. if(parseInt(idCardNo.charAt(14))%2==0){
  213. idCardInfo.gender=idCardNoUtil.genders.female;
  214. }else{
  215. idCardInfo.gender=idCardNoUtil.genders.male;
  216. }
  217. }else if(idCardNo.length==18){
  218. var aday = idCardNo.substring(6,14);
  219. idCardInfo.birthday=idCardNoUtil.formateDateCN(aday);
  220. if(parseInt(idCardNo.charAt(16))%2==0){
  221. idCardInfo.gender=idCardNoUtil.genders.female;
  222. }else{
  223. idCardInfo.gender=idCardNoUtil.genders.male;
  224. }
  225. }
  226. return idCardInfo;
  227. },
  229. getId15:function(idCardNo){
  230. if(idCardNo.length==15){
  231. return idCardNo;
  232. }else if(idCardNo.length==18){
  233. return idCardNo.substring(0,6) + idCardNo.substring(8,17);
  234. }else{
  235. return null;
  236. }
  237. },
  239. getId18: function(idCardNo){
  240. if(idCardNo.length==15){
  241. var id17 = idCardNo.substring(0,6) + '19' + idCardNo.substring(6);
  242. var parityBit = idCardNoUtil.getParityBit(id17);
  243. return id17 + parityBit;
  244. }else if(idCardNo.length==18){
  245. return idCardNo;
  246. }else{
  247. return null;
  248. }
  249. }
  250. };
  251. //验证护照是否正确
  252. function checknumber(number){
  253. var str=number;
  254. //在JavaScript中，正则表达式只能使用"/"开头和结束，不能使用双引号
  255. var Expression=/(P\d{7})|(G\d{8})/;
  256. var objExp=new RegExp(Expression);
  257. if(objExp.test(str)==true){
  258.    return true;
  259. }else{
  260.    return false;
  261. } 
  262. };

发表评论

表情：
评论列表 （有 0 条评论，716人围观）

还没有评论，来说两句吧...

相关阅读