如您所说，您希望哈希只包含数字。

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

or

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

\d和[0-9]都是同一个意思。 使用+表示搜索[0-9]中的一个或多个。

var reg = /^\d+$/;

应该这么做。原始值匹配任何恰好包含一个数字的值。

你需要*，所以它表示“零或多个前一个字符”，这应该做到:

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

这个函数也允许有符号和浮点数或空字符串:

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

如果你不想让空字符串使用这个:

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

只有数字的正则表达式(已更新)

 var reg = new RegExp('[^0-9]','g');

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+\.?\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"));

我看到你已经得到了很多答案，但如果你正在寻找一个正则表达式，可以匹配整数和浮点数，这一个将为你工作:

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

这个函数检查它的输入是否是经典意义上的数字，因为人们期望正常的数字检测函数能够工作。

这是一个可以用于HTML表单输入的测试。

它绕过了所有JS的民俗，比如tipeof(NaN) = number, parseint('1 Kg') = 1，布尔值被强制转换为数字，等等。

它通过将参数呈现为字符串，并根据@codename之类的正则表达式检查该字符串-但允许像5这样的条目。和5

function isANumber( n ) {
    var numStr = /^-?(\d+\.?\d*)$|(\d*\.?\d+)$/;
    return numStr.test( n.toString() );
}

not numeric:
Logger.log( 'isANumber( "aaa" ): ' + isANumber( 'aaa' ) );
Logger.log( 'isANumber( "" ): ' + isANumber( '' ) );
Logger.log( 'isANumber( "lkjh" ): ' + isANumber( 'lkjh' ) );
Logger.log( 'isANumber( 0/0 ): ' + isANumber( 0 / 0 ) );
Logger.log( 'isANumber( 1/0 ): ' + isANumber( 1 / 0 ) );
Logger.log( 'isANumber( "1Kg" ): ' + isANumber( '1Kg' ) );
Logger.log( 'isANumber( "1 Kg" ): ' + isANumber( '1 Kg' ) );
Logger.log( 'isANumber( false ): ' + isANumber( false ) );
Logger.log( 'isANumber( true ): ' + isANumber( true ) );

numeric:
Logger.log( 'isANumber( "0" ): ' + isANumber( '0' ) );
Logger.log( 'isANumber( "12.5" ): ' + isANumber( '12.5' ) );
Logger.log( 'isANumber( ".5" ): ' + isANumber( '.5' ) );
Logger.log( 'isANumber( "5." ): ' + isANumber( '5.' ) );
Logger.log( 'isANumber( "-5" ): ' + isANumber( '-5' ) );
Logger.log( 'isANumber( "-5." ): ' + isANumber( '-5.' ) );
Logger.log( 'isANumber( "-.5" ): ' + isANumber( '-5.' ) );
Logger.log( 'isANumber( "1234567890" ): ' + isANumber( '1234567890' ));

正则表达式的解释:

/^-?(\d+\.?\d*)$|(\d*\.?\d+)$/  

开头的“^”和结尾的“$”匹配字符串的开头和结尾，以确保检查横跨整个字符串。“-?”部分是带有“?”乘数的负号，它允许零或一个实例。

然后还有两个类似的组，用圆括号分隔。字符串必须匹配这两个组中的任意一个。第一个匹配5这样的数字。第二个。5

第一组是

\d+\.?\d*

“\d+”与数字(\d)匹配一次或多次。 “\.?”是小数点(用“\”转义，以消除它的魔力)，0次或1次。

最后一部分“\d*”也是一个数字，0次或多次。 除了第一个数字，其他部分都是可选的，所以这个组匹配5这样的数字。而不是和另一半匹配的。5。

如果你想用带符号的值匹配数字，你可以使用:

var reg = new RegExp('^(\-?|\+?)\d*$');

它将验证格式的数字:+1，-1,1。

在输入时，如果你想过滤掉其他字符，只显示输入字段中的数字，你可以在keyup上替换字段的值:

    var yourInput = jQuery('#input-field');
    yourInput.keyup(function() {
        yourInput.val((yourInput.val().replace(/[^\d]/g,'')))
    })   

这对你的目的来说太过分了:

const numberReSnippet = "NaN|-?((\d*\.\d+|\d+)([Ee][+-]?\d+)?|Infinity)";
const matchOnlyNumberRe = new RegExp("^("+ numberReSnippet + ")$");

据我所知，这与Java和JavaScript提供给您的所有数字变体相匹配，包括“-Infinity”、“1e-24”和“NaN”。它还可以匹配您可能键入的数字，例如“-.5”。

正如所写的，numberReSnippet被设计为被放入其他正则表达式中，因此您可以提取(或避免)数字。尽管有括号，但它不包含捕获组。因此"matchOnlyNumberRe"只匹配数字类型的字符串，并为整个字符串设置了一个捕获组。

下面是Jasmine测试，你可以看到它能处理什么，不能处理什么:

describe("Number Regex", function() {
    const re = matchOnlyNumberRe;
    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);
        expect(re.test(      "8|24")).toBe(false);
    });
});

^[0-9]$ 

.．.是一个匹配任何单个数字的正则表达式，因此1将返回true，而123将返回false。

如果你加上量词*，

^[0-9]*$

表达式将匹配任意长度的数字字符串，123将返回true。(123f仍然返回false)。

请注意，从技术上讲，一个空字符串是一个长度为0的数字字符串，因此它将使用^[0-9]*$返回true。如果您只想接受包含1个或多个数字的字符串，请使用+而不是*

^[0-9]+$

正如其他人所指出的那样，有很多方法可以实现这一点，但我认为应该指出，原始问题中的代码只需要一个额外的字符就可以正常工作。

如果你只需要正整数而不需要前导零(例如。"0001234"或"00"):

var reg = /^(?:[1-9]\d*|\d)$/;

/^[\+\-]?\d*\.?\d+(?:[Ee][\+\-]?\d+)?$/

如果数字不是特别大，可以用:

new RegExp(
    '^' +                           // No leading content.
    '[-+]?' +                       // Optional sign.
    '(?:[0-9]{0,30}\\.)?' +         // Optionally 0-30 decimal digits of mantissa.
    '[0-9]{1,30}' +                 // 1-30 decimal digits of integer or fraction.
    '(?:[Ee][-+]?[1-2]?[0-9])?' +   // Optional exponent 0-29 for scientific notation.
    '$'                             // No trailing content.
)

这试图避免一些场景，以防万一:

溢出原始字符串可能传递到的任何缓冲区。 由1E-323等非正常数字引起的缓慢或异常。 当期望有一个有限的数字时通过无穷大(尝试1E309或-1E309)。

var pattern = /[0-9!"£$%^&*()_+-=]/;

这试图避免一些场景，以防万一:

溢出原始字符串可能传递到的任何缓冲区。 由1E-323等非正常数字引起的缓慢或异常。 当期望有一个有限的数字时通过无穷大(尝试1E309或-1E309)。

为什么不用这样的东西:

$.isNumeric($(input).val())

jquery测试，和最常见的情况下检查

简单的Regex javascript

var cnpj = "12.32.432/1-22";
var rCnpj = cnpj.replace(/\D/gm,"");
console.log(cnpj);

*结果:

1232432122

只检查数字:

if(rCnpj === cnpj){
   return true;
}

简单的例子

if("12.32.432/1-22".replace(/\D/gm,"").length > 0){
   console.log("Ok.");
}

您也可以使用以下方法，但要注意它们的内部实现和/或返回值。

1A isNaN(+'13761123123123'); // returns true
1B isNaN(+'13761123123ABC'); // returns false

2A ~~'1.23'; // returns 1
2B ~~'1.2A'; // returns 0

For 1A & 1B the string is first type coerced using the + operator before being passed to the isNaN() function. This works because a number types that include non-numeric values return NaN. There are considerations with the isNaN()'s implementation details which is documented here. One consideration is if a boolean value is passed as isNaN(+false|true) are coerced to their numeric equivalents and thus false is returned but one might expect the function to return true since the boolean value isn't numeric in the sense of what we are testing.

对于2A和2B，值得注意的是，寻找数字的补数要求给定的值在规范中可以引用的32位有符号整数的值范围内。

我个人的偏好是1A和1B，因为它们包含一元运算符，因此可读性较差，因为速度和简洁。

穿孔https://jsperf.com/numeric-string-test-regexvsisnan/1

也许它有用:

let a = "1234"
parseInt(a) == a // true
let b = "1234abc"
parseInt(b) == b // false

\d将不匹配小数点。小数用下面的形式表示。

const re = /^\d*(\.\d+)?$/
'123'.match(re)       // true
'123.3'.match(re)     // true
'123!3'.match(re)     // false