Expresión regular para alfanuméricos y guiones bajos

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.

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).

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.

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*$

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*$

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.

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.

Qué tal si:

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

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

^\w+$

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

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".

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();

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";
}

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

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,})+$

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}

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

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

Más información en http://unicode.org/reports/tr18/ y en http://www.regular-expressions.info/unicode.html

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!

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

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

^\w*$ funcionará para las siguientes combinaciones

1
123
1av
pRo
av1

esto funciona para mí puedes probar

[\\p{Alnum}_]

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}`);
    });
}