正则表达式检查字符串是否只包含数字-Java 学习之路

209

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

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

22 回答

-1
```
var reg = /^\d+$/;
```
应该这样做 . 原始文件匹配任何由一个数字组成的内容 .
回复于 2024-04-20T14:17:16+08:00
12
正如您所说，您希望哈希仅包含数字 .
```
var reg = new RegExp('^[0-9]+$');
```
要么
```
var reg = new RegExp('^\\d+$');
```
\d 和 [0-9] 都意味着同样的事情 . 使用的意思是搜索[0-9]中的一个或多个 .
回复于 2024-04-20T14:17:16+08:00
1
这个也允许使用signed和float数字或空字符串：
```
var reg = /^-?\d*\.?\d*$/
```
如果你不想让空字符串使用这个：
```
var reg = /^-?\d+\.?\d*$/
```
回复于 2024-04-20T14:17:16+08:00

-1

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

回复于 2024-04-20T14:17:16+08:00

-3

这对你的目的来说极端矫枉过正，但这就是我的用法：

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

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

如上所述，reSnippet被设计为被删除到其他正则表达式中，因此您可以提取（或避免）数字 . 尽管有所有括号，但它不包含任何捕获组 . 因此，“matchOnlyNumberRe”仅匹配作为数字的字符串，并且具有整个字符串的捕获组 .

以下是Jasmine测试，因此您可以看到它的作用和不处理：

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

回复于 2024-04-20T14:17:16+08:00

59
```
^[0-9]$
```
...是匹配任何单个数字的正则表达式，因此1将返回true但123将返回false .

如果你添加*量词，
```
^[0-9]*$
```
表达式将匹配任意长度的数字字符串，123将返回true . （123f仍然会返回false） .

请注意，从技术上讲，空字符串是一个0长度的数字字符串，因此它将使用^ [0-9] * $返回true如果您只想接受包含1位或更多位数的字符串，请使用而不是*
```
^[0-9]+$
```
正如其他许多人所指出的那样，实现这一点的方法不止一种，但我觉得指出原始问题中的代码只需要一个额外的字符就可以按预期工作是合适的 .
回复于 2024-04-20T14:17:16+08:00
-3
此功能检查它的输入是否是传统意义上的数字，因为人们期望正常数字检测功能起作用 .

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

它绕过了所有的JS民间传说，比如tipeof（NaN）= number，parseint（'1 Kg'）= 1，booleans强制数字等等 .

它是通过将参数呈现为字符串并将该字符串与@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，它们与另一半相匹配 .
回复于 2024-04-20T14:17:16+08:00
4
如果您只需要正整数且不需要前导零（例如“0001234”或“00”）：
```
var reg = /^(?:[1-9]\d*|\d)$/;
```
回复于 2024-04-20T14:17:16+08:00
84
为什么不使用类似的东西：
```
$.isNumeric($(input).val())
```
是否对jquery进行了测试，并检查了最常见的情况
回复于 2024-04-20T14:17:16+08:00
16
你需要 * 所以它说"zero or more of the previous character"这应该这样做：
```
var reg = new RegExp('^\\d*$');
```
回复于 2024-04-20T14:17:16+08:00

-2

如果这些数字不应该是荒谬的，可以使用：

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

回复于 2024-04-20T14:17:16+08:00

388
在输入时，如果要过滤掉其他字符并仅在输入字段中显示数字，则可以替换keyup上字段的值：
```
var yourInput = jQuery('#input-field');
    yourInput.keyup(function() {
        yourInput.val((yourInput.val().replace(/[^\d]/g,'')))
    })
```
回复于 2024-04-20T14:17:16+08:00

Simple Regex javascript

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

*Result ：

1232432122

Checks for only numbers:

if(cnpj.length > 0){
   return true;
}

Simple example

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

回复于 2024-04-20T14:17:16+08:00

1
您也可以使用以下方法，但要注意它们的内部实现和/或返回值 .
```
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 实现细节的注意事项，记录在案here . 一个考虑因素是如果一个布尔值被传递，因为 isNaN(+false|true) 被强制转换为它们的数字等价物，因此返回 false 但是可能期望该函数返回 true ，因为布尔值在我们测试的意义上不是数字 .

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

我个人的偏好，虽然因为包括一元运算符而可能被认为不太可读，但由于速度和简洁性，它是1A和1B .

Perf https://jsperf.com/numeric-string-test-regexvsisnan/1
回复于 2024-04-20T14:17:16+08:00

也许它有效：

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

回复于 2024-04-20T14:17:16+08:00

\d 将与小数点不匹配 . 使用以下小数表 .

const re = /^[0-9.]+$/
'123'.match(re)       // true
'123.3'.match(re)     // true
'123!3'.match(re)     // false

回复于 2024-04-20T14:17:16+08:00

42
我看到你已经得到了很多答案，但是如果你正在寻找一个可以匹配整数和浮点数的正则表达式，那么这个将适合你：
```
var reg = /^-?\d*\.?\d+$/;
```
回复于 2024-04-20T14:17:16+08:00

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

回复于 2024-04-20T14:17:16+08:00

1
如果要将数字与有符号值匹配，可以使用：
```
var reg = new RegExp('^(\-?|\+?)\d*$');
```
它将验证格式的数量：1，-1,1 .
回复于 2024-04-20T14:17:16+08:00

用这个：

const pattern = new RegExp(/^[+-]?\d+(\.\d+)?([Ee][+-]?\d+)?$/g);

回复于 2024-04-20T14:17:16+08:00

5
仅限正则表达式（已更新）
```
var reg = new RegExp('[^0-9]','g');
```
回复于 2024-04-20T14:17:16+08:00
1
```
var pattern = /[0-9!"£$%^&*()_+-=]/;
```
这试图避免某些情况，以防万一：

溢出原始字符串可能传递给的任何缓冲区 . 由非正规数字引起的缓慢或奇怪，如 1E-323 . 在预期有限数量时传递无穷大（尝试 1E309 或 -1E309 ） .
回复于 2024-04-20T14:17:16+08:00

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

22 回答

相关问题