Regex For Numbers Only

document.getElementById('myinput').addEventListener('keypress', event => {
    if (!`${event.target.value}${event.key}`.match(/^[0-9]{0,2}$/)) {
        // block the input if result does not match
        event.preventDefault();
        event.stopPropagation();
        return false;
    }
});

<input id="myinput" type="text" value="" />

Regex to check whether a string contains only numbers

var reg = /^\d+$/;

should do it. The original matches anything that consists of exactly one digit.

How to check if a string contains only digits in Java

Try

String regex = "[0-9]+";

or

String regex = "\\d+";

As per Java regular expressions, the + means "one or more times" and \d means "a digit".

Note: the "double backslash" is an escape sequence to get a single backslash - therefore, \\d in a java String gives you the actual result: \d

References:

• Java Regular Expressions

• Java Character Escape Sequences

---

Edit: due to some confusion in other answers, I am writing a test case and will explain some more things in detail.

Firstly, if you are in doubt about the correctness of this solution (or others), please run this test case:

String regex = "\\d+";

// positive test cases, should all be "true"
System.out.println("1".matches(regex));
System.out.println("12345".matches(regex));
System.out.println("123456789".matches(regex));

// negative test cases, should all be "false"
System.out.println("".matches(regex));
System.out.println("foo".matches(regex));
System.out.println("aa123bb".matches(regex));

Question 1:

Isn't it necessary to add ^ and $ to the regex, so it won't match "aa123bb" ?

No. In java, the matches method (which was specified in the question) matches a complete string, not fragments. In other words, it is not necessary to use ^\\d+$ (even though it is also correct). Please see the last negative test case.

Please note that if you use an online "regex checker" then this may behave differently. To match fragments of a string in Java, you can use the find method instead, described in detail here:

Difference between matches() and find() in Java Regex

Question 2:

Won't this regex also match the empty string, "" ?*

No. A regex \\d* would match the empty string, but \\d+ does not. The star * means zero or more, whereas the plus + means one or more. Please see the first negative test case.

Question 3

Isn't it faster to compile a regex Pattern?

Yes. It is indeed faster to compile a regex Pattern once, rather than on every invocation of matches, and so if performance implications are important then a Pattern can be compiled and used like this:

Pattern pattern = Pattern.compile(regex);
System.out.println(pattern.matcher("1").matches());
System.out.println(pattern.matcher("12345").matches());
System.out.println(pattern.matcher("123456789").matches());

REGEX a-z 0-9 but not only numbers

The \D shorthand class means any non-digit symbol. You should remove it from the pattern (so that it becomes "^[A-Za-z0-9_-]{10,30}$") for the matches to return true, as 1 is a digit in 1Regex that accepts only numbers (0-9) and NO characters Regex for numbers only Regex to allow only numbers and max 2 digits Regex to check whether a string contains onle333e.

If you want to place a restriction (the string cannot consist of only digits) use an anchored look-ahead:

^(?![0-9]+$)[A-Za-z0-9_-]{10,30}$

Here is a demo

Or, a shortened version with i modifier making the pattern case-insensitive:

(?i)^(?![0-9]+$)[A-Z0-9_-]{10,30}$

allow only numbers AND may 'contain' slash AND must not start or end with slash

The [^/] matches any char, not just a digit. Besides, to validate a whole string, you need to use anchors, or a method that anchors the match at start and end of the string.

You may use

^(?!\/)[\d\/]*$(?<!\/)

Or

^\d(?:[\/\d]*\d)?$

See the regex demo #1 and regex demo #2.

Regex #1 details

• ^ - start of string
• (?!\/) - no / allowed at the start
• [\d\/]* - 0 or more digits or slashes
• $- end of string
• (?<!\/) - fail the match if there is a / at the end.

Regex #2 details

• ^ - start of string
• \d - a digit
• (?:[\/\d]*\d)? - an optional non-capturing group matching 0 or more / or digit chars and then a digit
• $ - end of string.

Regex expression for numbers and leading zeros just with a dot and decimal

If a negative lookahead is supported, you can exclude matches that start with a zero and have no decimal part.

^(?!0\d*$)\d+(?:\.\d{1,2})?$

• ^ Start of string
• (?!0+\d*$) Negative lookahead, assert not a zero followed by optional digits at the right
• \d+ Match 1+ digits
• (?:\.\d{1,2})? Match an optional decimal part with 1 or 2 digits
• $ End of string

Regex demo

---

Related Topics