c# - solo - probar expresiones regulares
¿Cómo puedo obtener una expresión regular para comprobar que una cadena solo contiene caracteres alfa[az] o[AZ]? (7)
Estoy intentando crear una expresión regular para verificar que una cadena dada solo tenga caracteres alfa az o AZ.
Hecho fácilmente como muchos de los otros han indicado usando lo que se conoce como "clases de caracteres". Esencialmente, estos nos permiten especificar un rango de valores para usar para la comparación: (NOTA: para simplificar, asumo los anclajes implícitos ^ y $ que se explican más adelante en esta publicación)
[az] Coincide con cualquier letra minúscula individual.
Ej: un partido, 8 no coincide
[AZ] Coincide con cualquier letra mayúscula individual.
Ej: A coincide, a no coincide.
[0-9] Une cualquier dígito con cero a nueve
ex: 8 partidos, un no coincide
[aeiou] Hacer coincidir solo en a o e o i o o o u. ex: o partidos, z no coincide
[a-zA-Z] Haga coincidir cualquier minúscula individual O mayúscula. Ej: A partidos, partidos, 3 no coinciden.
Naturalmente, también se pueden negar: [^ az] Coincidir con cualquier cosa que NO sea una letra minúscula, ej.
[^ AZ] Coincide con cualquier cosa que NO sea una letra mayúscula, por ejemplo: 5 coincidencias, A no coincide, una coincidencia
[^ 0-9] Coincide con cualquier cosa que NO sea un número, por ejemplo: 5 no coincide, A coincide, a coincide
[^ Aa69] Coincide con cualquier cosa siempre que no sea A o a o 6 o 9 ej .: 5 coincidencias, A no coincida, no coincida, 3 coincidencias
Para ver algunas clases de caracteres comunes, vaya a: http://www.regular-expressions.info/reference.html
La cadena puede tener hasta 25 letras de largo. (No estoy seguro si las expresiones regulares pueden verificar la longitud de las cadenas)
Absolutamente puede verificar la "longitud" pero no de la forma que pueda imaginar. Medimos la repetición, NO la longitud estrictamente hablando usando {}:
a {2} une dos a juntas.
Ej: a no coincide, aa coincide, aca no coincide
4 {3} une tres 4 juntos. ex: 4 no coincide, 44 no coincide, 444 coincidencias, 4434 no coincide
La repetición tiene valores que podemos establecer para tener límites inferior y superior:
un {2,} coincide en dos o más a juntas. Ej: a no coincide, aa coincide, aaa coincide, aba no coincide, aaaaaaaaa coincide
a {2,5} Match en dos a cinco a. Ej: a no coincide, aa coincide, aaa coincide, aba no coincide, aaaaaaaaa no coincide
La repetición se extiende a las clases de caracteres, por lo que: [az] {5} Une los cinco caracteres en minúscula. Ej: partidos bubba, Bubba no coincide, BUBBA no coincide, coincidencias asdjo
[AZ] {2,5} Une dos a cinco mayúsculas juntos. ej: bubba no coincide, Bubba no coincide, BUBBA coincide, BUBBETTE no coincide
[0-9] {4,8} Une cuatro a ocho números juntos. Ej: bubba no coincide, 15835 coincidencias, 44 no coincide, 3456876353456 no coincide
[a3g] {2} Haz coincidir una a OR 3 OR g si aparecen dos veces juntas. ej .: coincidencias aa, ba no coincide, 33 coincidencias, 38 no coinciden, a3 NO coincide
Ahora veamos su expresión regular: [^ az] | [^ AZ] Traducción: haga coincidir cualquier cosa siempre que NO sea una letra minúscula O una letra mayúscula.
Para solucionarlo de modo que satisfaga sus necesidades, lo reescribiríamos así: Paso 1: elimine la negación [az] | [AZ] Traducción: encuentre cualquier letra minúscula O mayúscula.
Paso 2: Si bien no es estrictamente necesario, limpiemos un poco la lógica OR [a-zA-Z] Traducción: encuentre cualquier letra en minúscula O mayúscula. Igual que el anterior pero ahora usa solo un conjunto de [].
Paso 3: Ahora indiquemos "longitud" [a-zA-Z] {1,25} Traducción: encuentre cualquier letra en minúscula O mayúscula repetida de una a veinticinco veces.
Aquí es donde las cosas se ponen de moda. Podría pensar que se hizo aquí y que podría depender de la tecnología que esté utilizando.
En sentido estricto, la expresión regular [a-zA-Z] {1,25} coincidirá con una a veinticinco letras mayúsculas o minúsculas EN CUALQUIER LUGAR en una línea:
[a-zA-Z] {1,25} partidos, partidos aZgD, partidos BUBBA, 243242hello242552 PARTIDOS
De hecho, todos los ejemplos que he dado hasta ahora harán lo mismo. Si eso es lo que desea, entonces está en buena forma, pero según su pregunta, supongo que SOLO desea letras de mayúsculas y minúsculas de una a veinticinco en toda la línea. Para eso nos dirigimos a los anclajes. Los anclajes nos permiten especificar esos molestos detalles:
^ comienzo de una linea
(Lo sé, acabamos de usar esto para la negación antes, no me hagas empezar)
$ fin de linea
Podemos usarlos así:
^ a {3} Desde el principio de la línea, haz coincidir tres veces, ej: aaa coincidencias, 123aaa no coincide, aaa123 coincidencias
a {3} $ Combina tres veces al final de una línea, ej: aaa coincidencias, 123aaa coincidencias, aaa123 no coincide
^ a {3} $ Combina tres veces para la línea ENTERA ej .: aaa coincide, 123aaa no coincide, aaa123 no coincide
Tenga en cuenta que aaa coincide en todos los casos porque tiene tres a al principio y al final de la línea técnicamente hablando.
Entonces, la solución final, técnicamente correcta, para encontrar una "palabra" que tenga "hasta cinco caracteres de longitud" en una línea sería:
^ [a-zA-Z] {1,25} $
La parte original es que algunas tecnologías ponen de manera implícita anclas en la expresión regular para usted y otras no. Solo tienes que probar tu expresión regular o leer los documentos para ver si tienes anclas implícitas.
Estoy intentando crear una expresión regular para verificar que una cadena dada solo tenga caracteres alfa az o AZ. La cadena puede tener hasta 25 letras de largo. (No estoy seguro si las expresiones regulares pueden verificar la longitud de las cadenas)
Ejemplos:
1. "abcdef" = true;
2. "a2bdef" = false ;
3. "333" = false;
4. "j" = true;
5. "aaaaaaaaaaaaaaaaaaaaaaaaaa" = false; // 26 letras
Esto es lo que tengo hasta ahora ... aunque no puedo entender qué es lo que está mal.
Regex alphaPattern = new Regex("[^az]|[^AZ]");
Pensaría que eso significaría que la cadena podría contener solo letras mayúsculas o minúsculas de az, pero cuando la asocio a una cadena con todas las letras, devuelve falso ...
Además, cualquier sugerencia sobre la eficiencia del uso de expresiones regulares frente a otros métodos de verificación sería muy apreciada.
La cadena puede tener hasta 25 letras de largo. (No estoy seguro si las expresiones regulares pueden verificar la longitud de las cadenas)
Las expresiones regulares pueden verificar la longitud de una cadena, como se puede ver en las respuestas publicadas por otros.
Sin embargo, cuando está validando una entrada de usuario (por ejemplo, un nombre de usuario), le aconsejo que haga esa comprobación por separado.
El problema es que la expresión regular solo puede decirle si una cadena coincide o no. No dirá por qué no coincide. ¿El texto era demasiado largo o contenía caracteres no permitidos? No se puede decir. Está lejos de ser amigable, cuando un programa dice: "El nombre de usuario provisto contenía caracteres no válidos o era demasiado largo". En su lugar, debe proporcionar mensajes de error separados para diferentes situaciones.
¿Entiendo correctamente que solo puede contener letras mayúsculas o minúsculas?
new Regex("^([a-z]{1,25}|[A-Z]{1,25})$")
Una expresión regular parece ser lo correcto para este caso.
Por cierto, el caret ("^") en el primer lugar dentro de una clase de carácter significa "no", por lo que " [^az]|[^AZ] " significaría "no cualquier letra minúscula, ni ninguna letra mayúscula "(sin tener en cuenta que az no son todas las letras).
Existen excelentes herramientas interactivas para desarrollar y probar expresiones de expresiones regulares:
- Regex Buddy - € 30
- Regex Coach - gratis
Son de gran ayuda porque le informan de inmediato si su expresión funciona como se esperaba e incluso le permiten pasar y depurar.
La expresión regular que está utilizando es una alternancia de [^az] y [^AZ] . Y las expresiones [^…] significan que coinciden con cualquier carácter distinto de los descritos en el conjunto de caracteres.
Así que, en general, su expresión significa que debe coincidir con cualquier otro carácter distinto de az o distinto de AZ .
Pero necesitas una expresión regular que coincida solo con a-zA-Z :
[a-zA-Z]
Y para especificar la longitud de eso, ancla la expresión con el inicio ( ^ ) y el final ( $ ) de la cadena y describe la longitud con el cuantificador { n , m } , lo que significa al menos n pero no más de m repeticiones:
^[a-zA-Z]{0,25}$
/// <summary>
/// Checks if string contains only letters a-z and A-Z and should not be more than 25 characters in length
/// </summary>
/// <param name="value">String to be matched</param>
/// <returns>True if matches, false otherwise</returns>
public static bool IsValidString(string value)
{
string pattern = @"^[a-zA-Z]{1,25}$";
return Regex.IsMatch(value, pattern);
}
Regex lettersOnly = new Regex("^[a-zA-Z]{1,25}$");
-
^significa "comenzar a coincidir al comienzo de la cadena" -
[a-zA-Z]significa "coincidir con minúsculas y mayúsculas az" -
{1,25}significa "coincide con el elemento anterior (la clase de caracteres, ver arriba) 1 a 25 veces" -
$significa "solo coincide si el cursor está al final de la cadena"