Gostaria de ter uma expressão regular que verifique se uma string contém apenas letras maiúsculas e minúsculas, números e sublinhados.
Gostaria de ter uma expressão regular que verifique se uma string contém apenas letras maiúsculas e minúsculas, números e sublinhados.
Respostas:
Para corresponder a uma sequência que contém apenas esses caracteres (ou uma sequência vazia), tente
"^[a-zA-Z0-9_]*$"
Isso funciona para expressões regulares do .NET e provavelmente para muitas outras linguagens.
Dividindo:
^ : 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
Se você não deseja permitir cadeias vazias, use + em vez de *.
Como outros já apontaram, algumas línguas regex têm uma forma abreviada para [a-zA-Z0-9_]
. Na linguagem regex do .NET, você pode ativar o comportamento do ECMAScript e usá-lo \w
como atalho (produzindo ^\w*$
ou ^\w+$
). Observe que em outros idiomas, e por padrão no .NET, \w
é um pouco mais amplo e também corresponderá a outros tipos de caracteres Unicode (obrigado Jan por apontar isso). Portanto, se você realmente deseja corresponder apenas a esses caracteres, provavelmente é melhor usar o formulário explícito (mais longo).
[\p{upper}\p{lower}\p{gc=Number}_]
é tudo o que você precisa para fazer isso corretamente, presumindo que não haja caracteres combinados.
Há muita verbosidade aqui, e sou profundamente contra, portanto, minha resposta conclusiva seria:
/^\w+$/
\w
é equivalente a [A-Za-z0-9_]
, que é praticamente o que você deseja. (a menos que introduzamos unicode no mix)
Usando o +
quantificador, você corresponderá a um ou mais caracteres. Se você também deseja aceitar uma string vazia, use *
.
\w
geralmente não é restrito apenas ao ASCII.
[a-z]
variações. \w
também capturará caracteres não latinos. Gosto šēēā
ouкукареку
Você deseja verificar se cada personagem corresponde aos seus requisitos, e é por isso que usamos:
[A-Za-z0-9_]
E você pode até usar a versão abreviada:
\w
O que é equivalente (em alguns tipos de expressão regular, verifique se você o fez antes de usá-lo). Em seguida, para indicar que a sequência inteira deve corresponder, use:
^
Para indicar que a sequência deve começar com esse caractere, use
$
Para indicar que a sequência deve terminar com esse caractere. Então use
\w+ or \w*
Para indicar "1 ou mais" ou "0 ou mais". Juntando tudo, temos:
^\w*$
Um ... pergunta: ele precisa ter pelo menos um caractere ou não? Pode ser uma string vazia?
^[A-Za-z0-9_]+$
Realizará pelo menos um alfanumérico ou sublinhado em maiúsculas ou minúsculas. Se o comprimento for zero, substitua + por *
^[A-Za-z0-9_]*$
Editar:
Se for necessário incluir diacríticos (como cedilla - ç), você precisará usar a palavra caractere que faz o mesmo que o acima, mas inclui os caracteres diacríticos:
^\w+$
Ou
^\w*$
Embora seja mais detalhado \w
, aprecio pessoalmente a legibilidade dos nomes completos das classes de caracteres POSIX ( http://www.zytrax.com/tech/web/regex.htm#special ), então eu diria:
^[[:alnum:]_]+$
No entanto, embora a documentação nos links acima afirme que \w
"Corresponde a qualquer caractere no intervalo 0 - 9, A - Z e a - z (equivalente a POSIX [: alnum:])", não achei que isso fosse verdade . Não de grep -P
qualquer maneira. Você precisa incluir explicitamente o sublinhado se você usar, [:alnum:]
mas não se você usar \w
. Você não pode vencer o seguinte para curto e doce:
^\w+$
Juntamente com a legibilidade, o uso das classes de caracteres POSIX ( http://www.regular-expressions.info/posixbrackets.html ) significa que seu regex pode funcionar em cadeias não ASCII, que os regexes baseados em intervalo não farão, pois contam com a ordem subjacente dos caracteres ASCII que podem ser diferentes de outros conjuntos de caracteres e, portanto, excluirá alguns caracteres não ASCII (letras como œ) que você pode querer capturar.
Em Ciência da Computação, um valor alfanumérico geralmente significa que o primeiro caractere não é um número, mas é um alfabeto ou sublinhado. Em seguida, o carácter pode ser 0-9
, A-Z
, a-z
, ou sublinhado ( _
).
Aqui está como você faria isso:
Testado em php:
$regex = '/^[A-Za-z_][A-Za-z\d_]*$/'
ou pegue isso
^[A-Za-z_][A-Za-z\d_]*$
e coloque-o na sua linguagem de desenvolvimento.
use lookaheads para fazer o "pelo menos um" item. Confie em mim, é muito mais fácil.
Aqui está um exemplo que exigiria de 1 a 10 caracteres, contendo pelo menos um dígito e uma letra:
^(?=.*\d)(?=.*[A-Za-z])[A-Za-z0-9]{1,10}$
NOTA: poderia ter usado \ w, mas as considerações ECMA / Unicode entram em jogo aumentando a cobertura de caracteres do \ w "caractere da palavra".
Experimente estas extensões multilíngues que criei para string.
IsAlphaNumeric - A string deve conter pelo menos 1 alfa (letra no intervalo Unicode, especificado em charSet) e pelo menos 1 número (especificado em numSet). Além disso, a string deve incluir apenas alfa e números.
IsAlpha - String deve conter pelo menos 1 alfa (no idioma charSet especificado) e incluir apenas alfa.
IsNumeric - A string deve conter pelo menos 1 número (no idioma especificado numSet) e incluir apenas números.
O intervalo charSet / numSet para o idioma desejado pode ser especificado. Os intervalos Unicode estão disponíveis no link abaixo:
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();
A seguinte expressão regular corresponde a caracteres alfanuméricos e sublinhado:
^[a-zA-Z0-9_]+$
Por exemplo, no 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";
}
Isso deve funcionar na maioria dos casos.
/^[\d]*[a-z_][a-z\d_]*$/gi
E por mais que eu quero dizer,
abcd True
abcd12 True
ab12cd True
12abcd True
1234 False
^ ... $
- combine o padrão começando e terminando com[\d]*
- corresponde a zero ou mais dígitos[a-z_]
- corresponde a um alfabeto ou sublinhado[a-z\d_]*
- corresponde a um alfabeto ou dígito ou sublinhado/gi
- corresponda globalmente na cadeia e não diferencia maiúsculas de minúsculas1234
é a palavra do idioma solicitado pelo autor. Seu idioma é mais restritivo.
Para mim, houve um problema em que desejo distinguir entre alfa, numérico e alfa numérico; portanto, para garantir que uma sequência alfanumérica contenha pelo menos um alfa e pelo menos um numérico, usei:
^([a-zA-Z_]{1,}\d{1,})+|(\d{1,}[a-zA-Z_]{1,})+$
Para aqueles que procuram correspondência alfanumérica unicode, convém fazer algo como:
^[\p{L} \p{Nd}_]+$
Leitura adicional em http://unicode.org/reports/tr18/ e em http://www.regular-expressions.info/unicode.html
Eu acredito que você não está usando caracteres latinos e Unicode em suas partidas. Por exemplo, se você precisar usar caracteres "ã" ou "ü", o uso de "\ w" não funcionará.
Como alternativa, você pode usar esta abordagem:
^[A-ZÀ-Ýa-zà-ý0-9_]+$
Espero que ajude!
Para verificar a cadeia inteira e não permitir cadeias vazias, tente
^[A-Za-z0-9_]+$
^\w*$
funcionará para as combinações abaixo
1
123
1av
pRo
av1
Isso funciona para mim, encontrei isso nas "Mastering Regular Expressions" da O'Reilly:
/^\w+$/
Explicação:
Verifique-se:
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}`);
});
}