CODEWITHSUNDEEP
regex
Jim
Jim

Reputation:

Regular expression for alphanumeric and underscores

Is there a regular expression which checks if a string contains only upper and lowercase letters, numbers, and underscores?

Upvotes: 834

Views: 1841425

Answers (21)

Sharad
Sharad

Reputation: 446

For Java, only case insensitive alphanumeric and underscore are allowed.

  • ^ Matches the string starting with any characters

  • [a-zA-Z0-9_]+ Matches alpha-numeric character and underscore.

  • $ Matches the string ending with zero or more characters.

      public class RegExTest {
      public static void main(String[] args) {
          System.out.println("_C#".matches("^[a-zA-Z0-9_]+$"));
      }
  }

Upvotes: 2

Jay
Jay

Reputation: 42692

The following regex matches alphanumeric characters and underscore:

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

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

Upvotes: 9

Danuel O'Neal
Danuel O'Neal

Reputation: 294

In computer science, an alphanumeric value often means the first character is not a number, but it is an alphabet or underscore. Thereafter the character can be 0-9, A-Z, a-z, or underscore (_).

Here is how you would do that:

Tested under PHP:

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

Or take

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

and place it in your development language.

Upvotes: 21

BenAlabaster
BenAlabaster

Reputation: 39856

Um...question: Does it need to have at least one character or no? Can it be an empty string?

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

Will do at least one upper or lower case alphanumeric or underscore. If it can be zero length, then just substitute the + for *:

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

If diacritics need to be included (such as cedilla - ç) then you would need to use the word character which does the same as the above, but includes the diacritic characters:

^\w+$

Or

^\w*$

Upvotes: 43

Drew Hall
Drew Hall

Reputation: 29055

Use

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

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

^\w+$

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

Upvotes: 25

Shantanu
Shantanu

Reputation: 91

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

IsAlphaNumeric - The string must contain at least one alpha (letter in Unicode range, specified in charSet) and at least one number (specified in numSet). Also, the string should consist only of alpha and numbers.

IsAlpha - The string should contain at least one alpha (in the language charSet specified) and consist only of alpha.

IsNumeric - The string should contain at least one number (in the language numSet specified) and consist only of numbers.

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

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

Usage:

// English
string test = "AASD121asf";

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

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

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

bool isAlphaNum = test.IsAlphaNumeric();

Upvotes: 9

Marcio Martins
Marcio Martins

Reputation: 340

I believe you are not taking Latin and Unicode characters in your matches.

For example, if you need to take "ã" or "ü" chars, the use of "\w" won't work.

You can, alternatively, use this approach:

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

Upvotes: 3

uma mahesh
uma mahesh

Reputation: 124

Required Format

Allow these three:

  1. 0142171547295
  2. 014-2171547295
  3. 123abc

Don't allow other formats:

validatePnrAndTicketNumber(){
    let alphaNumericRegex=/^[a-zA-Z0-9]*$/;
    let numericRegex=/^[0-9]*$/;
    let numericdashRegex=/^(([1-9]{3})\-?([0-9]{10}))$/;
   this.currBookingRefValue = this.requestForm.controls["bookingReference"].value;
   if(this.currBookingRefValue.length == 14 && this.currBookingRefValue.match(numericdashRegex)){
     this.requestForm.controls["bookingReference"].setErrors({'pattern': false});
   }else if(this.currBookingRefValue.length ==6 && this.currBookingRefValue.match(alphaNumericRegex)){
    this.requestForm.controls["bookingReference"].setErrors({'pattern': false});
   }else if(this.currBookingRefValue.length ==13 && this.currBookingRefValue.match(numericRegex) ){
    this.requestForm.controls["bookingReference"].setErrors({'pattern': false});
   }else{
    this.requestForm.controls["bookingReference"].setErrors({'pattern': true});
   }
}

<input name="booking_reference" type="text" [class.input-not-empty]="bookingRef.value"
    class="glyph-input form-control floating-label-input" id="bookings_bookingReference"
    value="" maxlength="14" aria-required="true" role="textbox" #bookingRef
    formControlName="bookingReference" (focus)="resetMessageField()" (blur)="validatePnrAndTicketNumber()"/>

Upvotes: -1

MiKr13
MiKr13

Reputation: 1511

This works for me. I found this in the O'Reilly's "Mastering Regular Expressions":

/^\w+$/

Explanation:

  • ^ asserts position at start of the string
    • \w+ matches any word character (equal to [a-zA-Z0-9_])
    • "+" Quantifier — Matches between one and unlimited times, as many times as possible, giving back as needed (greedy)
  • $ asserts position at the end of the string

Verify yourself:

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

Upvotes: 13

Chinmaya Pati
Chinmaya Pati

Reputation: 397

This should work in most of the cases.

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

And by most I mean,

abcd       True
abcd12     True
ab12cd     True
12abcd     True

1234       False

Explanation

  1. ^ ... $ - match the pattern starting and ending with
  2. [\d]* - match zero or more digits
  3. [a-z_] - match an alphabet or underscore
  4. [a-z\d_]* - match an alphabet or digit or underscore
  5. /gi - match globally across the string and case-insensitive

Upvotes: 6

Mukund Thakkar
Mukund Thakkar

Reputation: 1305

^\w*$ will work for the below combinations:

1
123
1av
pRo
av1

Upvotes: 2

Saurabh
Saurabh

Reputation: 7833

This works for me. You can try:

[\\p{Alnum}_]

Upvotes: 1

Agustin
Agustin

Reputation: 1254

For those of you looking for unicode alphanumeric matching, you might want to do something like:

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

Further reading is at Unicode Regular Expressions (Unicode Consortium) and at Unicode Regular Expressions (Regular-Expressions.info).

Upvotes: 5

boooloooo
boooloooo

Reputation: 159

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:

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

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

Upvotes: 15

kch
kch

Reputation: 79640

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

/^\w+$/

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

Upvotes: 482

Charlie
Charlie

Reputation: 45072

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

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

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

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.

Upvotes: 1261

mson
mson

Reputation: 7822

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}

Upvotes: 4

Day Davis Waterbury
Day Davis Waterbury

Reputation: 2132

Although it's more verbose than \w, I personally appreciate the readability of the full POSIX character class names ( http://www.zytrax.com/tech/web/regex.htm#special ), so I'd say: 

^[[:alnum:]_]+$

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:

^\w+$

Along with readability, using the POSIX character classes (http://www.regular-expressions.info/posixbrackets.html) 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.

Upvotes: 51

mylesmckeown
mylesmckeown

Reputation: 51

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 : 

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

Upvotes: 4

Anton
Anton

Reputation: 1437

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

[A-Za-z0-9_]

And you can even use the shorthand version:

\w

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

Upvotes: 51

David Norman
David Norman

Reputation: 19889

To check the entire string and not allow empty strings, try

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

Upvotes: 1

Related Questions