¿Cuáles son los controles del servidor de verificación?
RequiredFieldValidator (elemento requerido);
CompareValidator (comparación con un valor determinado);
RangeValidator (verificación de rango);
RegularExpressionValidator); (coincidencia de patrones);
CustomValidator (definido por el usuario);
El control ValidationSummary se utiliza para mostrar un resumen de todos los errores de validación en línea en una página web, un cuadro de mensaje o ambos
p>
El control RequiredFieldValidator comprueba si hay cadenas que no estén vacías de forma predeterminada (los espacios no se cuentan). Si ingresa caracteres en el campo de formulario asociado con RequiredFieldValidator, el control RequiredFieldValidator no mostrará su mensaje de error de validación.
El control RequiredFieldValidator se utiliza para requerir que los usuarios ingresen valores para los campos del formulario antes de enviar el formulario. Cuando se utiliza el control Required-FieldValidator, se deben establecer dos propiedades importantes:
ControlToValidate: el ID del campo del formulario que se está validando.
Texto: el mensaje de error que se muestra cuando falla la verificación.
El control RangeValidator se utiliza para detectar si el valor de un campo de formulario está entre los valores mínimo y máximo especificados. Al utilizar este control, se deben establecer 5 propiedades:
ControlToValidate: el ID del campo del formulario que se está validando.
Texto: el mensaje de error que se muestra cuando falla la verificación.
MinimumValue: el valor mínimo del rango de validación.
MaximumValue: el valor máximo del rango de validación.
Tipo: el tipo de comparación realizada. Los valores posibles son Cadena, Entero, Doble, Fecha y Moneda.
El control CompareValidator se puede utilizar para realizar tres tipos diferentes de tareas de validación. La detección del tipo de datos se puede realizar utilizando CompareValidator. En otras palabras, puede usarlo para determinar si el usuario ingresó un valor del tipo correcto en un campo de formulario, como ingresar una fecha en un campo de datos de cumpleaños.
También puede utilizar el control CompareValidator para comparar el valor de un campo de formulario de entrada con un valor fijo. Por ejemplo, si desea crear un sitio web de subastas, puede utilizar CompareValidator para comprobar si el nuevo precio inicial es mayor que el precio inicial anterior.
Finalmente, puede utilizar el control CompareValidator para comparar el valor de un campo de formulario con el valor de otro campo de formulario. Por ejemplo, puede utilizar el control CompareValidator para comprobar si el valor de la fecha de inicio de la reunión ingresado es menor que el valor de la fecha de finalización de la reunión ingresado.
El control CompareValidator tiene 6 propiedades importantes:
ControlToValidate: el ID del campo del formulario que se está validando.
Texto: el mensaje de error que se muestra cuando falla la verificación.
Tipo: el tipo de datos a comparar. Los valores posibles son Cadena, Entero, Doble, Fecha y Moneda.
Operador: el tipo de comparación realizada. Los valores posibles son DataTypeCheck, Equal, GreaterThan, Greater-ThanEqual, LessThan, LessThanEqual y NotEqual.
ValueToCompare: el valor fijo que se compara.
ControlToCompare: el ID del control que se está comparando.
El control RegularExpressionValidator se utiliza para comparar valores de campos de formulario con expresiones regulares.
Se pueden utilizar expresiones regulares para representar patrones de cadenas, como direcciones de correo electrónico, números de seguridad social, números de teléfono, fechas, números de moneda y códigos de producto.
Se pueden ingresar expresiones regulares en este control ValidationExpression para controlar los caracteres ingresados por el usuario. Las expresiones regulares tienen muchos usos. Específicamente, puede encontrar algunas expresiones regulares de uso común en Internet.
Solo se pueden ingresar números: "^[0-9]*$".
Sólo se pueden introducir números de n dígitos: "^\d{n}$".
Solo se pueden ingresar números con al menos n dígitos: "^\d{n,}$".
Sólo se pueden introducir m~n números:. "^\d{m,n}$"
Solo se pueden ingresar números que comiencen con cero y distintos de cero: "^(0|[1-9][0-9]*)$" .
Sólo se pueden introducir números reales positivos con dos decimales: "^[0-9]+(.[0-9]{2})?$".
Sólo se pueden introducir números reales positivos con 1 a 3 decimales: "^[0-9]+(.[0-9]{1,3})?$".
Solo se pueden ingresar números enteros positivos distintos de cero: "^\+?[1-9][0-9]*$".
Solo se pueden ingresar números enteros negativos distintos de cero: "^\-[1-9][]0-9"*$.
Sólo se pueden introducir caracteres con una longitud de 3: "^.{3}$".
Sólo se puede introducir una cadena formada por 26 letras inglesas: "^[A-Za-z]+$".
Solo se puede ingresar una cadena que consta de 26 letras mayúsculas en inglés: "^[A-Z]+$".
Solo se puede ingresar una cadena que consta de 26 letras minúsculas en inglés: "^[a-z]+$".
Solo se puede ingresar una cadena compuesta por números y 26 letras en inglés: "^[A-Za-z0-9]+$".
Solo se puede ingresar una cadena que consta de números, 26 letras en inglés o guiones bajos: "^\w+$".
Verificar contraseña de usuario: "^[a-zA-Z]\w{5,17}$" El formato correcto es: comenzando con una letra, la longitud es entre 6 y 18, y solo puede Contiene caracteres, números y guiones bajos.
Comprueba si contiene caracteres como ^%&',;=?$\": "[^%&',;=?$\x22]+".
Introduzca solo caracteres chinos: "^[\u4e00-\u9fa5]{0,}$"
Verifique la dirección de correo electrónico: "^\w+([-+.]\w+)*@\w+([ -. ]\w+)*\.\w+([-.]\w+)*$".
Número de teléfono de verificación: "^(\(\d{3,4}-)|\ d{ 3.4}-)?\d{7,8}$"El formato correcto es: "XXX-XXXXXXX", "XXXX- XXXXXXXX", "XXX-XXXXXXX", "XXX-XXXXXXXX", "XXXXXXX" y " XXXXXXXX".
Verificar número de identificación (15 o 18 dígitos): "^\d{15}|\d{18}$"
Verificar 12 meses del año. : "^(0?[1-9]|1[0-2])$" El formato correcto es: "01"～"09" y "1"～"12"
Verifica uno. El día 31 del mes: "^((0?[1-9])|((1|2)[0-9])|30|31)$" El formato correcto es "01"~"09; " y " 1"~"31".
Expresión regular del número de teléfono (admite número de teléfono móvil, código de área de 3 a 4 dígitos, número de transmisión en vivo de 7 a 8 dígitos, número de extensión de 1 a 4 dígitos) ((\d{11})|^( (\ d{7,8})|(\d{4}|\d{3})-(\d{7,8})|(\d{4}|\d{3})-(\ d{ 7,8})-(\d{4}|\d{3}|\d{2}|\d{1})|(\d{7,8})-(\d{4} |\ d{3}|\d{2}|\d{1}))$)
Utilice expresiones regulares para limitar el contenido de entrada del cuadro de texto en el formulario web:
Usar expresiones regulares El límite de expresión solo se puede ingresar en chino: onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,'')" onbeforepaste="cliPBoardData.setData('text ',clipboardData.getData('text ').replace(/[^\u4E00-\u9FA5]/g,''))"
Utilice expresiones regulares para limitar la entrada solo de caracteres de ancho completo : onkeyup="valor=valor.replace(/ [^\uFF00-\uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[ ^\uFF00-\uFFFF]/g,' '))"
Utilice expresiones regulares para limitar la entrada a números: onkeyup="value=value.replace(/[^\d]/g,' ') "onbeforepaste="clipboardData.setData( 'text',clipboardData.getData('text').replace(/[^\d]/g,''))"
Utilice expresiones regulares para limite la entrada solo a números e inglés: onkeyup= "value=value.replace(/[\W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace (/[^\d]/g, ''))"
Un programa JavaScript que utiliza expresiones regulares para extraer nombres de archivos de direcciones URL. El siguiente resultado es página1
El lo siguiente es un fragmento de referencia:
s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2")
alerta(s)
Coincidencia de caracteres de doble byte (incluidos los caracteres chinos): [^\x00-\xff]
Aplicación: Calcula la longitud de una cadena ( un carácter de doble byte se cuenta como 2, los caracteres ASCII se cuentan como 1)
El siguiente es un fragmento de referencia:
String.prototype.len=function(){return this .replace([^\x00-\xff]/g,"aa" ).length;}
Expresión regular para hacer coincidir líneas en blanco: \n[\s|
Expresión regular para coincidir con etiquetas HTML: /<(.* )>.*<\/\1>|<(.*) \/>/
Expresión regular que coincide con espacios iniciales y finales: (^\s*)|(\s*$)
El siguiente es un fragmento de referencia:
String.prototype.trim = function()
{
return this.replace(/(^\ s*)|(\s*$)/g, ""); expresiones regulares para descomponer y convertir direcciones IP:
Siguiente
El siguiente es un programa Javascript que utiliza expresiones regulares para hacer coincidir direcciones IP y convertir direcciones IP en los valores correspondientes:
El siguiente es un fragmento entre comillas:
función IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //Expresión regular que coincide con la dirección IP
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow (255,2))+ExpReg.$3*255+ExpReg.$4*1
}
else
{
tirar new Error("¡No es una dirección IP válida!")
}
}
Sin embargo, si el programa anterior no usa expresiones regulares, sino que usa directamente la función split puede ser más sencilla de descomponer, el programa es el siguiente:
El siguiente es un fragmento de referencia:
var ip="10.100.20.168"
ip=ip.split(" .")
alert("El valor de IP es: "+(ip[0]*255*255*255+ip[1]*255*255+ ip[2]*255+ip[3 ]*1))
Explicación del símbolo:
\
Marcar el siguiente carácter como carácter especial, un carácter literal, o una comilla invertida, o un carácter de escape octal. Por ejemplo, 'n' coincide con el carácter "n". '\n' coincide con un carácter de nueva línea. La secuencia '\\' coincide con "\" y "\(" coincide con "(".
^
Coincide con el comienzo de la cadena de entrada. Si Multiline del objeto RegExp es set Property, ^ también coincide con la posición después de '\n' o '\r'
$
Coincide con el final de la cadena de entrada si la propiedad Multiline del objeto RegExp es. set. $ también coincide con la posición antes de '\n' o '\r'
*
Coincide con la subexpresión anterior cero o más veces. z" y "zoo". * Equivalente a {0,}.
+
Coincide con la subexpresión anterior una o más veces. Por ejemplo, 'zo+' coincide con " zo" y "zoo", pero no "z". + Equivalente a {1,}.
Coincide con la subexpresión anterior cero o una vez. Por ejemplo, "do(es)?" do" o "does". ? Equivale a {0,1}.
{n}
n coincide con un número entero no negativo. Definitivamente n veces. Por ejemplo, 'o {2}' no puede coincidir con la 'o' en "Bob", pero puede coincidir con dos o en "comida"
{n,}
n no es negativo. entero. Coincide al menos n veces. Por ejemplo, 'o{2,}' no puede coincidir con 'o' en "Bob", pero puede coincidir con todos los 'o{ en "foooood 1,}' es equivalente a 'o+". '. 'o{0,}' es equivalente a 'o*'
{n,m}
Tanto my n son números enteros no negativos, donde n <=. m Coincide al menos n veces y como máximo m veces. Por ejemplo, "o{1,3}" coincidirá con los primeros tres 'o{0,1} en "fooooood" es equivalente a 'o?'. Tenga en cuenta que no puede haber un espacio entre la coma y los dos números
Cuando este carácter va seguido de cualquier otro limitador (*, +, ?, {n }, {n,},. {n,m}) más tarde, el patrón coincidente no es codicioso.
El modo no codicioso coincide con la menor cantidad posible de la cadena buscada, mientras que el modo codicioso predeterminado coincide con la mayor cantidad posible de la cadena buscada. Por ejemplo, para la cadena "oooo", 'o+?' coincidirá con una sola "o", mientras que 'o+' coincidirá con todas las 'o'.
.
Coincide con cualquier carácter excepto "\n". Para hacer coincidir cualquier carácter, incluido "\n", utilice un patrón como "[.\n]".
(patrón)
Haga coincidir el patrón y obtenga esta coincidencia. Las coincidencias obtenidas se pueden obtener de la colección Matches generada, utilizando la colección SubMatches en VBScript o las propiedades $0…$9 en JScript. Para hacer coincidir los caracteres entre paréntesis, utilice ’\(’ o ’\)’.
(?:pattern)
Coincide con el patrón pero no obtiene el resultado coincidente, lo que significa que se trata de una coincidencia que no se recupera y no se almacena para su uso posterior. Esto resulta útil cuando se utiliza el carácter "o" (|) para combinar partes de un patrón. Por ejemplo, 'industr(?:y|ies) es una expresión más corta que 'industria|industrias'.
(?=pattern)
Búsqueda directa, que coincide con la cadena de búsqueda al principio de cualquier patrón de coincidencia de cadena. Esta es una coincidencia sin recuperación, es decir, no es necesario recuperar la coincidencia para su uso posterior. Por ejemplo, 'Windows (?=95|98|NT|2000)' coincide con "Windows" en "Windows 2000", pero no con "Windows" en "Windows 3.1". La captación previa no consume caracteres, es decir, después de que se produce una coincidencia, la búsqueda de la siguiente coincidencia comienza inmediatamente después de la última coincidencia, en lugar de comenzar después del carácter que contiene la captación previa.
(?!pattern)
Búsqueda anticipada negativa, coincide con la cadena de búsqueda al principio de cualquier cadena que no coincida con el patrón. Esta es una coincidencia sin recuperación, es decir, no es necesario recuperar la coincidencia para su uso posterior. Por ejemplo, 'Windows (?!95|98|NT|2000)' puede coincidir con "Windows" en "Windows 3.1", pero no con "Windows" en "Windows 2000". La captación previa no consume caracteres, es decir, después de que se produce una coincidencia, la búsqueda de la siguiente coincidencia comienza inmediatamente después de la última coincidencia, en lugar de comenzar después del carácter que contiene la captación previa
x|y
Haga coincidir x o y. Por ejemplo, 'z|comida' coincide con "z" o "comida". '(z|f)ood' coincide con "zood" o "comida".
[xyz]
Colección de personajes. Coincide con cualquiera de los caracteres contenidos. Por ejemplo, '[abc]' coincide con 'a' en "normal".
[^xyz]
Una colección de caracteres negativos. Coincide con cualquier personaje no incluido. Por ejemplo, '[^abc]' coincide con 'p' en "normal".
[a-z]
Rango de caracteres. Coincide con cualquier carácter dentro del rango especificado. Por ejemplo, '[a-z]' coincide con cualquier carácter alfabético en minúscula en el rango de 'a' a 'z'.
[^a-z]
Rango de caracteres negativos. Coincide con cualquier carácter que no esté dentro del rango especificado. Por ejemplo, '[^a-z]' coincide con cualquier carácter que no esté en el rango de 'a' a 'z'.
\b
Hacer coincidir el límite de una palabra, es decir, la posición entre una palabra y un espacio. Por ejemplo, 'er\b' coincide con 'er' en "never" pero no con "er" en "verb".
\B
Hacer coincidir límites que no sean palabras.
'er\B' coincide con 'er' en "verbo", pero no con 'er' en "never". \cx
Coincide con el carácter de control especificado por x. Por ejemplo, \cM coincide con un carácter Control-M o retorno de carro. El valor de x debe ser uno de A-Z o a-z. De lo contrario, c se trata como un carácter 'c' literal.
\d
Coincide con un carácter numérico. Equivalente a [0-9].
\D
Coincide con un carácter no numérico. Equivalente a [^0-9].
\f
Coincide con un carácter de avance de formulario. Equivalente a \x0c y \cL.
\n
Coincide con un carácter de nueva línea. Equivalente a \ y \cJ.
\r
Coincide con un carácter de retorno de carro. Equivalente a \x0d y \cM.
\s
Coincide con cualquier carácter de espacio en blanco, incluidos espacios, tabulaciones, cambios de formulario, etc. Equivalente a [ \f\n\r\t\v].
\S
Coincide con cualquier carácter que no sea un espacio en blanco. Equivalente a [^ \f\n\r\t\v].
\t
Coincide con un carácter de tabulación. Equivalente a \x09 y \cI.
\v
Coincide con un carácter de tabulación vertical. Equivalente a \x0b y \cK.
\w
Coincide con cualquier carácter de palabra, incluido un guión bajo. Equivalente a '[A-Za-z0-9_]'.
\W
Coincide con cualquier carácter que no sea una palabra. Equivalente a '[^A-Za-z0-9_]'.
\xn
Coincide con n, donde n es el valor de escape hexadecimal. El valor de escape hexadecimal debe tener exactamente dos dígitos. Por ejemplo, '\x41' coincide con "A". ’\x041’ es equivalente a ’\x04’ y “1”.
La codificación ASCII se puede utilizar en expresiones regulares.
\num
Coincide con num, donde num es un entero positivo. Una referencia al partido obtenido. Por ejemplo, '(.)\1' coincide con dos caracteres idénticos consecutivos.
\n
Identifica un valor de escape octal o una referencia inversa. Si \n está precedido por al menos n subexpresiones recuperadas, n es una referencia hacia atrás. De lo contrario, si n es un número octal (0-7), entonces n es un valor de escape octal.
\nm
Identifica un valor de escape octal o una referencia inversa. Si \nm está precedido por al menos nm subexpresiones get, nm es una referencia hacia atrás. Si \nm está precedido por al menos n, n es una referencia hacia atrás seguida de un literal m. Si ninguna de las condiciones anteriores es verdadera, entonces \nm coincidirá con el valor de escape octal nm si n y m son ambos dígitos octales (0-7).
\nml
Si n es un dígito octal (0-3) y m y l son ambos dígitos octales (0-7), entonces coincide con el valor de escape octal nml.
\un
Coincide con n, donde n es un carácter Unicode representado por cuatro dígitos hexadecimales. Por ejemplo, \u00A9 coincide con el símbolo de copyright (?).
Número de teléfono móvil y expresión regular del número de teléfono
Expresión regular del número de teléfono (admite número de teléfono móvil, código de área de 3 a 4 dígitos, número de transmisión en vivo de 7 a 8 dígitos, 1- Número de extensión de 4 dígitos) ((\d{11})|^((\d{7,8})|(\d{4}|\d{3})-(\d{7,8})| (\ d{4}|\d{3})-(\d{7,8})-(\d{4}|\d{3}|\d{2}|\d{1})| (\ d{7,8})-(\d{4}|\d{3}|\d{2}|\d{1}))$)
Formato coincidente:
Número de teléfono móvil de 11 dígitos
Código de área de 3 a 4 dígitos, número de transmisión en vivo de 7 a 8 dígitos, número de extensión de 1 a 4 dígitos
Por ejemplo: 12345678901 , 1234-12345678-1234
"^\d+$" //Entero no negativo (entero positivo + 0)
"^[0-9]*[1-9 ][0-9]*$ " //Entero positivo
"^((-\d+)|())$" //Entero no positivo (entero negativo + 0)
"^-[ 0-9]*[1-9][0-9]*$" //Entero negativo
"^-?\d+$" //Entero
"^\ d+(\.\d+)?$" //Número de punto flotante no negativo (número de punto flotante positivo + 0)
"^(([0-9 ]+\.[0-9]*[1 -9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+) |([0-9]*[1-9 ][0-9]*))$" //Número de punto flotante positivo
"^((-\d+(\.\d+)? )|((\.)?) )$" //Número de punto flotante no positivo (número de punto flotante negativo + 0)
"^(-((([0-9 ]+\.[0-9]*[1-9][0 -9]*)|([0-9]*[1-9][0-9]*\.[0-9]+) |([0-9]*[1-9][0-9 ]*)))$" //Punto flotante negativo
Número
"^(-?\ d+)(\.\d+)?$" //Punto flotante
"^[A-Za-z]+$" //Una cadena que consta de 26 letras en inglés
"^[A-Z]+$" //Una cadena compuesta por 26 letras en inglés Una cadena compuesta por letras mayúsculas
"^[a-z]+$" //Una cadena compuesta por 26 letras minúsculas en inglés
"^[A-Za-z0- 9]+$" //Una cadena que consta de números y 26 letras en inglés
"^\w+$" //Una cadena que consta de números , 26 letras en inglés o guiones bajos
"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+ $" //dirección de correo electrónico
"^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*)) *(\?\S*)?$ " //url
/^13\d{9}$/gi expresión regular del número de teléfono móvil
public static bool IsValidMobileNo(string MóvilNo)
{
const string regPattern = @"^(130|131|132|133|134|135|136|137|138|139)\d{8} $";
return Regex.IsMatch(MobileNo, regPattern);
}
Expresión regular: verificar número de teléfono móvil: 13[0-9] {9}
Anteponga en su número de teléfono móvil 86 o +8
Caso 6: ^((\+86)|(86))?(13)\d{9}$
El número de teléfono y el número de teléfono móvil se verifican simultáneamente: (^(\d{3, 4 }-)?\d{7,8})$|(13[0-9]{9})
Extrae enlaces de red en la información: (h|H)(r|R) ( e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)? Extracción Dirección de correo electrónico en el mensaje:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
Extraiga el enlace de la imagen en la información: (s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('| "| *|>)?
Extrae la dirección IP en la información: (\d+)\.(\d+)\.(\d+)\.(\d+)
Extraer información El número de teléfono móvil chino en: (86)*0*13\d{9}
Extraer el número de teléfono fijo chino en la información: (\(\d{3,4}\ )|\d{ 3,4}-|\s)?\d{8}
Extraiga números de teléfono chinos (incluidos teléfonos móviles y fijos) de la información: (\(\d{3, 4}\)| \d{3,4}-|\s)?\d{7,14}
Extrae el código postal chino en la información: [1-9]{1}( \d+){5}
Extrae el número de identificación chino en la información:\d{18}|\d{15}
Extrae el número entero en la información:\d+
Extraer números de punto flotante (es decir, decimales) en el mensaje: (-?\d*)\.?\d+
Extraer cualquier número en el mensaje: (-?\d* )(\.\d+)?
Extrae la cadena china en la información: [\u4e00-\u9fa5]*
Extrae la cadena de doble byte (caracteres chinos) en la información: [^\x00-\xff ]*