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

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

"123"和 "123f"都是假的。我想检查散列是否只包含数字。我错过什么了吗？

1126698 次浏览
小开

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

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

或

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次。< / p >

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

小开

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

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提供给您的所有数字变体相匹配，包括“-无限”、“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这样的非正常数字引起的缓慢或异常。
  • 当需要一个有限数字时传递Infinity(尝试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

对于1A &在传递给isNaN()函数之前，字符串首先使用+操作符进行强制类型转换。这是因为包含非数字值的数字类型返回NaN。在这里中记录的isNaN()'s实现细节有一些注意事项。一个需要考虑的问题是，如果一个布尔值被传递为isNaN(+false|true)，则被强制转换为它们的数字等价物，因此返回false，但人们可能期望该函数返回true，因为布尔值在我们测试的意义上不是数字。

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

我个人的偏好是1A &因为速度和简洁。

穿孔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

提交答案