javascript - 验证字符串是否为正整数

Question

我想要最简单的故障安全测试来检查 JavaScript 中的字符串是否为正整数。

isNaN(str)为所有类型的非整数值返回 true，并parseInt(str)为浮点字符串返回整数，例如“2.5”。而且我也不想使用一些 jQuery 插件。

score 347 · Accepted Answer

给你两个答案：

基于解析
正则表达式

请注意，在这两种情况下，我都将“正整数”解释为 include 0，即使0它不是正数。如果您想禁止，我会附上注释0。

基于解析

如果您希望它是合理值范围内的规范化十进制整数字符串，您可以这样做：

function isInDesiredForm(str) {
    var n = Math.floor(Number(str));
    return n !== Infinity && String(n) === str && n >= 0;
}

或者如果你想允许空格和前导零：

function isInDesiredForm(str) {
    str = str.trim();
    if (!str) {
        return false;
    }
    str = str.replace(/^0+/, "") || "0";
    var n = Math.floor(Number(str));
    return n !== Infinity && String(n) === str && n >= 0;
}

实时测试台（不处理前导零或空格）：

function isInDesiredForm(str) {
    var n = Math.floor(Number(str));
    return n !== Infinity && String(n) === str && n >= 0;
}
function gid(id) {
    return document.getElementById(id);
}
function test(str, expect) {
    var result = isInDesiredForm(str);
    console.log(
        str + ": " +
        (result ? "Yes" : "No") +
        (expect === undefined ? "" : !!expect === !!result ? " <= OK" : " <= ERROR ***")
    );
}
gid("btn").addEventListener(
    "click",
    function() {
        test(gid("text").value);
    },
    false
);
test("1", true);
test("1.23", false);
test("1234567890123", true);
test("1234567890123.1", false);
test("0123", false); // false because we don't handle leading 0s
test(" 123 ", false); // false because we don't handle whitespace

<label>
  String:
  <input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">

实时测试台（处理前导零和空格）：

function isInDesiredForm(str) {
    str = str.trim();
    if (!str) {
        return false;
    }
    str = str.replace(/^0+/, "") || "0";
    var n = Math.floor(Number(str));
    return String(n) === str && n >= 0;
}
function gid(id) {
    return document.getElementById(id);
}
function test(str, expect) {
    var result = isInDesiredForm(str);
    console.log(
        str + ": " +
        (result ? "Yes" : "No") +
        (expect === undefined ? "" : !!expect === !!result ? " <= OK" : " <= ERROR ***")
    );
}
gid("btn").addEventListener(
    "click",
    function() {
        test(gid("text").value);
    },
    false
);
test("1", true);
test("1.23", false);
test("1234567890123", true);
test("1234567890123.1", false);
test("0123", true);
test(" 123 ", true);

<label>
  String:
  <input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">

如果您想禁止0，只需更改>= 0为> 0. （或者，在允许前导零的版本中，删除|| "0"就replace行了。）

这是如何工作的：

在允许空格和前导零的版本中：

str = str.trim();删除任何前导和尾随空白。
if (!str)捕获一个空白字符串并返回，其余的工作没有意义。
str = str.replace(/^0+/, "") || "0";从字符串中删除所有前导 0 - 但如果导致空白字符串，则恢复单个 0。

Number(str)：转换str为数字；这个数字很可能有一个小数部分，或者可能是NaN。
Math.floor：截断数字（切掉任何小数部分）。
String(...)：将结果转换回正常的十进制字符串。对于非常大的数字，这将采用科学记数法，这可能会破坏这种方法。（我不太清楚拆分在哪里，详细信息在规范中，但是对于整数，我相信它已经超过 21 位[到那时数字变得非常不精确，如 IEEE-754双精度数只有大约 15 位精度..)
... === str：将其与原始字符串进行比较。
n >= 0: 看看是不是阳性。

请注意，对于 input "+1"、任何在该阶段未转换为相同科学计数法的科学计数法输入String(...)，以及 JavaScript 使用的数字类型（IEEE-754 双精度二进制浮点），这都会失败无法准确地表示哪些解析更接近于与给定值不同的值（其中包括超过 9,007,199,254,740,992 的许多整数；例如，1234567890123456789将失败）。前者很容易解决，后两者就不太容易了。

正则表达式

另一种方法是通过正则表达式测试字符串的字符，如果您的目标是只允许（比如说）一个可选+的，后跟一个0或一个普通十进制格式的字符串：

function isInDesiredForm(str) {
    return /^\+?(0|[1-9]\d*)$/.test(str);
}

现场测试台：

function isInDesiredForm(str) {
    return /^\+?(0|[1-9]\d*)$/.test(str);
}
function gid(id) {
    return document.getElementById(id);
}
function test(str, expect) {
    var result = isInDesiredForm(str);
    console.log(
        str + ": " +
        (result ? "Yes" : "No") +
        (expect === undefined ? "" : !!expect === !!result ? " <= OK" : " <= ERROR ***")
    );
}
gid("btn").addEventListener(
    "click",
    function() {
        test(gid("text").value);
    },
    false
);
test("1", true);
test("1.23", false);
test("1234567890123", true);
test("1234567890123.1", false);
test("0123", false); // false because we don't handle leading 0s
test(" 123 ", false); // false because we don't handle whitespace

<label>
  String:
  <input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">

这是如何工作的：

^: 匹配字符串的开头
\+?: 允许一个可选的+（如果你不想的话，删除它）
(?:...|...)：允许这两个选项之一（不创建捕获组）：
(0|...): 允许0自己...
(...|[1-9]\d*): ...或一个以非数字开头0并后跟任意数量的十进制数字的数字。
$: 匹配字符串的结尾。

如果你想禁止0（因为它不是正数），正则表达式就变成了just /^\+?[1-9]\d*$/（例如，我们可以失去我们需要允许的交替0）。

如果要允许前导零（0123、00524），则只需将替换替换(?:0|[1-9]\d*)为\d+

function isInDesiredForm(str) {
    return /^\+?\d+$/.test(str);
}

如果要允许空格，请\s*在之后^和\s*之前添加$。

将其转换为数字时的注意事项：在现代引擎上使用+str或Number(str)执行它可能会很好，但较旧的引擎可能会以非标准（但以前允许）的方式扩展这些引擎，即前导零表示八进制（以 8 为基数），例如“010” => 8。验证数字后，您可以安全地使用parseInt(str, 10)它来确保它被解析为十进制（以 10 为基数）。parseInt将忽略字符串末尾的垃圾，但我们确保正则表达式没有任何垃圾。

score 85 · Accepted Answer

解决方案 1

如果我们将JavaScript 整数视为最大值4294967295（即Math.pow(2,32)-1），那么以下简短的解决方案将完美地工作：

function isPositiveInteger(n) {
    return n >>> 0 === parseFloat(n);
}

描述：

零填充右移运算符做了三件重要的事情：
- 截断小数部分
  - 123.45 >>> 0 === 123
- 负数的移位
  - -1 >>> 0 === 4294967295
- 范围内的“作品”MAX_INT
  - 1e10 >>> 0 === 1410065408
  - 1e7 >>> 0 === 10000000
parseFloat正确解析字符串数字（NaN非数字字符串的设置）

测试：

"0"                     : true
"23"                    : true
"-10"                   : false
"10.30"                 : false
"-40.1"                 : false
"string"                : false
"1234567890"            : true
"129000098131766699.1"  : false
"-1e7"                  : false
"1e7"                   : true
"1e10"                  : false
"1edf"                  : false
" "                     : false
""                      : false

演示：http: //jsfiddle.net/5UCy4/37/

解决方案 2

另一种方法适用于所有有效到的数值Number.MAX_VALUE，即大约1.7976931348623157e+308：

function isPositiveInteger(n) {
    return 0 === n % (!isNaN(parseFloat(n)) && 0 <= ~~n);
}

描述：

!isNaN(parseFloat(n))用于过滤纯字符串值，例如"", " ", "string";
0 <= ~~n过滤负数和大的非整数值，例如"-40.1", "129000098131766699";
(!isNaN(parseFloat(n)) && 0 <= ~~n)true如果 value 既是数字又是正数，则返回；
0 === n % (...)检查 value 是否为非浮点型 - 此处(...)（参见 3）0在的情况下进行评估，在 . 的情况下false进行1评估true。

测试：

"0"                     : true
"23"                    : true
"-10"                   : false
"10.30"                 : false
"-40.1"                 : false
"string"                : false
"1234567890"            : true
"129000098131766699.1"  : false
"-1e10"                 : false
"1e10"                  : true
"1edf"                  : false
" "                     : false
""                      : false

演示：http: //jsfiddle.net/5UCy4/14/

以前的版本：

function isPositiveInteger(n) {
    return n == "0" || ((n | 0) > 0 && n % 1 == 0);
}

演示：http: //jsfiddle.net/5UCy4/2/

score 26 · Accepted Answer

在 node 和超过 90% 的所有浏览器（IE 和 Opera Mini 除外）中工作的现代解决方案是使用Number.isInteger，然后进行简单的肯定检查。

Number.isInteger(x) && x > 0

这是在 ECMAScript 2015 中完成的。

function isPositiveInteger(x) {
    return Number.isInteger(x) && x > 0
}

Polyfil 是：

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

如果您需要支持可能是字符串或数字形式的输入，那么您可以使用这个函数，在所有现有答案（2/1/2018）在某种形式的输入上失败后，我编写了一个大型测试套件。

function isPositiveInteger(v) {
  var i;
  return v && (i = parseInt(v)) && i > 0 && (i === v || ''+i === v);
}

score 25 · Accepted Answer

25

看起来正则表达式是要走的路：

var isInt = /^\+?\d+$/.test('the string');

于 2012-05-31T13:41:15.723 回答

score 10 · Accepted Answer

10

ES6：

Number.isInteger(Number(theNumberString)) && Number(theNumberString) > 0

于 2020-06-28T11:34:31.007 回答

score 5 · Accepted Answer

这就是我验证字符串是否为正整数的方式。

var str = "123";
var str1 = "1.5";
var str2 = "-123";

console.log("is str positive integer: ", Number.isInteger(Number(str)) && Number(str) > 0)
console.log("is str1 positive integer: ", Number.isInteger(Number(str1)) && Number(str1) > 0)
console.log("is str2 positive integer: ", Number.isInteger(Number(str2)) && Number(str2) > 0)

score 4 · Accepted Answer

这几乎是一个重复的问题：

在 JavaScript 中验证十进制数字 - IsNumeric()

它的答案是：

function isNumber(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}

所以，一个正整数将是：

function isPositiveInteger(n) {
  var floatN = parseFloat(n);
  return !isNaN(floatN) && isFinite(n) && floatN > 0
      && floatN % 1 == 0;
}

score 2 · Accepted Answer

return ((parseInt(str, 10).toString() == str) && str.indexOf('-') === -1);

如果你给出一个像'0001'这样的字符串，那将不起作用

score 2 · Accepted Answer

我的函数检查数字是否为 +ve 并且也可能具有十进制值。

       function validateNumeric(numValue){
            var value = parseFloat(numValue);
            if (!numValue.toString().match(/^[-]?\d*\.?\d*$/)) 
                    return false;
            else if (numValue < 0) {
                return false;
            }
            return true;        
        }

score 2 · Accepted Answer

简单的

function isInteger(num) {
  return (num ^ 0) === num;
}

console.log(isInteger(1));

您还可以扩展 Number 并通过原型将函数分配给它。

score 2 · Accepted Answer

只是建立在上面 VisioN 的答案上，如果您使用的是 jQuery 验证插件，您可以使用它：

$(document).ready(function() {
    $.validator.addMethod('integer', function(value, element, param) {
        return (value >>> 0 === parseFloat(value) && value > 0);
    }, 'Please enter a non zero integer value!');
}

然后你可以在你的正常规则集中使用或以这种方式动态添加它：

$("#positiveIntegerField").rules("add", {required:true, integer:true});

score 1 · Accepted Answer

大多数时候，您需要这种类型的数据库使用检查，例如检查字符串是否有效的 userId。因此，不可能有任何奇怪的符号可以被解析为整数。整数也应该在整数的数据库范围内。你只需要像 1,2,3 这样的普通 int 等等。

const isStrNormPosInt = (str: string) => {
  return /^([1-9]\d*)$/.test(str) && Number(str) <= 2147483647 // postgres max int
}

如果检查通过，您可以将其转换为数字Number(str)

score 1 · Accepted Answer

如果您使用的是 HTML5 表单，则可min="0"以为表单元素使用属性<input type="number" />。所有主要浏览器都支持这一点。它不涉及用于此类简单任务的 Javascript，而是集成在新的 html 标准中。它记录在https://www.w3schools.com/tags/att_input_min.asp

score 0 · Accepted Answer

0

(~~a == a)a字符串在哪里。

于 2014-04-01T21:49:59.723 回答

javascript - 验证字符串是否为正整数

14 回答 14

基于解析

正则表达式

解决方案 1

解决方案 2

Related

Reference