regex - special - Regular Expression for alphanumeric and underscores

regular expression alphanumeric fixed length (12)

Although it's more verbose than \w, I personally appreciate the readability of the full POSIX character class names ( ), so I'd say:


However, while the documentation at the above links states that \w will "Match any character in the range 0 - 9, A - Z and a - z (equivalent of POSIX [:alnum:])", I have not found this to be true. Not with grep -P anyway. You need to explicitly include the underscore if you use [:alnum:] but not if you use \w. You can't beat the following for short and sweet:


Along with readability, using the POSIX character classes ( means that your regex can work on non ASCII strings, which the range based regexes won't do since they rely on the underlying ordering of the ASCII characters which may be different from other character sets and will therefore exclude some non-ASCII characters (letters such as œ) which you might want to capture.

I would like to have a regular expression that checks if a string contains only upper and lowercase letters, numbers, and underscores.

For me there was an issue in that I want to distinguish between alpha, numeric and alpha numeric, so to ensure an alphanumeric string contains at least one alpha and at least one numeric, I used :


Here is the regex for what you want with a quantifier to specify at least 1 character and no more than 255 characters

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

How about:


...if you want to be explicit, or:


...if you prefer concise (Perl syntax).

The following regex matches alphanumeric characters and underscore:


For example, 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";

There's a lot of verbosity in here, and I'm deeply against it, so, my conclusive answer would be:


\w is equivalent to [A-Za-z0-9_], which is pretty much what you want. (unless we introduce unicode to the mix)

Using the + quantifier you'll match one or more characters. If you want to accept an empty string too, use * instead.

To match a string that contains only those characters (or an empty string), try


This works for .NET regular expressions, and probably a lot of other languages as well.

Breaking it down:

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

If you don't want to allow empty strings, use + instead of *.

EDIT As others have pointed out, some regex languages have a shorthand form for [a-zA-Z0-9_]. In the .NET regex language, you can turn on ECMAScript behavior and use \w as a shorthand (yielding ^\w*$ or ^\w+$). Note that in other languages, and by default in .NET, \w is somewhat broader, and will match other sorts of unicode characters as well (thanks to Jan for pointing this out). So if you're really intending to match only those characters, using the explicit (longer) form is probably best.

Try these multi-lingual extensions I have made for string.

IsAlphaNumeric - String must contain atleast 1 alpha (letter in Unicode range, specified in charSet) and atleast 1 number (specified in numSet). Also, the string should comprise only of alpha and numbers.

IsAlpha - String should contain atleast 1 alpha (in the language charSet specified) and comprise only of alpha.

IsNumeric - String should contain atleast 1 number (in the language numSet specified) and comprise only of numbers.

The charSet/numSet range for the desired language can be specified. The Unicode ranges are available on below link:


    public static bool IsAlphaNumeric(this string stringToTest)
        const string charSet = "a-zA-Z";
        const string numSet = @"0-9";

        //const string charSet = @"\u0388-\u03EF";            
        //const string numSet = @"0-9";

        //const string charSet = @"\u0985-\u09E3";
        //const string numSet = @"\u09E6-\u09EF";

        //const string charSet = @"\u0905-\u0963";
        //const string numSet = @"\u0966-\u096F";

        return Regex.Match(stringToTest, @"^(?=[" + numSet + @"]*?[" + charSet + @"]+)(?=[" + charSet + @"]*?[" + numSet + @"]+)[" + charSet + numSet [email protected]"]+$").Success;

    public static bool IsNumeric(this string stringToTest)
        const string numSet = @"0-9";

        //const string numSet = @"\u0966-\u096F";

        return Regex.Match(stringToTest, @"^[" + numSet + @"]+$").Success;

    public static bool IsAlpha(this string stringToTest)
        const string charSet = "a-zA-Z";

        return Regex.Match(stringToTest, @"^[" + charSet + @"]+$").Success;

Usage :

        string test = "AASD121asf";

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

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

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

        bool isAlphaNum = test.IsAlphaNumeric();

You want to check that each character matches your requirements, which is why we use:


And you can even use the shorthand version:


Which is equivalent (in some regex flavors, so make sure you check before you use it). Then to indicate that the entire string must match, you use:


To indicate the string must start with that character, then use


To indicate the string must end with that character. Then use

\w+ or \w*

To indicate "1 or more", or "0 or more". Putting it all together, we have:


^\w*$ will work for below combination 1 123 1av pRo av1

this works for me you can try [\p{Alnum}_]

use lookaheads to do the "at least one" stuff. Trust me it's much easier.

Here's an example that would require 1-10 characters, containing at least one digit and one letter:


NOTE: could have used \w but then ECMA/Unicode considerations come into play increasing the character coverage of the \w "word character".