Expresión regular para caracteres alfanuméricos y de subrayado

Me gustaría tener una expresión regular que compruebe si una cadena contiene solo letras mayúsculas y minúsculas, números y guiones bajos.

Para hacer coincidir una cadena que contenga solo esos caracteres (o una cadena vacía), intente

"^[a-zA-Z0-9_]*$" 

Esto funciona para expresiones regulares de .NET, y probablemente también para muchos otros lenguajes.

Rompiéndolo:

 ^ : start of string [ : beginning of character group az : any lowercase letter AZ : any uppercase letter 0-9 : any digit _ : underscore ] : end of character group * : zero or more of the given characters $ : end of string 

Si no quiere permitir cadenas vacías, use + en lugar de *.

EDITAR Como otros han señalado, algunos idiomas regex tienen una forma abreviada de [a-zA-Z0-9_] . En el lenguaje regex de .NET, puede activar el comportamiento de ECMAScript y usar \w como una abreviatura (rindiendo ^\w*$ o ^\w+$ ). Tenga en cuenta que en otros idiomas, y de forma predeterminada en .NET, \w es algo más amplio, y también coincidirá con otros tipos de caracteres Unicode (gracias a Jan por señalar esto). Entonces, si realmente pretendes hacer coincidir solo esos caracteres, probablemente sea mejor usar la forma explícita (más larga).

Hay mucha verborrea aquí, y estoy profundamente en contra, así que mi respuesta definitiva sería:

 /^\w+$/ 

\w es equivalente a [A-Za-z0-9_] , que es más o menos lo que quieres. (a menos que introduzcamos Unicode en la mezcla)

Usando el cuantificador + coincidirá con uno o más caracteres. Si también quieres aceptar una cadena vacía, usa * lugar.

Desea verificar que cada personaje coincida con sus requisitos, por lo que usamos:

 [A-Za-z0-9_] 

E incluso puedes usar la versión abreviada:

 \w 

Lo cual es equivalente (en algunos sabores de expresiones regulares, así que asegúrese de verificar antes de usarlo). Luego, para indicar que toda la cadena debe coincidir, utiliza:

 ^ 

Para indicar que la cadena debe comenzar con ese carácter, luego use

 $ 

Para indicar que la cadena debe terminar con ese carácter. Entonces usa

 \w+ or \w* 

Para indicar “1 o más”, o “0 o más”. Poniéndolo todo junto, tenemos:

 ^\w*$ 

Aunque es más prolijo que \w , personalmente aprecio la legibilidad de los nombres completos de las clases de caracteres POSIX ( http://www.zytrax.com/tech/web/regex.htm#special ), así que diría:

 ^[[:alnum:]_]+$ 

Sin embargo, aunque la documentación en los enlaces anteriores indica que \w “Coincidirá con cualquier carácter en el rango 0 – 9, A – Z y a – z (equivalente a POSIX [: alnum:])”, no he encontrado esto ser cierto. No con grep -P todos modos. [:alnum:] incluir explícitamente el guión bajo si usa [:alnum:] pero no si usa \w . No puedes vencer a los siguientes por cortos y dulces:

 ^\w+$ 

Junto con la legibilidad, el uso de las clases de caracteres POSIX ( http://www.regular-expressions.info/posixbrackets.html ) significa que su expresión regular puede funcionar en cadenas que no sean ASCII, que las expresiones regulares basadas en rangos no harán ya que dependen de el orden subyacente de los caracteres ASCII que puede ser diferente de otros juegos de caracteres y, por lo tanto, excluirá algunos caracteres que no son ASCII (letras como œ) que puede querer capturar.

Um … pregunta: ¿Necesita tener al menos un carácter o no? ¿Puede ser una cadena vacía?

 ^[A-Za-z0-9_]+$ 

Hará por lo menos un mayúsculo o un alfanumérico en mayúscula o minúscula. Si puede ser de longitud cero, simplemente sustituya el + por *

 ^[A-Za-z0-9_]*$ 

Editar:

Si es necesario incluir signos diacríticos (como cedilla – ç), entonces necesitarás usar la palabra carácter que hace lo mismo que la anterior, pero incluye los caracteres diacríticos:

 ^\w+$ 

O

 ^\w*$ 

En Informática, un valor alfanumérico a menudo significa que el primer carácter no es un número, sino que es un alfabeto o guión bajo. A partir de entonces, el carácter puede ser 0-9 , AZ , az o guión bajo ( _ ).

Aquí es cómo lo harías:

Probado bajo php:

 $regex = '/^[A-Za-z_][A-Za-z\d_]*$/' 

o toma esto

 ^[A-Za-z_][A-Za-z\d_]*$ 

y colocarlo en tu lenguaje de desarrollo.

Qué tal si:

 ^([A-Za-z]|[0-9]|_)+$ 

… si quieres ser explícito, o:

 ^\w+$ 

… si prefieres conciso (syntax Perl).

use lookaheads para hacer las cosas “al menos una”. Confía en mí es mucho más fácil.

Aquí hay un ejemplo que requeriría de 1 a 10 caracteres, que contiene al menos un dígito y una letra:

 ^(?=.*\d)(?=.*[A-Za-z])[A-Za-z0-9]{1,10}$ 

NOTA: podría haber usado \ w pero luego entran en juego las consideraciones ECMA / Unicode aumentando la cobertura de caracteres del carácter de palabra “w”.

Prueba estas extensiones multilingües que he creado para la cadena.

IsAlphaNumeric – La cadena debe contener al menos 1 alfa (letra en el rango Unicode, especificada en charSet) y al menos 1 número (especificado en numSet). Además, la cadena debe comprender solo alfa y números.

IsAlpha – String debe contener al menos 1 alfa (en el idioma charSet especificado) y comprender solo alfa.

IsNumeric – String debe contener al menos 1 número (en el idioma numSet especificado) y comprender solo un número.

Se puede especificar el rango charSet / numSet para el idioma deseado. Los rangos de Unicode están disponibles en el siguiente enlace:

http://www.ssec.wisc.edu/~tomw/java/unicode.html

API:

  public static bool IsAlphaNumeric(this string stringToTest) { //English const string charSet = "a-zA-Z"; const string numSet = @"0-9"; //Greek //const string charSet = @"\u0388-\u03EF"; //const string numSet = @"0-9"; //Bengali //const string charSet = @"\u0985-\u09E3"; //const string numSet = @"\u09E6-\u09EF"; //Hindi //const string charSet = @"\u0905-\u0963"; //const string numSet = @"\u0966-\u096F"; return Regex.Match(stringToTest, @"^(?=[" + numSet + @"]*?[" + charSet + @"]+)(?=[" + charSet + @"]*?[" + numSet + @"]+)[" + charSet + numSet +@"]+$").Success; } public static bool IsNumeric(this string stringToTest) { //English const string numSet = @"0-9"; //Hindi //const string numSet = @"\u0966-\u096F"; return Regex.Match(stringToTest, @"^[" + numSet + @"]+$").Success; } public static bool IsAlpha(this string stringToTest) { //English const string charSet = "a-zA-Z"; return Regex.Match(stringToTest, @"^[" + charSet + @"]+$").Success; } 

Uso:

  //English string test = "AASD121asf"; //Greek //string test = "Ϡϛβ123"; //Bengali //string test = "শর৩৮"; //Hindi //string test = @"क़लम३७ख़"; bool isAlphaNum = test.IsAlphaNumeric(); 

La siguiente expresión regular coincide con caracteres alfanuméricos y guiones bajos:

 ^[a-zA-Z0-9_]+$ 

Por ejemplo, en Perl:

 #!/usr/bin/perl -w my $arg1 = $ARGV[0]; # check that the string contains *only* one or more alphanumeric chars or underscores if ($arg1 !~ /^[a-zA-Z0-9_]+$/) { print "Failed.\n"; } else { print "Success.\n"; } 

Para mí había un problema en el sentido de que quería distinguir entre alfa, numérico y alfanumérico, así que para asegurar que una cadena alfanumérica contiene al menos un alfa y al menos un numérico, utilicé:

 ^([a-zA-Z_]{1,}\d{1,})+|(\d{1,}[a-zA-Z_]{1,})+$ 

Para aquellos de ustedes que buscan la coincidencia alfanumérica Unicode, es posible que desee hacer algo como:

 ^[\p{L} \p{Nd}_]+$ 

Lectura adicional en http://unicode.org/reports/tr18/ y en http://www.regular-expressions.info/unicode.html

Aquí está la expresión regular de lo que quiere con un cuantificador para especificar al menos 1 carácter y no más de 255 caracteres

[^ a-zA-Z0-9 _] {1,255}

La coincidencia de diacríticos en una expresión regular abre una lata de gusanos, especialmente cuando se toma en cuenta Unicode. Es posible que desee leer sobre las configuraciones regionales de Posix en particular.

Para verificar la cadena completa y no permitir cadenas vacías, intente

 ^[A-Za-z0-9_]+$ 

esto funciona para mí, puedes probar [\ p {Alnum} _]

^ \ w * $ funcionará para la siguiente combinación 1 123 1av pRo av1