验证字符串是否为正整数

Validate that a string is a positive integer

本文关键字：整数 是否 字符串 验证      更新时间：2023-09-26

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

isNaN(str) 为各种非整数值返回 true，parseInt(str)返回浮点字符串的整数，如"2.5"。我也不想使用一些jQuery插件。

给你

两个答案：

  • 基于解析

  • 正则表达式

请注意，在这两种情况下，我都将"正整数"解释为包含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即可。（或者，在允许前导零的版本中，删除replace行上的|| "0"。

工作原理：

  1. 在允许空格和前导零的版本中：
  • str = str.trim(); 删除任何前导和尾随白步。
  • if (!str)捕获一个空白字符串并返回，执行其余工作没有意义。
  • str = str.replace(/^0+/, "") || "0"; 从字符串中删除所有前导 0，但如果这导致字符串为空，则会恢复单个 0。

  1. Number(str)：将str转换为一个数字;该数字很可能有一个小数部分，或者可能是NaN。

  2. Math.floor：截断数字（切掉任何小数部分）。

  3. String(...) ：将结果转换回普通的十进制字符串。对于非常大的数字，这将采用科学记数法，这可能会打破这种方法。（我不太清楚拆分在哪里，细节在规格中，但对于整数，我相信它是在你超过 21 位的点 [到那时数字已经变得非常不精确，因为 IEEE-754 双精度数字只有 15 位精度......

  4. ... === str：将其与原始字符串进行比较。

  5. n >= 0 ：检查它是否为阳性。

请注意，这对于输入"+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">

工作原理：

  1. ^：匹配字符串的开头

  2. '+?：允许单个可选+（如果不想，请将其删除）

  3. (?:...|...)：允许以下两个选项之一（不创建捕获组）：

  4. (0|...) ： 允许自行0...

  5. (...|[1-9]'d*) ： ...或以 0 以外的内容开头并后跟任意数量的十进制数字的数字。

  6. $：匹配字符串的结尾。

如果你想禁止0（因为它不是正的），正则表达式就变成了/^'+?[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会忽略字符串末尾的垃圾，但我们确保正则表达式没有任何垃圾。

解决方案 1

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

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

描述：

  1. 零填充右移运算符执行三项重要操作：
    • 截断小数部分
      • 123.45 >>> 0 === 123
    • 负数的偏移
      • -1 >>> 0 === 4294967295
    • MAX_INT范围内的"作品"
      • 1e10 >>> 0 === 1410065408
      • 1e7 >>> 0 === 10000000
  2. 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);
}

描述：

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

测试：

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

适用于节点和超过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);
}

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

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

ES6：

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

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

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

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

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)

简单

function isInteger(num) {
  return (num ^ 0) === num;
}
console.log(isInteger(1));

您还可以扩展数字并通过原型为其分配功能。

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

如果您给出像"0001"这样的字符串，则不起作用

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

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

只是为了建立在上面 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});

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

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

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

我的问题基本相同：检查用户是否键入了一个整数和正数。

我们的朋友Levi的代码和响应是我迄今为止在整个互联网上找到的最好的，并且在处理错误方面令人满意。

我在网站上找到了以下代码（https://bobbyhadz.com/blog/javascript-check-if-string-is-positive-integer）：

function isPositiveInteger(str) {
   if (typeof str !== 'string') {
     return false;
   }
   const num = Number(str);
   if (Number.isInteger(num) && num > 0) {
     return true;
   }
   return false;
}

但是，对于1e10它不会正确返回。

我的标准需要在@VisioN的答案之上进行一些额外的检查。

  • 不是负数 - 包括-0
  • 不是小数点数为零的浮点数 - 0.0 ， 1.000000
  • 不是指数表示法中的数字 - 1e10

我发现这对于验证快速路由器的路由参数很有用。 例如 /books/:bookId

法典 

/**
 * Validate that a string is a positive integer
 * Excludes float numbers with a zero decimal part, exponential notation and negative 0
 * @param n
 * @returns {boolean}
 */
function isStrictlyPositiveInteger(n) {
    const nString = n.toString(), nInt = parseInt(n), nFloat = parseFloat(n);
    // if a negative number (works on -0)
    if (nString.charAt(0) === '-') {
        return false;
    }
    // if an exponential like 1e10
    if (nString.indexOf('e') > -1) {
        return false;
    }
    // if a float number with a zero decimal part e.g 0.0
    if ((nFloat === nInt) && (nString.indexOf('.') > -1)) {
        return false;
    }
    // if a positive integer
    // https://stackoverflow.com/a/10835227/8470877
    return (0 === n % (!isNaN(nFloat) && 0 <= ~~n));
}

测试

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

(~~a == a)其中a是字符串。

相关文章：