Expressão regular para caracteres alfanuméricos 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.

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

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

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

E se:

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

... se você quiser ser explícito, ou:

^\w+$

... se você preferir conciso (sintaxe Perl).

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

Explicação

1. ^ ... $ - combine o padrão começando e terminando com
2. [\d]* - corresponde a zero ou mais dígitos
3. [a-z_] - corresponde a um alfabeto ou sublinhado
4. [a-z\d_]* - corresponde a um alfabeto ou dígito ou sublinhado
5. /gi - corresponda globalmente na cadeia e não diferencia maiúsculas de minúsculas

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

Aqui está a regex do que você deseja com um quantificador para especificar pelo menos 1 caractere e não mais que 255 caracteres

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

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, você pode tentar

[\\p{Alnum}_]

Isso funciona para mim, encontrei isso nas "Mastering Regular Expressions" da O'Reilly:

/^\w+$/

Explicação:

• ^ afirma a posição no início da string
  • \ w + corresponde a qualquer caractere de palavra (igual a [a-zA-Z0-9_])
  • "+" Quantificador - Corresponde entre uma e várias vezes, quantas vezes for possível, devolvendo o que for necessário (ganancioso)
• $ afirma a posição no final da string

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