Regex to check whether a string contains only numbers

Regex to check whether a string contains only numbers

hash = window.location.hash.substr(1);
var reg = new RegExp(‘^[0-9]$’);
console.log(reg.test(hash));

I get false on both “123” and “123f”. I would like to check if the hash only contains numbers. Did I miss something?

Solutions/Answers:

Solution 1:

var reg = /^\d+$/;

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

Solution 2:

As you said, you want hash to contain only numbers.

var reg = new RegExp('^[0-9]+$');

or

var reg = new RegExp('^\\d+$');

\d and [0-9] both mean the same thing.
The + used means that search for one or more occurring of [0-9].

Solution 3:

This one will allow also for signed and float numbers or empty string:

var reg = /^-?\d*\.?\d*$/

If you don’t want allow to empty string use this one:

var reg = /^-?\d+\.?\d*$/

Solution 4:

var validation = {
    isEmailAddress:function(str) {
        var pattern =/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
        return pattern.test(str);  // returns a boolean
    },
    isNotEmpty:function (str) {
        var pattern =/\S+/;
        return pattern.test(str);  // returns a boolean
    },
    isNumber:function(str) {
        var pattern = /^\d+$/;
        return pattern.test(str);  // returns a boolean
    },
    isSame:function(str1,str2){
        return str1 === str2;
    }
};   

alert(validation.isNotEmpty("dff"));
alert(validation.isNumber(44));
alert(validation.isEmailAddress("mf@tl.ff"));
alert(validation.isSame("sf","sf"));

Solution 5:

This is extreme overkill for your purpose, but here’s what I use:

var numberReSnippet = "(?:NaN|-?(?:(?:\\d+|\\d*\\.\\d+)(?:[E|e][+|-]?\\d+)?|Infinity))";
var matchOnlyNumberRe = new RegExp("^("+ numberReSnippet + ")$");

To my knowledge, this matches all the variations on numbers that Java and JavaScript will ever throw at you, including “-Infinity”, “1e-24” and “NaN”. It also matches numbers you might type, such as “-.5”.

Related:  How do I make an HTML text box show a hint when empty?

As written, reSnippet is designed to be dropped into other regular expressions, so you can extract (or avoid) numbers. Despite all the parentheses, it contains no capturing groups. Thus “matchOnlyNumberRe” matches only strings that are numbers, and has a capturing group for the entire string.

Here are the Jasmine tests, so you can see what it does and doesn’t handle:

describe("Number Regex", function() {
    var re = new RegExp("^("+ numberReSnippet + ")$");
    it("Matches Java and JavaScript numbers", function() {
        expect(re.test(         "1")).toBe(true);
        expect(re.test(       "0.2")).toBe(true);
        expect(re.test(     "0.4E4")).toBe(true);  // Java-style
        expect(re.test(       "-55")).toBe(true);
        expect(re.test(      "-0.6")).toBe(true);
        expect(re.test(  "-0.77E77")).toBe(true);
        expect(re.test(      "88E8")).toBe(true);
        expect(re.test(       "NaN")).toBe(true);
        expect(re.test(  "Infinity")).toBe(true);
        expect(re.test( "-Infinity")).toBe(true);
        expect(re.test(     "1e+24")).toBe(true);  // JavaScript-style
    });
    it("Matches fractions with a leading decimal point", function() {
        expect(re.test(        ".3")).toBe(true);
        expect(re.test(       "-.3")).toBe(true);
        expect(re.test(     ".3e-4")).toBe(true);
    });
    it("Doesn't match non-numbers", function() {
        expect(re.test(         ".")).toBe(false);
        expect(re.test(        "9.")).toBe(false);
        expect(re.test(          "")).toBe(false);
        expect(re.test(         "E")).toBe(false);
        expect(re.test(       "e24")).toBe(false);
        expect(re.test(   "1e+24.5")).toBe(false);
        expect(re.test("-.Infinity")).toBe(false);
    });
});

Solution 6:

^[0-9]$ 

…is a regular expression matching any single digit, so 1 will return true but 123 will return false.

Related:  ES6 Template Literals Vs concatenated strings

If you add the * quantifier,

^[0-9]*$

the expression will match arbitrary length strings of digits and 123 will return true. (123f will still return false).

Be aware that technically an empty string is a 0-length string of digits, and so it will return true using ^[0-9]*$ If you want to only accept strings containing 1 or more digits, use + instead of *

^[0-9]+$

As the many others have pointed out, there are more than a few ways to achieve this, but I felt like it was appropriate to point out that the code in the original question only requires a single additional character to work as intended.