Expresión regular para alfanuméricos y guiones bajos

585

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


fuente
99
Es una pena que los diferentes motores regex tengan diferentes medios para combinar alfanuméricos. Una pregunta como esta (bastante vaga, sin lenguaje / sabor de expresión regular indicada) requiere una respuesta muy larga, o al menos muy organizada, que se concentra en cada sabor.
Wiktor Stribiżew

Respuestas:

939

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

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

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

Desglosándolo:

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

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


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

Charlie
fuente
8
Si alguna vez vas a Alemania o si ves casi cualquier texto en alemán, verás lo que estoy diciendo.
Programador de Windows el
30
\ w y [A-Za-z0-9_] no son equivalentes en la mayoría de los sabores de expresiones regulares. \ w incluye letras con
signos
44
La pregunta original decía "letras mayúsculas y minúsculas", por lo que parecería que las "letras" de los scripts no latinos deberían coincidir.
Trejkaz
3
[\p{upper}\p{lower}\p{gc=Number}_]es todo lo que necesita para hacer esto correctamente, suponiendo que no haya caracteres combinados.
tchrist
1
Parece que preg_match requiere que su patrón esté encerrado con delimitadores, que normalmente son barras inclinadas. Entonces necesitaría "/ ^ [a-zA-Z0-9 _] * $ /". Consulte esta pregunta para obtener más información: stackoverflow.com/questions/6445133/… . Vea también esta página: forums.phpfreaks.com/topic/…
Charlie
346

Hay mucha verbosidad aquí, y estoy profundamente en contra de eso, entonces, mi respuesta concluyente sería:

/^\w+$/

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

Usando el +cuantificador unirás uno o más caracteres. Si también quieres aceptar una cadena vacía, *úsala.

kch
fuente
67
\wgeneralmente no está restringido a ASCII solo.
tchrist
26
El inglés no es el único idioma en el mundo, por lo que esta debería ser la respuesta aceptada, no la [a-z]y sus variaciones. \wcapturará también caracteres no latinos. Me gusta šēēāoкукареку
Alex
1
Validado en la página 318 de O'Reilly "Mastering Regular Expressions"
guidotex
36

Desea verificar que cada personaje coincida con sus requisitos, por eso utilizamos:

[A-Za-z0-9_]

E incluso puedes usar la versión abreviada:

\w

Lo que 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, utilice:

^

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

$

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

\w+ or \w*

Para indicar "1 o más" o "0 o más". Poniendo todo junto, tenemos:

^\w*$
Anton
fuente
10
\ w y [A-Za-z0-9_] no son equivalentes en la mayoría de los sabores de expresiones regulares. \ w incluye letras con
signos
32

Um ... pregunta: ¿Necesita tener al menos un personaje o no? ¿Puede ser una cadena vacía?

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

Hará al menos una letra mayúscula o minúscula alfanumérica o de subrayado. Si puede ser de longitud cero, entonces simplemente sustituya el + por *

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

Editar:

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

^\w+$

O

^\w*$
BenAlabastro
fuente
Bueno, ahora que lo mencionas, también extrañé un montón de otros personajes franceses ...
BenAlabaster
1
\ w es lo mismo que [\ w] con menos esfuerzo de tipeo
Jan Goyvaerts
Sí, todavía necesita el + o * y el ^ y $ - \ w solo comprueba que contiene caracteres de palabras, no que solo contenga caracteres de palabras ...
BenAlabaster
Curiosamente, esto todavía permite el signo $.
Induster
@Induster, es por lo que BenAlabaster acaba de señalar
Sebas el
27

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

^[[:alnum:]_]+$

Sin embargo, aunque la documentación en los enlaces anteriores establece que \w"coincidirá con cualquier carácter en el rango 0 - 9, A - Z y a - z (equivalente a POSIX [: alnum:])", no he encontrado que esto sea cierto . No con de grep -Ptodos modos. Debe incluir explícitamente el guión bajo si lo usa, [:alnum:]pero no si lo usa \w. No se puede superar lo siguiente en pocas palabras:

^\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 son ASCII, lo que las expresiones regulares basadas en rango no harán, ya que dependen el orden subyacente de los caracteres ASCII que puede ser diferente de otros juegos de caracteres y, por lo tanto, excluirá algunos caracteres no ASCII (letras como œ) que quizás desee capturar.

Día Davis Waterbury
fuente
22

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

Así es como 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 colóquelo en su lenguaje de desarrollo.

Danuel O'Neal
fuente
17

Qué tal si:

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

... si quieres ser explícito, o:

^\w+$

... si prefiere conciso (sintaxis de Perl).

Drew Hall
fuente
12

use lookaheads para hacer "al menos uno". Confía en mí, es mucho más fácil.

Aquí hay un ejemplo que requeriría 1-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 consideraciones ECMA / Unicode que aumentan la cobertura de caracteres del \ w "carácter de palabra".

boooloooo
fuente
¿Cómo lo haríamos si queremos agregar _ y - a la lista?
Rahi
10

Pruebe estas extensiones multilingües que he hecho para string.

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

IsAlpha: la cadena debe contener al menos 1 alfa (en el lenguaje charSet especificado) y debe contener solo alfa.

IsNumeric: la cadena debe contener al menos 1 número (en el idioma numSet especificado) y debe contener solo números.

Se puede especificar el rango charSet / numSet para el idioma deseado. Las gamas 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();
Shantanu
fuente
@ Shah: he agregado los únicos alfabetos (y solo los números también).
Shantanu
8

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";
}
Arrendajo
fuente
El patrón en su código es correcto, pero el patrón anterior solo verifica una sola instancia.
BenAlabaster
Eso fue intencional, la muestra de código fue pensada como un uso clarificador para verificar realmente una cadena. También por qué el código tiene los marcadores de inicio y final de línea, que no están en el ejemplo de expresiones regulares.
Jay
1
@Windows programmer - en.wikipedia.org/wiki/Alphanumeric - alfabeto latino , no "juego de caracteres latinos", que es lo que incluye diacríticos, etc. 0-9.
Jay
2
ñ es una letra del alfabeto en español, incluso en América Latina.
Programador de Windows el
2
"Me gustaría tener una expresión regular que verifique si una cadena contiene solo letras mayúsculas y minúsculas, números y guiones bajos" no lo limita a letras latinas. "La siguiente expresión regular coincide con caracteres alfanuméricos y guiones bajos" no lo limita a letras latinas. "^ [a-zA-Z0-9 _] + $" falla.
Programador de Windows el
6

Esto debería funcionar en la mayoría de los casos.

/^[\d]*[a-z_][a-z\d_]*$/gi

Y por la mayoría quiero decir,

abcd       True
abcd12     True
ab12cd     True
12abcd     True

1234       False


Explicación

  1. ^ ... $ - coincide con el patrón que comienza y termina con
  2. [\d]* - coincide con cero o más dígitos
  3. [a-z_] - unir un alfabeto o un guión bajo
  4. [a-z\d_]* - coincide con un alfabeto o dígito o guión bajo
  5. /gi - coincide globalmente a través de la cadena y no distingue mayúsculas de minúsculas
Chinmaya Pati
fuente
2
La pregunta original no requería que la carta estuviera presente.
Dmitry Kuzminov
¿De qué carta estás hablando? Mi expresión regular contiene la que se hizo en la pregunta. Alfabetos, números, guiones bajos
Chinmaya Pati
Esta 1234es la palabra del idioma solicitado por el autor. Tu idioma es más restrictivo.
Dmitry Kuzminov
4

Para mí hubo un problema en el que quería distinguir entre alfa, numérico y alfa numérico, por lo que para garantizar que una cadena alfanumérica contenga al menos un alfa y al menos un numérico, utilicé:

^([a-zA-Z_]{1,}\d{1,})+|(\d{1,}[a-zA-Z_]{1,})+$
mylesmckeown
fuente
Exactamente lo que quiero ... Gracias
Aniket kale
3

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

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

Creo que no estás tomando caracteres latinos y Unicode en tus partidos. Por ejemplo, si necesita tomar caracteres "ã" o "ü", el uso de "\ w" no funcionará.

Alternativamente, puede usar este enfoque:

^[A-ZÀ-Ýa-zà-ý0-9_]+$

¡Espero eso ayude!

Marcio Martins
fuente
1

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

^[A-Za-z0-9_]+$
David Norman
fuente
1

^\w*$ funcionará para las siguientes combinaciones

1
123
1av
pRo
av1
Mukund
fuente
¿Qué pasa con una línea vacía? ¿Es también una cadena alfanumérica?
v010dya
0

esto funciona para mí puedes probar

[\\p{Alnum}_]
Saurabh
fuente
0

Esto funciona para mí, encontré esto en "Dominar expresiones regulares" de O'Reilly:

/^\w+$/

Explicación:

  • ^ afirma la posición al comienzo de la cadena
    • \ w + coincide con cualquier carácter de palabra (igual a [a-zA-Z0-9_])
    • Cuantificador "+": coincide entre una e ilimitadas veces, tantas veces como sea posible, devolviendo según sea necesario (codicioso)
  • $ afirma la posición al final de la cadena

Verifícate a ti mismo:

const regex = /^\w+$/;
const str = `nut_cracker_12`;
let m;

if ((m = regex.exec(str)) !== null) {
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

Mihir Kumar
fuente