jQuery validate: ¿Cómo agregar una regla para la validación de expresiones regulares?




5 Answers

Puedes usar el addMethod ()

p.ej

$.validator.addMethod('postalCode', function (value) { 
    return /^((\d{5}-\d{4})|(\d{5})|([A-Z]\d[A-Z]\s\d[A-Z]\d))$/.test(value); 
}, 'Please enter a valid US or Canadian postal code.');

buen artículo aquí https://web.archive.org/web/20130609222116/http://www.randallmorey.com/blog/2008/mar/16/extending-jquery-form-validation-plugin/

jquery regex jquery-validate

Estoy usando el complemento de validación jQuery . ¡Buena cosa! Quiero migrar mi solución ASP.NET existente para usar jQuery en lugar de los validadores ASP.NET. Me falta un reemplazo para el validador de expresiones regulares . Quiero poder hacer algo como esto:

$("Textbox").rules("add", { regularExpression: "^[a-zA-Z'.\s]{1,40}$" })

¿Cómo agrego una regla personalizada para lograr esto?




No hay razón para definir la expresión regular como una cadena.

$.validator.addMethod(
    "regex",
    function(value, element, regexp) {
        var check = false;
        return this.optional(element) || regexp.test(value);
    },
    "Please check your input."
);

y

telephone: { required: true, regex : /^[\d\s]+$/, minlength: 5 },

Es mejor así, ¿no?




Extendiendo un poco la respuesta de PeterTheNiceGuy:

$.validator.addMethod(
        "regex",
        function(value, element, regexp) {
            if (regexp.constructor != RegExp)
                regexp = new RegExp(regexp);
            else if (regexp.global)
                regexp.lastIndex = 0;
            return this.optional(element) || regexp.test(value);
        },
        "Please check your input."
);

Esto le permitiría pasar un objeto de expresión regular a la regla.

$("Textbox").rules("add", { regex: /^[a-zA-Z'.\s]{1,40}$/ });

Es necesario restablecer la propiedad lastIndex cuando g -flag se establece en el objeto RegExp . De lo contrario, comenzaría a validar desde la posición de la última coincidencia con esa expresión regular, incluso si la cadena de asunto es diferente.

Algunas otras ideas que tuve fueron para permitirte usar matrices de expresiones regulares, y otra regla para la negación de las expresiones regulares:

$("password").rules("add", {
    regex: [
        /^[a-zA-Z'.\s]{8,40}$/,
        /^.*[a-z].*$/,
        /^.*[A-Z].*$/,
        /^.*[0-9].*$/
    ],
    '!regex': /password|123/
});

Pero implementar eso quizás sea demasiado.




Este es el código de trabajo.

function validateSignup()
{   
    $.validator.addMethod(
            "regex",
            function(value, element, regexp) 
            {
                if (regexp.constructor != RegExp)
                    regexp = new RegExp(regexp);
                else if (regexp.global)
                    regexp.lastIndex = 0;
                return this.optional(element) || regexp.test(value);
            },
            "Please check your input."
    );

    $('#signupForm').validate(
    {

        onkeyup : false,
        errorClass: "req_mess",
        ignore: ":hidden",
        validClass: "signup_valid_class",
        errorClass: "signup_error_class",

        rules:
        {

            email:
            {
                required: true,
                email: true,
                regex: /^[A-Za-z0-9_]+\@[A-Za-z0-9_]+\.[A-Za-z0-9_]+/,
            },

            userId:
            {
                required: true,
                minlength: 6,
                maxlength: 15,
                regex: /^[A-Za-z0-9_]{6,15}$/,
            },

            phoneNum:
            {
                required: true,
                regex: /^[+-]{1}[0-9]{1,3}\-[0-9]{10}$/,
            },

        },
        messages: 
        {
            email: 
            {
                required: 'You must enter a email',
                regex: 'Please enter a valid email without spacial chars, ie, Example@gmail.com'
            },

            userId:
            {
                required: 'Alphanumeric, _, min:6, max:15',
                regex: "Please enter any alphaNumeric char of length between 6-15, ie, sbp_arun_2016"
            },

            phoneNum: 
            {
                required: "Please enter your phone number",
                regex: "e.g. +91-1234567890"    
            },

        },

        submitHandler: function (form)
        {
            return true;
        }
    });
}



utilizamos principalmente la notación de marcado del complemento de validación jquery y las muestras publicadas no funcionaron para nosotros, cuando hay marcas presentes en la expresión regular, por ejemplo

<input type="text" name="myfield" regex="/^[0-9]{3}$/i" />

Por eso utilizamos el siguiente fragmento de código.

$.validator.addMethod(
        "regex",
        function(value, element, regstring) {
            // fast exit on empty optional
            if (this.optional(element)) {
                return true;
            }

            var regParts = regstring.match(/^\/(.*?)\/([gim]*)$/);
            if (regParts) {
                // the parsed pattern had delimiters and modifiers. handle them. 
                var regexp = new RegExp(regParts[1], regParts[2]);
            } else {
                // we got pattern string without delimiters
                var regexp = new RegExp(regstring);
            }

            return regexp.test(value);
        },
        "Please check your input."
);  

Por supuesto, ahora se podría combinar este código con uno de los anteriores para permitir también pasar objetos RegExp al complemento, pero como no lo necesitábamos, dejamos este ejercicio para el lector ;-).

PD: también hay un complemento incluido para eso, https://github.com/jzaefferer/jquery-validation/blob/master/src/additional/pattern.js




Related