正则表达式检查字符串是否仅包含数字

var reg = /^'d+$/;

应该这样做。 原件匹配任何正好由一位数字组成的内容。

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

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

或

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

'd和[0-9]的意思是一样的。使用的 + 表示搜索 [0-9] 中的一个或多个匹配项。

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

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

如果您不想允许空字符串，请使用以下命令：

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

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

^[0-9]$ 

。是匹配任何一位数的正则表达式，因此 1 将返回 true，但 123 将返回 false。

如果添加 * 量词，

^[0-9]*$

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

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

^[0-9]+$

正如许多其他人所指出的那样，有很多方法可以实现这一点，但我觉得指出原始问题中的代码只需要一个额外的字符即可按预期工作是合适的。

对于您的目的来说，这是极端的矫枉过正：

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

''d 将不匹配小数点。使用以下小数点。

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

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

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

它绕过了所有的JS民间传说，比如tipeof(NaN(=数字，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( 匹配一次或多次。
"''.？"是小数点(用"''"转义以使其失去魔力(，零次或一次。

最后一部分"''d*"又是一个数字，零次或多次。
所有部分都是可选的，但第一个数字除外，因此该组匹配 5 等数字。而不是与另一半匹配的 .5。

如果您只需要正整数而不需要前导零(例如"0001234"或"00"(：

var reg = /^(?:[1-9]'d*|'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等非正常数字引起的缓慢或奇怪。
• 当期望有限数时传递Infinity(尝试1E309或-1E309(。

为什么不使用类似的东西：

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

是否经过 jquery 测试，并检查最常见的情况

也许它有效：

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

你需要*，所以它说"零个或多个前一个字符"，这应该这样做：

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

Simple 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

对于 1A 和 1B，字符串在传递给 isNaN() 函数之前首先使用 + 运算符进行类型强制。这是因为包含非数值的数字类型返回 NaN 。此处记录的isNaN()'s实现详细信息有一些注意事项。一个考虑因素是，如果布尔值在isNaN(+false|true)被强制到它们的数字等效项时传递，因此返回false，但人们可能期望函数返回true因为布尔值不是我们正在测试的意义上的数字。

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

我个人的偏好，虽然可以说是可读性较差，因为它们包括一元运算符，但由于速度和简洁性，是1A和1B。

性能 https://jsperf.com/numeric-string-test-regexvsisnan/1

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

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

在输入时，如果要过滤掉其他字符并仅在输入字段中显示数字，则可以在 keyup 上替换该字段的值：

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

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

如果要将数字与有符号值匹配，可以使用：

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

它将验证格式的数量：+1， -1， 1.

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

这会尽量避免某些情况，以防万一：

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

仅数字正则表达式(更新(

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