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.
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.
Respuestas:
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 \w
como una abreviatura (rendimiento ^\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 tiene la intención de hacer coincidir solo esos caracteres, probablemente sea mejor usar la forma explícita (más larga).
[\p{upper}\p{lower}\p{gc=Number}_]
es todo lo que necesita para hacer esto correctamente, suponiendo que no haya caracteres combinados.
Hay mucha verbosidad aquí, y estoy profundamente en contra de eso, entonces, mi respuesta concluyente 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 a la mezcla)
Usando el +
cuantificador unirás uno o más caracteres. Si también quieres aceptar una cadena vacía, *
úsala.
\w
generalmente no está restringido a ASCII solo.
[a-z]
y sus variaciones. \w
capturará también caracteres no latinos. Me gusta šēēā
oкукареку
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 -P
todos 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-z
o 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.
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
^ ... $
- coincide con el patrón que comienza y termina con[\d]*
- coincide con cero o más dígitos[a-z_]
- unir un alfabeto o un guión bajo[a-z\d_]*
- coincide con un alfabeto o dígito o guión bajo/gi
- coincide globalmente a través de la cadena y no distingue mayúsculas de minúsculas1234
es la palabra del idioma solicitado por el autor. Tu idioma es más restrictivo.
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,})+$
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_]+$
Esto funciona para mí, encontré esto en "Dominar expresiones regulares" de O'Reilly:
/^\w+$/
Explicación:
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}`);
});
}