solo - regexp javascript

RegularExpressionAttribute: ¿Cómo hacer que no distinga mayúsculas y minúsculas para la validación del lado del cliente?

Question

Tengo una cadena que uso para la validación del lado del cliente:

private const String regex = @"^(?:/b(?:/d{5}(?:/s*-/s*/d{5})?|([A-Z]{2})/d{3}(?:/s*-/s*/1/d{3})?)(?:,/s*)?)+$";

Utilizo esta cadena en mi atributo [RegularExpression(regex, ErrorMessage = "invalid")] .

Sé que la marca /i para una expresión regular de Javascript se usa para que no se distinga entre mayúsculas y minúsculas, pero simplemente pegarla al final de mi expresión regular (es decir, @"^....$/i" no funciona, la expresión regular) La validación falla completamente, independientemente de lo que se ingrese (válido o no).

¿Qué me estoy perdiendo?

Answer 1

En C # puedes alinear algunas opciones de expresiones regulares. Para especificar la opción de ignorar el caso, debe agregar (?i) al principio de su patrón. Sin embargo, no estoy seguro de cómo trataría esto con RegularExpressionAttribute y si maneja la traducción para el lado del cliente. Desde mi experiencia con RegularExpressionValidator de ASP.NET lo dudo; la expresión regular debe ser lo suficientemente vainilla para que funcione con ambos motores.

En cualquier caso si fuera válido se vería así:

@"^(?i)(?:/b(?:/d{5}(?:/s*-/s*/d{5})?|([A-Z]{2})/d{3}(?:/s*-/s*/1/d{3})?)(?:,/s*)?)+$"

Answer 2

He creado este atributo que le permite especificar RegexOptions. EDITAR: También se integra con la validación discreta. El cliente solo obedecerá RegexOptions.Multiline y RegexOptions.IgnoreCase ya que eso es lo que soporta JavaScript.

[RegularExpressionWithOptions(@".+@example/.com", RegexOptions = RegexOptions.IgnoreCase)]

DO#

public class RegularExpressionWithOptionsAttribute : RegularExpressionAttribute, IClientValidatable
{
    public RegularExpressionWithOptionsAttribute(string pattern) : base(pattern) { }

    public RegexOptions RegexOptions { get; set; }

    public override bool IsValid(object value)
    {
        if (string.IsNullOrEmpty(value as string))
            return true;

        return Regex.IsMatch(value as string, "^" + Pattern + "$", RegexOptions);
    }

    public IEnumerable<System.Web.Mvc.ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
    {
        var rule = new ModelClientValidationRule
        {
            ErrorMessage = FormatErrorMessage(metadata.DisplayName),
            ValidationType = "regexwithoptions"
        };

        rule.ValidationParameters["pattern"] = Pattern;

        string flags = "";
        if ((RegexOptions & RegexOptions.Multiline) == RegexOptions.Multiline)
            flags += "m";
        if ((RegexOptions & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
            flags += "i";
        rule.ValidationParameters["flags"] = flags;

        yield return rule;
    }
}

JavaScript

(function ($) {

    $.validator.unobtrusive.adapters.add("regexwithoptions", ["pattern", "flags"], function (options) {
        options.messages[''regexwithoptions''] = options.message;
        options.rules[''regexwithoptions''] = options.params;
    });

    $.validator.addMethod("regexwithoptions", function (value, element, params) {
        var match;
        if (this.optional(element)) {
            return true;
        }

        var reg = new RegExp(params.pattern, params.flags);
        match = reg.exec(value);
        return (match && (match.index === 0) && (match[0].length === value.length));
    });

})(jQuery);

Este artículo de Anthony Stevens me ayudó a poner esto en funcionamiento: ASP.NET MVC 3 Validación de JavaScript discreta con validadores personalizados

Answer 3

private const String regex = @"^(?:/b(?:/d{5}(?:/s*-/s*/d{5})?|([a-zA-Z]{2})/d{3}(?:/s*-/s*/1/d{3})?)(?:,/s*)?)+$";