Espressione regolare per caratteri alfanumerici e di sottolineatura

Vorrei avere un'espressione regolare che controlla se una stringa contiene solo lettere maiuscole e minuscole, numeri e caratteri di sottolineatura.

Per abbinare una stringa che contiene solo quei caratteri (o una stringa vuota), prova

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

Funziona con le espressioni regolari di .NET e probabilmente anche con molte altre lingue.

Abbattendo:

^ : 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 non si desidera consentire stringhe vuote, utilizzare + invece di *.

Come altri hanno sottolineato, alcune lingue regex hanno una forma abbreviata per [a-zA-Z0-9_]. Nel linguaggio regex .NET, è possibile attivare il comportamento ECMAScript e utilizzare \wcome scorciatoia (cedimento ^\w*$o ^\w+$). Si noti che in altre lingue, e per impostazione predefinita in .NET, \wè un po 'più ampio e corrisponderà anche ad altri tipi di caratteri Unicode (grazie a Jan per averlo sottolineato). Quindi, se hai davvero intenzione di abbinare solo quei personaggi, usare la forma esplicita (più lunga) è probabilmente la cosa migliore.

C'è molta verbosità qui, e sono profondamente contrario, quindi la mia risposta conclusiva sarebbe:

/^\w+$/

\wè equivalente a [A-Za-z0-9_], che è praticamente quello che vuoi. (a meno che non introduciamo unicode nel mix)

Usando il +quantificatore abbinerai uno o più caratteri. Se vuoi accettare anche una stringa vuota, usa *invece.

Vuoi verificare che ogni personaggio soddisfi i tuoi requisiti, motivo per cui usiamo:

[A-Za-z0-9_]

E puoi anche usare la versione abbreviata:

\w

Che è equivalente (in alcuni sapori regex, quindi assicurati di controllare prima di usarlo). Quindi per indicare che l'intera stringa deve corrispondere, si utilizza:

^

Per indicare che la stringa deve iniziare con quel carattere, quindi utilizzare

$

Per indicare che la stringa deve terminare con quel carattere. Quindi utilizzare

\w+ or \w*

Per indicare "1 o più" o "0 o più". Mettendo tutto insieme, abbiamo:

^\w*$

Um ... domanda: deve avere almeno un personaggio o no? Può essere una stringa vuota?

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

Farà almeno un carattere alfanumerico o di sottolineatura maiuscolo o minuscolo. Se può avere una lunghezza pari a zero, sostituisci + con *

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

Modificare:

Se è necessario includere i segni diacritici (come cedilla - ç), è necessario utilizzare il carattere parola che fa lo stesso del precedente, ma include i caratteri diacritici:

^\w+$

O

^\w*$

Sebbene sia più dettagliato di \w, apprezzo personalmente la leggibilità dei nomi completi delle classi di caratteri POSIX ( http://www.zytrax.com/tech/web/regex.htm#special ), quindi direi:

^[[:alnum:]_]+$

Tuttavia, mentre la documentazione ai link sopra afferma che \w"Corrisponderà a qualsiasi carattere nell'intervallo 0 - 9, A - Z e a - z (equivalente di POSIX [: alnum:])", non ho trovato che questo sia vero . Non grep -Pcomunque. È necessario includere esplicitamente il carattere di sottolineatura se si utilizza [:alnum:]ma non se si utilizza \w. Non puoi battere quanto segue in breve e dolce:

^\w+$

Insieme alla leggibilità, l'uso delle classi di caratteri POSIX ( http://www.regular-expressions.info/posixbrackets.html ) significa che il tuo regex può funzionare su stringhe non ASCII, cosa che i regex basati su intervallo non faranno poiché si basano su l'ordinamento sottostante dei caratteri ASCII che può essere diverso dagli altri set di caratteri e pertanto escluderà alcuni caratteri non ASCII (lettere come œ) che potresti voler catturare.

In Informatica, un valore alfanumerico spesso indica che il primo carattere non è un numero ma è un alfabeto o un trattino basso. Successivamente il carattere può essere 0-9, A-Z, a-z, o sottolineatura ( _).

Ecco come lo faresti:

Testato sotto php:

$regex = '/^[A-Za-z_][A-Za-z\d_]*$/'

o prendi questo

^[A-Za-z_][A-Za-z\d_]*$

e inseriscilo nel tuo linguaggio di sviluppo.

Che ne dite di:

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

... se vuoi essere esplicito, oppure:

^\w+$

... se preferisci la sintassi (sintassi Perl).

usa i lookahead per fare "almeno una" roba. Fidati di me è molto più facile.

Ecco un esempio che richiederebbe 1-10 caratteri, contenente almeno una cifra e una lettera:

^(?=.*\d)(?=.*[A-Za-z])[A-Za-z0-9]{1,10}$

NOTA: avrebbe potuto usare \ w ma poi entrano in gioco le considerazioni ECMA / Unicode aumentando la copertura dei caratteri del \ w "carattere parola".

Prova queste estensioni multilingue che ho creato per la stringa.

IsAlphaNumeric - La stringa deve contenere almeno 1 alfa (lettera nell'intervallo Unicode, specificato in charSet) e almeno 1 numero (specificato in numSet). Inoltre, la stringa dovrebbe comprendere solo alfa e numeri.

IsAlpha - String deve contenere almeno 1 alpha (nella lingua charSet specificata) e comprendere solo alpha.

IsNumeric: la stringa deve contenere almeno 1 numero (nella lingua numSet specificata) e comprendere solo numeri.

È possibile specificare l'intervallo charSet / numSet per la lingua desiderata. Gli intervalli Unicode sono disponibili sul link seguente:

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

Utilizzo:

        //English
        string test = "AASD121asf";

        //Greek
        //string test = "Ϡϛβ123";

        //Bengali
        //string test = "শর৩৮";

        //Hindi
        //string test = @"क़लम३७ख़";

        bool isAlphaNum = test.IsAlphaNumeric();

La seguente regex corrisponde ai caratteri alfanumerici e al carattere di sottolineatura:

^[a-zA-Z0-9_]+$

Ad esempio, in 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";
}

Questo dovrebbe funzionare nella maggior parte dei casi.

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

E per molti intendo,

abcd       True
abcd12     True
ab12cd     True
12abcd     True

1234       False

Spiegazione

1. ^ ... $ - corrisponde allo schema che inizia e termina con
2. [\d]* - corrisponde a zero o più cifre
3. [a-z_] - abbina un alfabeto o un trattino basso
4. [a-z\d_]* - abbina un alfabeto o una cifra o un trattino basso
5. /gi - Corrispondenza globale sulla stringa e senza distinzione tra maiuscole e minuscole

Per me c'è stato un problema in cui voglio distinguere tra alfa, numerico e alfanumerico, quindi per garantire che una stringa alfanumerica contenga almeno un alfa e almeno un numerico, ho usato:

^([a-zA-Z_]{1,}\d{1,})+|(\d{1,}[a-zA-Z_]{1,})+$

Ecco la regex per ciò che vuoi con un quantificatore per specificare almeno 1 carattere e non più di 255 caratteri

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

Per quelli di voi che cercano la corrispondenza alfanumerica unicode, potreste voler fare qualcosa del tipo:

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

Ulteriori letture su http://unicode.org/reports/tr18/ e su http://www.regular-expressions.info/unicode.html

Credo che non prenderai personaggi latini e Unicode nelle tue partite. Ad esempio, se devi prendere i caratteri "ã" o "ü", l'uso di "\ w" non funzionerà.

In alternativa, puoi utilizzare questo approccio:

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

Spero che sia d'aiuto!

Per controllare l'intera stringa e non consentire stringhe vuote, provare

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

^\w*$ funzionerà per le seguenti combinazioni

1
123
1av
pRo
av1

questo funziona per me, puoi provare

[\\p{Alnum}_]

Questo funziona per me, l'ho trovato nelle "Mastering Regular Expressions" di O'Reilly:

/^\w+$/

Spiegazione:

• ^ afferma la posizione all'inizio della stringa
  • \ w + corrisponde a qualsiasi carattere di parola (uguale a [a-zA-Z0-9_])
  • "+" Quantificatore - Corrisponde tra una e più volte, il maggior numero di volte possibile, restituendo quanto necessario (avido)
• $ afferma la posizione alla fine della stringa

Verifica te stesso:

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