blocks|key|1738858|text|正如您所说的，您希望hash只包含数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1738859|const+reg+=+new+RegExp('%5E[0-9]%2B$');|code-block|syntax|javascript|1738860|或|1738861|const+reg+=+new+RegExp('%5E\d%2B$')|1738862|\d和[0-9]的意思是一样的。%2B+used表示搜索0-9中的一个或多个匹配项。|offset|length|style|CODE|1738863|entityMap^0|0|0|0|0|0|2|3|5|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

As you said, you want hash to contain only numbers.
<pre><code>const reg = new RegExp('^[0-9]+$');
</code></pre>
or
<pre><code>const reg = new RegExp('^\d+$')
</code></pre>
<code>\d</code> and <code>[0-9]</code> both mean the same thing.
The + used means that search for one or more occurring of [0-9].

blocks|key|1738871|text|var+reg+=+/%5E\d%2B$/;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1738872|应该做这件事。原始的匹配任何只包含一个数字的内容。|unstyled|1738873|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>var reg = /^\d+$/;
</code></pre>

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

blocks|key|1952361|text|您需要*，以便它显示“前一个字符的零个或多个”，应该是这样的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1952362|var+reg+=+new+RegExp('%5E\\d*$');|code-block|syntax|javascript|1952363|entityMap^0|3|1|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You need the <code>*</code> so it says "zero or more of the previous character" and this should do it:

<pre><code>var reg = new RegExp('^\\d*$');
</code></pre>

blocks|key|1952370|text|这将允许有符号和浮点数或空字符串：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1952371|var+reg+=+/%5E-?\d*\.?\d*$/|code-block|syntax|javascript|1952372|如果您不希望允许空字符串，请使用以下命令：|1952373|var+reg+=+/%5E-?\d%2B\.?\d*$/|1952374|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

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

<pre><code>var reg = /^-?\d*\.?\d*$/
</code></pre>

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

<pre><code>var reg = /^-?\d+\.?\d*$/
</code></pre>

blocks|key|1738938|text|仅数字正则表达式(已更新)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1738939|+var+reg+=+new+RegExp('[%5E0-9]','g');|code-block|syntax|javascript|1738940|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Number only regex (Updated)

<pre><code> var reg = new RegExp('[^0-9]','g');
</code></pre>

blocks|key|1952421|text|var+validation+=+{
++++isEmailAddress:function(str)+{
++++++++var+pattern+=/%5E\w%2B([\.-]?\w%2B)*@\w%2B([\.-]?\w%2B)*(\.\w{2,3})%2B$/;
++++++++return+pattern.test(str);++//+returns+a+boolean
++++},
++++isNotEmpty:function+(str)+{
++++++++var+pattern+=/\S%2B/;
++++++++return+pattern.test(str);++//+returns+a+boolean
++++},
++++isNumber:function(str)+{
++++++++var+pattern+=+/%5E\d%2B$/;
++++++++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"));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1952422|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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"));
</code></pre>

blocks|key|1952431|text|我看你已经得到了很多答案，但是如果你正在寻找一个可以匹配整数和浮点数的正则表达式，这个答案将为你工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1952432|var+reg+=+/%5E-?\d*\.?\d%2B$/;|code-block|syntax|javascript|1952433|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I see you have already gotten a lot of answers, but if you are looking for a regular expression that can match integers and floating point numbers, this one will work for you:

<pre><code>var reg = /^-?\d*\.?\d+$/;
</code></pre>

blocks|key|1738991|text|这个函数检查它的输入是否是经典意义上的数字，因为人们期望一个正常的数字检测函数工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1738992|例如，这是一个可以用于HTML表单输入的测试。|1738993|它绕过了所有JS民间传说，比如tipeof(NaN)+=+number，parseint('1+Kg')+=+1，布尔值被强制化为数字，等等。|1738994|它通过将参数呈现为字符串并根据正则表达式检查该字符串来实现，例如@codename-但允许5.和.5等条目|1738995|function+isANumber(+n+)+{
++++var+numStr+=+/%5E-?(\d%2B\.?\d*)$%7C(\d*\.?\d%2B)$/;
++++return+numStr.test(+n.toString()+);
}

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

numeric:
Logger.log(+'isANumber(+"0"+):+'+%2B+isANumber(+'0'+)+);
Logger.log(+'isANumber(+"12.5"+):+'+%2B+isANumber(+'12.5'+)+);
Logger.log(+'isANumber(+".5"+):+'+%2B+isANumber(+'.5'+)+);
Logger.log(+'isANumber(+"5."+):+'+%2B+isANumber(+'5.'+)+);
Logger.log(+'isANumber(+"-5"+):+'+%2B+isANumber(+'-5'+)+);
Logger.log(+'isANumber(+"-5."+):+'+%2B+isANumber(+'-5.'+)+);
Logger.log(+'isANumber(+"-.5"+):+'+%2B+isANumber(+'-5.'+)+);
Logger.log(+'isANumber(+"1234567890"+):+'+%2B+isANumber(+'1234567890'+));|code-block|syntax|javascript|1738996|正则表达式的解释：|1738997|/%5E-?(\d%2B\.?\d*)$%7C(\d*\.?\d%2B)$/++|1738998|开头的"%5E“和结尾的"$”匹配字符串的开始和结束，以确保检查跨越整个字符串。"-?“部分是减号和"?“允许零个或一个实例的乘法器。|1738999|然后有两个相似的组，用括号分隔。字符串必须与这两个组中的任一组匹配。第一个匹配像5这样的数字，第二个匹配.5|1739000|第一组是|1739001|\d%2B\.?\d*|1739002|"\d%2B“与数字(\d)匹配一次或多次。|1739003|".?“是小数点(用"\“进行转义以消除其魔力)，0次或1次。|1739004|最后一部分"\d*“也是一个数字，零次或多次。|1739005|所有的部分都是可选的，除了第一个数字，所以这个组匹配像5.这样的数字，而不是由另一半匹配的.5。|1739006|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1B|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1C|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1E|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|J|7|1I|8|@]|9|@]|A|$K|L]]|$1|Y|3|Z|5|6|7|1J|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1K|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1L|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1M|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

This function checks if it's input is numeric in the classical sense, as one expects a normal number detection function to work. 

It's a test one can use for HTML form input, for example. 

It bypasses all the JS folklore, like tipeof(NaN) = number, parseint('1 Kg') = 1, booleans coerced into numbers, and the like. 

It does it by rendering the argument as a string and checking that string against a regex like those by @codename- but allowing entries like 5. and .5 

<pre><code>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' ));
</code></pre>

Explanation of the regex: 

<pre><code>/^-?(\d+\.?\d*)$|(\d*\.?\d+)$/ 
</code></pre>

The initial "^" and the final "$" match the start and the end of the string, to ensure the check spans the whole string. The "-?" part is the minus sign with the "?" multiplier that allows zero or one instance of it.

Then there are two similar groups, delimited by parenthesis. The string has to match either of these groups. The first matches numbers like 5. and the second .5

The first group is 

<pre><code>\d+\.?\d*
</code></pre>

The "\d+" matches a digit (\d) one or more times. 
The "\.?" is the decimal point (escaped with "\" to devoid it of its magic), zero or one times. 

The last part "\d*" is again a digit, zero or more times. 
All the parts are optional but the first digit, so this group matches numbers like 5. and not .5 which are matched by the other half.

blocks|key|1952456|text|如果要将数字与有符号的值进行匹配，可以使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1952457|var+reg+=+new+RegExp('%5E(\-?%7C\%2B?)\d*$');|code-block|syntax|javascript|1952458|它将验证以下格式的数字：%2B+1，-1，1。|1952459|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you want to match the numbers with signed values, you can use:

<pre><code>var reg = new RegExp('^(\-?|\+?)\d*$');
</code></pre>

It will validate the numbers of format: +1, -1, 1.

blocks|key|1739026|text|在输入时，如果您想过滤掉其他字符，只在输入字段中显示数字，则可以在keyup上替换该字段的值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739027|++++var+yourInput+=+jQuery('#input-field');
++++yourInput.keyup(function()+{
++++++++yourInput.val((yourInput.val().replace(/[%5E\d]/g,'')))
++++})+++|code-block|syntax|javascript|1739028|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

On input, if you want to filter out other characters and only show numbers in the input field, you could replace the value of the field on keyup:

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

blocks|key|1739054|text|对于您的目的来说，这是非常夸张的，但以下是我使用的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739055|var+numberReSnippet+=+"(?:NaN%7C-?(?:(?:\\d%2B%7C\\d*\\.\\d%2B)(?:[E%7Ce][%2B%7C-]?\\d%2B)?%7CInfinity))";
var+matchOnlyNumberRe+=+new+RegExp("%5E("%2B+numberReSnippet+%2B+")$");|code-block|syntax|javascript|1739056|据我所知，这与Java和JavaScript抛给你的数字的所有变体相匹配，包括"-Infinity“、"1e-24”和"NaN“。它还可以匹配您可能键入的数字，例如"-.5“。|1739057|正如所写的那样，reSnippet被设计成可以放入其他正则表达式中，因此您可以提取(或避免)数字。尽管有所有的括号，但它不包含捕获组。因此，"matchOnlyNumberRe“只匹配为数字的字符串，并且对整个字符串有一个捕获组。|1739058|下面是Jasmine测试，因此您可以看到它能处理什么和不能处理什么：|1739059|describe("Number+Regex",+function()+{
++++var+re+=+new+RegExp("%5E("%2B+numberReSnippet+%2B+")$");
++++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%2B24")).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%2B24.5")).toBe(false);
++++++++expect(re.test("-.Infinity")).toBe(false);
++++});
});|1739060|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

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

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

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".

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:

<pre><code>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);
 });
});
</code></pre>

blocks|key|1739094|text|%5E[0-9]$+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1739095|...is匹配任何单个数字的正则表达式，因此1将返回true，而123将返回false。|unstyled|1739096|如果你加上*量词，|1739097|%5E[0-9]*$|1739098|表达式将匹配任意长度的数字字符串，123将返回true。(123f仍将返回false)。|1739099|请注意，从技术上讲，空字符串是0长度的数字字符串，因此它将使用%5E0-9*$返回true。如果只接受包含1位或更多数字的字符串，请使用%2B而不是*|1739100|%5E[0-9]%2B$|1739101|正如其他许多人所指出的那样，有很多方法可以实现这一点，但我觉得应该指出，原始问题中的代码只需要一个额外的字符就可以达到预期的效果。|1739102|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$B|C]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$B|C]]|$1|Q|3|R|5|F|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|F|7|12|8|@]|9|@]|A|$]]]|T|$]]

<pre><code>^[0-9]$ 
</code></pre>

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

If you add the * quantifier,

<pre><code>^[0-9]*$
</code></pre>

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 *

<pre><code>^[0-9]+$
</code></pre>

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.

blocks|key|1739119|text|如果您只需要正整数，而不需要前导零(例如"0001234“或"00")：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739120|var+reg+=+/%5E(?:[1-9]\d*%7C\d)$/;|code-block|syntax|javascript|1739121|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you need just positive integer numbers and don't need leading zeros (e.g. "0001234" or "00"):

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

blocks|key|1952547|text|/%5E[\%2B\-]?\d*\.?\d%2B(?:[Ee][\%2B\-]?\d%2B)?$/|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1952548|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

blocks|key|1739145|text|var+pattern+=+/[0-9!"£$%25%5E&*()_%2B-=]/;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1739146|这试图避免某些情况，以防万一：|unstyled|1739147|使原始字符串可能被传递到的任何缓冲区溢出。由像1E-323这样的非正规数引起的缓慢或奇怪。当需要一个有限数时传递无穷大(尝试1E309或-1E309)。|offset|length|style|CODE|1739148|entityMap^0|0|0|N|6|1Q|5|1W|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|F|7|X|8|@]|9|@]|A|$]]]|N|$]]

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

This tries to avoid some scenarios, just in case:

Overflowing any buffers the original string might get passed to.
Slowness or oddities caused by denormal numbers like <code>1E-323</code>.
Passing Infinity when a finite number is expected (try <code>1E309</code> or <code>-1E309</code>).

blocks|key|1952558|text|为什么不使用下面这样的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1952559|$.isNumeric($(input).val())|code-block|syntax|javascript|1952560|是否测试了jquery，并检查了最常见的情况|1952561|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Why dont use something like:

<pre><code>$.isNumeric($(input).val())
</code></pre>

Is jquery tested, and the most common case are checked

blocks|key|1739202|text|您也可以使用以下方法，但要知道它们的内部实现和/或返回值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739203|1A+isNaN(%2B'13761123123123');+//+returns+true
1B+isNaN(%2B'13761123123ABC');+//+returns+false

2A+~~'1.23';+//+returns+1
2B+~~'1.2A';+//+returns+0|code-block|syntax|javascript|1739204|对于1A和1B，在传递给isNaN()函数之前，字符串首先使用%2B运算符进行类型转换。这是因为包含非数字值的number类型返回NaN。在here文档中有关于isNaN()'s实现细节的注意事项。一个需要考虑的问题是，如果布尔值作为isNaN(%2Bfalse%7Ctrue)传递，则会强制将其转换为等效的数值，从而返回false，但您可能希望函数返回true，因为布尔值不是我们正在测试的意义上的数值。|offset|length|style|CODE|1739205|对于2A和2B，值得注意的是，寻找数字的补码要求给定的值在spec中可以引用的有符号32位整数的值范围内。|1739206|我个人的偏好是1A和1B，因为它的速度和简洁性，尽管它可能被认为可读性较差，因为它们包括一元运算符。|1739207|性能https://jsperf.com/numeric-string-test-regexvsisnan/1|1739208|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN#Confusing_special-case_behavior|1|https://www.ecma-international.org/ecma-262/9.0/index.html#sec-bitwise-not-operator|2|https://jsperf.com/numeric-string-test-regexvsisnan/1^0|0|0|C|7|V|1|1R|3|26|9|37|I|4B|5|4R|4|1W|4|0|0|T|4|1|0|0|2|1H|2|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@$I|17|J|18|K|L]|$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]|$I|1F|J|1G|K|L]|$I|1H|J|1I|K|L]|$I|1J|J|1K|K|L]]|9|@$I|1L|J|1M|1|1N]]|A|$]]|$1|M|3|N|5|6|7|1O|8|@]|9|@$I|1P|J|1Q|1|1R]]|A|$]]|$1|O|3|P|5|6|7|1S|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1T|8|@]|9|@$I|1U|J|1V|1|1W]]|A|$]]|$1|S|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]|12|$5|V|W|X|A|$Y|13]]]]

You could also use the following methods but be aware of their internal implementation and/or return values.

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

2A ~~'1.23'; // returns 1
2B ~~'1.2A'; // returns 0
</code></pre>

For 1A &amp; 1B the string is first type coerced using the <code>+</code> operator before being passed to the <code>isNaN()</code> function. This works because a number types that include non-numeric values return <code>NaN</code>. There are considerations with the <code>isNaN()'s</code> implementation details which is documented <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN#Confusing_special-case_behavior" rel="nofollow noreferrer">here</a>. One consideration is if a boolean value is passed as <code>isNaN(+false|true)</code> are coerced to their numeric equivalents and thus <code>false</code> is returned but one might expect the function to return <code>true</code> since the boolean value isn't numeric in the sense of what we are testing.

For 2A &amp; 2B it's worth noting that finding the complement of the number requires the given value in question to be within the range the values of a signed 32 bit integer which can be referenced in the <a href="https://www.ecma-international.org/ecma-262/9.0/index.html#sec-bitwise-not-operator" rel="nofollow noreferrer">spec</a>.

My personal preference, although it could be argued to be less readable since they include the unary operator, is 1A &amp; 1B because of the speed and conciseness.

Perf <a href="https://jsperf.com/numeric-string-test-regexvsisnan/1" rel="nofollow noreferrer">https://jsperf.com/numeric-string-test-regexvsisnan/1</a>

blocks|key|1739228|text|也许它是有效的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739229|let+a+=+"1234"
parseInt(a)+==+a+//+true
let+b+=+"1234abc"
parseInt(b)+==+b+//+false|code-block|syntax|javascript|1739230|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Maybe it works:

<pre><code>let a = "1234"
parseInt(a) == a // true
let b = "1234abc"
parseInt(b) == b // false
</code></pre>

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

I get false on both <code>"123"</code> and <code>"123f"</code>. I would like to check if the hash only contains numbers. Did I miss something?

Regex to check whether a string contains only numbers

jQuery

Java

hash = window.location.hash.substr(1);var reg = new RegExp('^[0-9]$');console.log(reg.test(hash));我在"123"和"123f"上都得到了false。我想检查散列是否只包含数字。我错过了什么吗？

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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