Regulärer Ausdruck für alphanumerische Zeichen und Unterstriche

Ich hätte gerne einen regulären Ausdruck, der prüft, ob eine Zeichenfolge nur Groß- und Kleinbuchstaben, Zahlen und Unterstriche enthält.

Versuchen Sie es mit einer Zeichenfolge, die nur diese Zeichen enthält (oder einer leeren Zeichenfolge)

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

Dies funktioniert für reguläre .NET-Ausdrücke und wahrscheinlich auch für viele andere Sprachen.

Brechen sie ab:

^ : 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

Wenn Sie keine leeren Zeichenfolgen zulassen möchten, verwenden Sie + anstelle von *.

Wie andere betont haben, haben einige Regex-Sprachen eine Kurzform für [a-zA-Z0-9_]. In der .NET-Regex-Sprache können Sie das ECMAScript-Verhalten aktivieren und \wals Kurzform (Ausbeute ^\w*$oder ^\w+$) verwenden. Beachten Sie, dass in anderen Sprachen und standardmäßig in .NET \wetwas breiter ist und auch mit anderen Arten von Unicode-Zeichen übereinstimmt (danke an Jan für den Hinweis). Wenn Sie also wirklich nur diese Zeichen abgleichen möchten, ist es wahrscheinlich am besten, die explizite (längere) Form zu verwenden.

Hier drin steckt viel Ausführlichkeit, und ich bin zutiefst dagegen. Meine abschließende Antwort wäre also:

/^\w+$/

\wist gleichbedeutend mit [A-Za-z0-9_], was ziemlich genau das ist, was Sie wollen. (es sei denn, wir führen Unicode in die Mischung ein)

Mit dem +Quantifizierer stimmen Sie mit einem oder mehreren Zeichen überein. Wenn Sie auch eine leere Zeichenfolge akzeptieren möchten, verwenden Sie *stattdessen.

Sie möchten überprüfen, ob jedes Zeichen Ihren Anforderungen entspricht. Deshalb verwenden wir:

[A-Za-z0-9_]

Und Sie können sogar die Kurzversion verwenden:

\w

Welches ist äquivalent (in einigen Regex-Geschmacksrichtungen, stellen Sie also sicher, dass Sie es überprüfen, bevor Sie es verwenden). Um anzuzeigen, dass die gesamte Zeichenfolge übereinstimmen muss, verwenden Sie:

^

Um anzuzeigen, dass die Zeichenfolge mit diesem Zeichen beginnen muss, verwenden Sie

$

Um anzuzeigen, muss die Zeichenfolge mit diesem Zeichen enden. Dann benutze

\w+ or \w*

Anzeige von "1 oder mehr" oder "0 oder mehr". Alles zusammen haben wir:

^\w*$

Ähm ... Frage: Muss es mindestens einen Charakter haben oder nicht? Kann es eine leere Zeichenfolge sein?

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

Führt mindestens eine alphanumerische Groß- oder Kleinschreibung oder einen Unterstrich aus. Wenn die Länge Null sein kann, ersetzen Sie einfach * durch das +

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

Bearbeiten:

Wenn diakritische Zeichen enthalten sein müssen (z. B. cedilla - ç), müssen Sie das Wortzeichen verwenden, das das Gleiche wie oben tut, jedoch die diakritischen Zeichen enthält:

^\w+$

Oder

^\w*$

Obwohl es ausführlicher ist als \w, schätze ich persönlich die Lesbarkeit der vollständigen POSIX-Zeichenklassennamen ( http://www.zytrax.com/tech/web/regex.htm#special ), daher würde ich sagen:

^[[:alnum:]_]+$

Obwohl die Dokumentation unter den obigen Links besagt, dass \w"mit jedem Zeichen im Bereich von 0 - 9, A - Z und a - z (Äquivalent zu POSIX [: alnum:]) übereinstimmt", habe ich dies nicht als wahr befunden . Jedenfalls nicht mit grep -P. Sie müssen den Unterstrich explizit einfügen, wenn Sie verwenden, [:alnum:]aber nicht, wenn Sie verwenden \w. Sie können Folgendes kurz und bündig nicht übertreffen:

^\w+$

Neben der Lesbarkeit bedeutet die Verwendung der POSIX-Zeichenklassen ( http://www.regular-expressions.info/posixbrackets.html ), dass Ihre Regex mit Nicht-ASCII-Zeichenfolgen arbeiten kann, was die bereichsbasierten Regexes nicht tun, da sie sich darauf verlassen Die zugrunde liegende Reihenfolge der ASCII-Zeichen, die sich möglicherweise von anderen Zeichensätzen unterscheidet und daher einige Nicht-ASCII-Zeichen (Buchstaben wie œ) ausschließt, die Sie möglicherweise erfassen möchten.

In der Informatik bedeutet ein alphanumerischer Wert häufig, dass das erste Zeichen keine Zahl, sondern ein Alphabet oder ein Unterstrich ist. Danach kann das Zeichen sein 0-9, A-Z, a-z, oder Unterstrich ( _).

So würden Sie das machen:

Getestet unter PHP:

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

oder nimm das

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

und platzieren Sie es in Ihrer Entwicklungssprache.

Wie wäre es mit:

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

... wenn Sie explizit sein möchten oder:

^\w+$

... wenn Sie eine prägnante (Perl-Syntax) bevorzugen.

Verwenden Sie Lookaheads, um die "mindestens einen" Sachen zu machen. Vertrau mir, es ist viel einfacher.

Hier ist ein Beispiel, das 1-10 Zeichen erfordert, die mindestens eine Ziffer und einen Buchstaben enthalten:

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

HINWEIS: hätte \ w verwenden können, aber dann kommen ECMA / Unicode-Überlegungen ins Spiel, die die Zeichenabdeckung des \ w "Wortzeichens" erhöhen.

Probieren Sie diese mehrsprachigen Erweiterungen aus, die ich für Zeichenfolgen erstellt habe.

IsAlphaNumeric - Der String muss mindestens 1 Alpha (Buchstabe im Unicode-Bereich, angegeben in charSet) und mindestens 1 Nummer (angegeben in numSet) enthalten. Außerdem sollte die Zeichenfolge nur aus Alpha und Zahlen bestehen.

IsAlpha - String sollte mindestens 1 Alpha enthalten (in der angegebenen Sprache charSet) und nur Alpha enthalten.

IsNumeric - String sollte mindestens 1 Nummer enthalten (in der angegebenen Sprache numSet) und nur aus Zahlen bestehen.

Der charSet / numSet-Bereich für die gewünschte Sprache kann angegeben werden. Die Unicode-Bereiche sind unter folgendem Link verfügbar:

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

Verwendungszweck :

        //English
        string test = "AASD121asf";

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

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

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

        bool isAlphaNum = test.IsAlphaNumeric();

Der folgende reguläre Ausdruck entspricht alphanumerischen Zeichen und Unterstrichen:

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

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

Dies sollte in den meisten Fällen funktionieren.

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

Und mit den meisten meine ich,

abcd       True
abcd12     True
ab12cd     True
12abcd     True

1234       False

Erläuterung

1. ^ ... $ - Passen Sie das Muster an, das mit und endet
2. [\d]* - mit null oder mehr Ziffern übereinstimmen
3. [a-z_] - einem Alphabet oder Unterstrich entsprechen
4. [a-z\d_]* - einem Alphabet oder einer Ziffer oder einem Unterstrich entsprechen
5. /gi - Global über die Zeichenfolge hinweg übereinstimmen und die Groß- und Kleinschreibung nicht berücksichtigen

Für mich gab es ein Problem darin, dass ich zwischen Alpha, Numerisch und Alphanumerisch unterscheiden möchte. Um sicherzustellen, dass eine alphanumerische Zeichenfolge mindestens ein Alpha und mindestens eine Numerik enthält, habe ich Folgendes verwendet:

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

Hier ist der reguläre Ausdruck für das, was Sie mit einem Quantifizierer wünschen, der mindestens 1 Zeichen und nicht mehr als 255 Zeichen angibt

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

Für diejenigen unter Ihnen, die nach alphanumerischen Unicode-Übereinstimmungen suchen, möchten Sie möglicherweise Folgendes tun:

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

Weitere Informationen finden Sie unter http://unicode.org/reports/tr18/ und unter http://www.regular-expressions.info/unicode.html

Ich glaube, Sie nehmen in Ihren Spielen keine lateinischen und Unicode-Zeichen. Wenn Sie beispielsweise Zeichen "ã" oder "ü" verwenden müssen, funktioniert die Verwendung von "\ w" nicht.

Alternativ können Sie diesen Ansatz verwenden:

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

Ich hoffe es hilft!

Versuchen Sie es, um die gesamte Zeichenfolge zu überprüfen und keine leeren Zeichenfolgen zuzulassen

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

^\w*$ funktioniert für die folgenden Kombinationen

1
123
1av
pRo
av1

Das funktioniert bei mir, du kannst es versuchen

[\\p{Alnum}_]

Dies funktioniert für mich und wurde in O'Reillys "Mastering Regular Expressions" gefunden:

/^\w+$/

Erläuterung:

• ^ bestätigt die Position am Anfang des Strings
  • \ w + entspricht einem beliebigen Wortzeichen (gleich [a-zA-Z0-9_])
  • "+" Quantifizierer - Stimmt so oft wie möglich zwischen einer und einer unbegrenzten Anzahl überein und gibt nach Bedarf etwas zurück (gierig)
• $ bestätigt die Position am Ende des Strings

Überprüfen Sie sich:

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