提问



什么是在JavaScript中验证十进制数字最干净,最有效的方法?


奖励积分:



  1. 净度。解决方案应该简洁明了。

  2. 跨平台。



测试用例:


01. IsNumeric('-1')      => true
02. IsNumeric('-1.5')    => true
03. IsNumeric('0')       => true
04. IsNumeric('0.42')    => true
05. IsNumeric('.42')     => true
06. IsNumeric('99,999')  => false
07. IsNumeric('0x89f')   => false
08. IsNumeric('#abcdef') => false
09. IsNumeric('1.2.3')   => false
10. IsNumeric('')        => false
11. IsNumeric('blah')    => false

最佳参考


@Joel的答案非常接近,但在以下情况下会失败:


// Whitespace strings:
IsNumeric(' ')    == true;
IsNumeric('\t\t') == true;
IsNumeric('\n\r') == true;

// Number literals:
IsNumeric(-1)  == false;
IsNumeric(0)   == false;
IsNumeric(1.1) == false;
IsNumeric(8e5) == false;


前段时间我不得不实现IsNumeric函数,找出变量是否包含数值,无论其类型,它可能是包含数字的String价值(我不得不考虑指数表示法等),Number对象,几乎任何东西都可以传递给那个函数,我不能做任何类型的假设,照顾类型强制(例如[[。]] [[+true == 1;true不应被视为"numeric"


我认为值得分享这套针对众多功能实现的 +30单元测试,并且还共享通过我所有测试的那个:[109]


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


P.S。 isNaN&由于强制转换为数字,isFinite具有令人困惑的行为。在ES6中,Number.isNaN& Number.isFinite将解决这些问题。使用它们时请记住这一点。 [110] [111] [112] [113]





更新:
这是jQuery现在如何做到的(2.2稳定):[114]


isNumeric: function(obj) {
    var realStringObj = obj && obj.toString();
    return !jQuery.isArray(obj) && (realStringObj - parseFloat(realStringObj) + 1) >= 0;
}


更新:
Angular 4.3:[115]


export function isNumeric(value: any): boolean {
    return !isNaN(value - parseFloat(value));
}

其它参考1


Arrrgh!不要听正则表达式的答案.RegEx对此很狡猾,我不是只说表演。用你的正则表达方式做出微妙的,不可能发现错误是如此容易。


如果你不能isNaN(),这应该会更好:


function IsNumeric(input)
{
    return (input - 0) == input && (''+input).trim().length > 0;
}


这是它的工作原理:


(input - 0)表达式强制JavaScript对输入值进行类型强制;必须首先将其解释为减法运算的数字。如果转换为数字失败,表达式将导致NaN。然后将此数字结果与您传入的原始值进行比较。由于左侧现在是数字,因此再次使用类型强制。既然来自双方的输入都是从相同的原始值强制转换为相同的类型,那么您会认为它们应该始终相同(始终为真)。但是,有一个特殊的规则,即NaN永远不等于NaN,因此不能转换为数字的值(并且只能转换为数字的值)在假。


检查长度是针对涉及空字符串的特殊情况。另请注意,它会降低到您的0x89f测试,但这是因为在许多环境中定义数字文字的方法是正确的。如果要捕获该特定方案,可以添加其他检查。更好的是,如果这是你不使用isNaN()的原因,那么只需将自己的函数包裹在isNaN()周围,这也可以进行额外的检查。


总之, 如果您想知道某个值是否可以转换为数字,请务必尝试将其转换为数字。





我回去做了一些研究为什么一个空格字符串没有预期的输出,我想我现在得到它:一个空字符串被强制0而不是NaN]]。只需在长度检查之前修剪字符串就可以处理这种情况。


运行单元测试新代码,它只在无穷大和布尔文字上失败,唯一应该是问题的是你生成代码(真的,谁会输入文字并检查它是否是数字?你应该知道),这将是一些奇怪的代码来生成。


但是,再次,使用它的唯一原因是,如果由于某种原因你必须避免使用isNaN()。

其它参考2


这种方式似乎运作良好:


function IsNumeric(input){
    var RE = /^-{0,1}\d*\.{0,1}\d+$/;
    return (RE.test(input));
}


并测试它:


// alert(TestIsNumeric());

function TestIsNumeric(){
    var results = ''
    results += (IsNumeric('-1')?"Pass":"Fail") + ": IsNumeric('-1') => true\n";
    results += (IsNumeric('-1.5')?"Pass":"Fail") + ": IsNumeric('-1.5') => true\n";
    results += (IsNumeric('0')?"Pass":"Fail") + ": IsNumeric('0') => true\n";
    results += (IsNumeric('0.42')?"Pass":"Fail") + ": IsNumeric('0.42') => true\n";
    results += (IsNumeric('.42')?"Pass":"Fail") + ": IsNumeric('.42') => true\n";
    results += (!IsNumeric('99,999')?"Pass":"Fail") + ": IsNumeric('99,999') => false\n";
    results += (!IsNumeric('0x89f')?"Pass":"Fail") + ": IsNumeric('0x89f') => false\n";
    results += (!IsNumeric('#abcdef')?"Pass":"Fail") + ": IsNumeric('#abcdef') => false\n";
    results += (!IsNumeric('1.2.3')?"Pass":"Fail") + ": IsNumeric('1.2.3') => false\n";
    results += (!IsNumeric('')?"Pass":"Fail") + ": IsNumeric('') => false\n";
    results += (!IsNumeric('blah')?"Pass":"Fail") + ": IsNumeric('blah') => false\n";

    return results;
}


我从http://www.codetoad.com/javascript/isnumeric.asp借用了这个正则表达式。说明:[116]


/^ match beginning of string
-{0,1} optional negative sign
\d* optional digits
\.{0,1} optional decimal point
\d+ at least one digit
$/ match end of string

其它参考3


雅虎UI使用此:[117]


isNumber: function(o) {
    return typeof o === 'number' && isFinite(o);
}

其它参考4


function IsNumeric(num) {
     return (num >=0 || num < 0);
}


这适用于0x23类型数字。

其它参考5


接受的答案没有通过你的测试#7,我想这是因为你改变了主意。所以这是对已接受答案的回应,我遇到了问题。


在某些项目中,我需要验证一些数据并尽可能确定它是一个可以在数学运算中使用的javascript数值。


jQuery和其他一些javascript库已经包含了这样一个函数,通常称为isNumeric。 stackoverflow上还有一篇文章被广泛接受为答案,与上述图书馆使用的一般例程相同。


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


首先,如果参数是长度为1的数组,则上面的代码将返回true,并且该单个元素是上述逻辑认为是数字的类型。在我看来,如果它是一个数组,那么它不是数字。


为了缓解这个问题,我添加了一个检查来从逻辑中对数组进行折扣


function isNumber(n) {
  return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n);
}


当然,您也可以使用Array.isArray,jquery $.isArray或原型Object.isArray而不是Object.prototype.toString.call(n) !== '[object Array]'


我的第二个问题是负十六进制整数文字字符串(-0xA - > -10)未计入数字。但是,正十六进制整数文字字符串(0xA - > 10)被视为数字。
我需要两个都是有效的数字。


然后我修改了逻辑以考虑到这一点。


function isNumber(n) {
  return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}


如果你担心每次调用函数时都会创建正则表达式,那么你可以在一个闭包中重写它,像这样的东西


var isNumber = (function () {
  var rx = /^-/;

  return function (n) {
      return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(rx, ''));
  };
}());


然后,我接受了CMSs +30测试用例,并在jsfiddle上克隆了测试,增加了我的额外测试用例和上述解决方案。[119] [120]


它可能无法取代广泛接受/使用过的答案,但如果这更像是您希望的isNumeric函数的结果,那么希望这会有所帮助。


编辑:正如Bergi所指出的,还有其他可能被视为数字的对象,白名单比黑名单更好。考虑到这一点,我会添加标准。


我希望我的isNumeric函数只考虑数字或字符串


考虑到这一点,最好使用它


function isNumber(n) {
  return (Object.prototype.toString.call(n) === '[object Number]' || Object.prototype.toString.call(n) === '[object String]') &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}


测试解决方案




var testHelper = function() {

  var testSuite = function() {
    test("Integer Literals", function() {
      ok(isNumber("-10"), "Negative integer string");
      ok(isNumber("0"), "Zero string");
      ok(isNumber("5"), "Positive integer string");
      ok(isNumber(-16), "Negative integer number");
      ok(isNumber(0), "Zero integer number");
      ok(isNumber(32), "Positive integer number");
      ok(isNumber("040"), "Octal integer literal string");
      ok(isNumber(0144), "Octal integer literal");
      ok(isNumber("-040"), "Negative Octal integer literal string");
      ok(isNumber(-0144), "Negative Octal integer literal");
      ok(isNumber("0xFF"), "Hexadecimal integer literal string");
      ok(isNumber(0xFFF), "Hexadecimal integer literal");
      ok(isNumber("-0xFF"), "Negative Hexadecimal integer literal string");
      ok(isNumber(-0xFFF), "Negative Hexadecimal integer literal");
    });

    test("Foating-Point Literals", function() {
      ok(isNumber("-1.6"), "Negative floating point string");
      ok(isNumber("4.536"), "Positive floating point string");
      ok(isNumber(-2.6), "Negative floating point number");
      ok(isNumber(3.1415), "Positive floating point number");
      ok(isNumber(8e5), "Exponential notation");
      ok(isNumber("123e-2"), "Exponential notation string");
    });

    test("Non-Numeric values", function() {
      equals(isNumber(""), false, "Empty string");
      equals(isNumber("        "), false, "Whitespace characters string");
      equals(isNumber("\t\t"), false, "Tab characters string");
      equals(isNumber("abcdefghijklm1234567890"), false, "Alphanumeric character string");
      equals(isNumber("xabcdefx"), false, "Non-numeric character string");
      equals(isNumber(true), false, "Boolean true literal");
      equals(isNumber(false), false, "Boolean false literal");
      equals(isNumber("bcfed5.2"), false, "Number with preceding non-numeric characters");
      equals(isNumber("7.2acdgs"), false, "Number with trailling non-numeric characters");
      equals(isNumber(undefined), false, "Undefined value");
      equals(isNumber(null), false, "Null value");
      equals(isNumber(NaN), false, "NaN value");
      equals(isNumber(Infinity), false, "Infinity primitive");
      equals(isNumber(Number.POSITIVE_INFINITY), false, "Positive Infinity");
      equals(isNumber(Number.NEGATIVE_INFINITY), false, "Negative Infinity");
      equals(isNumber(new Date(2009, 1, 1)), false, "Date object");
      equals(isNumber(new Object()), false, "Empty object");
      equals(isNumber(function() {}), false, "Instance of a function");
      equals(isNumber([]), false, "Empty Array");
      equals(isNumber(["-10"]), false, "Array Negative integer string");
      equals(isNumber(["0"]), false, "Array Zero string");
      equals(isNumber(["5"]), false, "Array Positive integer string");
      equals(isNumber([-16]), false, "Array Negative integer number");
      equals(isNumber([0]), false, "Array Zero integer number");
      equals(isNumber([32]), false, "Array Positive integer number");
      equals(isNumber(["040"]), false, "Array Octal integer literal string");
      equals(isNumber([0144]), false, "Array Octal integer literal");
      equals(isNumber(["-040"]), false, "Array Negative Octal integer literal string");
      equals(isNumber([-0144]), false, "Array Negative Octal integer literal");
      equals(isNumber(["0xFF"]), false, "Array Hexadecimal integer literal string");
      equals(isNumber([0xFFF]), false, "Array Hexadecimal integer literal");
      equals(isNumber(["-0xFF"]), false, "Array Negative Hexadecimal integer literal string");
      equals(isNumber([-0xFFF]), false, "Array Negative Hexadecimal integer literal");
      equals(isNumber([1, 2]), false, "Array with more than 1 Positive interger number");
      equals(isNumber([-1, -2]), false, "Array with more than 1 Negative interger number");
    });
  }

  var functionsToTest = [

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

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

    function(n) {
      return !isNaN((n));
    },

    function(n) {
      return !isNaN(parseFloat(n));
    },

    function(n) {
      return typeof(n) != "boolean" && !isNaN(n);
    },

    function(n) {
      return parseFloat(n) === Number(n);
    },

    function(n) {
      return parseInt(n) === Number(n);
    },

    function(n) {
      return !isNaN(Number(String(n)));
    },

    function(n) {
      return !isNaN(+('' + n));
    },

    function(n) {
      return (+n) == n;
    },

    function(n) {
      return n && /^-?\d+(\.\d+)?$/.test(n + '');
    },

    function(n) {
      return isFinite(Number(String(n)));
    },

    function(n) {
      return isFinite(String(n));
    },

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

    function(n) {
      return parseFloat(n) == n;
    },

    function(n) {
      return (n - 0) == n && n.length > 0;
    },

    function(n) {
      return typeof n === 'number' && isFinite(n);
    },

    function(n) {
      return !Array.isArray(n) && !isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
    }

  ];


  // Examines the functionsToTest array, extracts the return statement of each function
  // and fills the toTest select element.
  var fillToTestSelect = function() {
    for (var i = 0; i < functionsToTest.length; i++) {
      var f = functionsToTest[i].toString();
      var option = /[\s\S]*return ([\s\S]*);/.exec(f)[1];
      $("#toTest").append('<option value="' + i + '">' + (i + 1) + '. ' + option + '</option>');
    }
  }

  var performTest = function(functionNumber) {
    reset(); // Reset previous test
    $("#tests").html(""); //Clean test results
    isNumber = functionsToTest[functionNumber]; // Override the isNumber global function with the one to test
    testSuite(); // Run the test

    // Get test results
    var totalFail = 0;
    var totalPass = 0;
    $("b.fail").each(function() {
      totalFail += Number($(this).html());
    });
    $("b.pass").each(function() {
      totalPass += Number($(this).html());
    });
    $("#testresult").html(totalFail + " of " + (totalFail + totalPass) + " test failed.");

    $("#banner").attr("class", "").addClass(totalFail > 0 ? "fail" : "pass");
  }

  return {
    performTest: performTest,
    fillToTestSelect: fillToTestSelect,
    testSuite: testSuite
  };
}();


$(document).ready(function() {
  testHelper.fillToTestSelect();
  testHelper.performTest(0);

  $("#toTest").change(function() {
    testHelper.performTest($(this).children(":selected").val());
  });
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js" type="text/javascript"></script>
<script src="https://rawgit.com/Xotic750/testrunner-old/master/testrunner.js" type="text/javascript"></script>
<link href="https://rawgit.com/Xotic750/testrunner-old/master/testrunner.css" rel="stylesheet" type="text/css">
<h1>isNumber Test Cases</h1>

<h2 id="banner" class="pass"></h2>

<h2 id="userAgent">Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.95 Safari/537.11</h2>

<div id="currentFunction"></div>

<div id="selectFunction">
  <label for="toTest" style="font-weight:bold; font-size:Large;">Select function to test:</label>
  <select id="toTest" name="toTest">
  </select>
</div>

<div id="testCode"></div>

<ol id="tests">
  <li class="pass">
    <strong>Integer Literals <b style="color:black;">(0, 10, 10)</b></strong>

    <ol style="display: none;">
      <li class="pass">Negative integer string</li>

      <li class="pass">Zero string</li>

      <li class="pass">Positive integer string</li>

      <li class="pass">Negative integer number</li>

      <li class="pass">Zero integer number</li>

      <li class="pass">Positive integer number</li>

      <li class="pass">Octal integer literal string</li>

      <li class="pass">Octal integer literal</li>

      <li class="pass">Hexadecimal integer literal string</li>

      <li class="pass">Hexadecimal integer literal</li>
    </ol>
  </li>

  <li class="pass">
    <strong>Foating-Point Literals <b style="color:black;">(0, 6, 6)</b></strong>

    <ol style="display: none;">
      <li class="pass">Negative floating point string</li>

      <li class="pass">Positive floating point string</li>

      <li class="pass">Negative floating point number</li>

      <li class="pass">Positive floating point number</li>

      <li class="pass">Exponential notation</li>

      <li class="pass">Exponential notation string</li>
    </ol>
  </li>

  <li class="pass">
    <strong>Non-Numeric values <b style="color:black;">(0, 18, 18)</b></strong>

    <ol style="display: none;">
      <li class="pass">Empty string: false</li>

      <li class="pass">Whitespace characters string: false</li>

      <li class="pass">Tab characters string: false</li>

      <li class="pass">Alphanumeric character string: false</li>

      <li class="pass">Non-numeric character string: false</li>

      <li class="pass">Boolean true literal: false</li>

      <li class="pass">Boolean false literal: false</li>

      <li class="pass">Number with preceding non-numeric characters: false</li>

      <li class="pass">Number with trailling non-numeric characters: false</li>

      <li class="pass">Undefined value: false</li>

      <li class="pass">Null value: false</li>

      <li class="pass">NaN value: false</li>

      <li class="pass">Infinity primitive: false</li>

      <li class="pass">Positive Infinity: false</li>

      <li class="pass">Negative Infinity: false</li>

      <li class="pass">Date object: false</li>

      <li class="pass">Empty object: false</li>

      <li class="pass">Instance of a function: false</li>
    </ol>
  </li>
</ol>

<div id="main">
  This page contains tests for a set of isNumber functions. To see them, take a look at the source.
</div>

<div>
  <p class="result">Tests completed in 0 milliseconds.
    <br>0 tests of 0 failed.</p>
</div>



是的,内置isNaN(object)将比任何正则表达式解析快得多,因为它是内置和编译的,而不是动态解释。[122]


虽然结果与您正在寻找的内容有所不同(尝试一下):[123]


                                              // IS NUMERIC
document.write(!isNaN('-1') + "<br />");      // true
document.write(!isNaN('-1.5') + "<br />");    // true
document.write(!isNaN('0') + "<br />");       // true
document.write(!isNaN('0.42') + "<br />");    // true
document.write(!isNaN('.42') + "<br />");     // true
document.write(!isNaN('99,999') + "<br />");  // false
document.write(!isNaN('0x89f') + "<br />");   // true
document.write(!isNaN('#abcdef') + "<br />"); // false
document.write(!isNaN('1.2.3') + "<br />");   // false
document.write(!isNaN('') + "<br />");        // true
document.write(!isNaN('blah') + "<br />");    // false

其它参考6


从jQuery 1.7开始,你可以使用jQuery.isNumeric():[124]


$.isNumeric('-1');      // true
$.isNumeric('-1.5');    // true
$.isNumeric('0');       // true
$.isNumeric('0.42');    // true
$.isNumeric('.42');     // true
$.isNumeric('0x89f');   // true (valid hexa number)
$.isNumeric('99,999');  // false
$.isNumeric('#abcdef'); // false
$.isNumeric('1.2.3');   // false
$.isNumeric('');        // false
$.isNumeric('blah');    // false


请注意,与您所说的不同,0x89f是有效数字(hexa)

其它参考7


使用isNaN功能。我相信如果你测试!isNaN(yourstringhere)它适用于任何这些情况。

其它参考8


它可以在没有RegExp的情况下完成


function IsNumeric(data){
    return parseFloat(data)==data;
}

其它参考9


我意识到原始问题没有提到jQuery,但是如果你使用jQuery,你可以这样做:


$.isNumeric(val)


简单。


https://api.jquery.com/jQuery.isNumeric/(截至jQuery 1.7)[125]

其它参考10


如果我没有弄错,这应该匹配任何有效的JavaScript数值,不包括常数(InfinityNaN)和符号运算符+/-(因为它们是就我而言,实际上并不是数字的一部分,它们是独立的运营商):


我需要这个用于标记器,其中将数字发送到JavaScript进行评估并不是一个选项......它绝对不是最短的正则表达式,但我相信它能捕捉到JavaScript数字语法的所有细微之处。


/^(?:(?:(?:[1-9]\d*|\d)\.\d*|(?:[1-9]\d*|\d)?\.\d+|(?:[1-9]\d*|\d)) 
(?:[e]\d+)?|0[0-7]+|0x[0-9a-f]+)$/i


有效数字包括:


 - 0
 - 00
 - 01
 - 10
 - 0e1
 - 0e01
 - .0
 - 0.
 - .0e1
 - 0.e1
 - 0.e00
 - 0xf
 - 0Xf


无效的数字


 - 00e1
 - 01e1
 - 00.0
 - 00x0
 - .
 - .e0

其它参考11


return (input - 0) == input && input.length > 0;


对我不起作用。当我发出警报并进行测试时,input.lengthundefined。我认为没有属性来检查整数长度。所以我做的是


var temp = '' + input;
return (input - 0) == input && temp.length > 0;


它工作正常。

其它参考12


对我来说,这是最好的方法:


isNumber : function(v){
   return typeof v === 'number' && isFinite(v);
}

其它参考13


整数值可以通过以下方式验证:


function isNumeric(value) {
    var bool = isNaN(+value));
    bool = bool || (value.indexOf('.') != -1);
    bool = bool || (value.indexOf(",") != -1);
    return !bool;
};


这种方式更容易,更快!检查所有测试!

其它参考14


这是一个很小的改进版本(可能是最快的方式)我使用而不是精确的jQuery变种,我真的不知道为什么他们不使用这个:


function isNumeric(val) {
    return !isNaN(+val) && isFinite(val);
}


jQuery版本的缺点是,如果你传递带有前导数字的字符串和"123abc"之类的尾随字母,parseFloat | parseInt将提取数字分数并返回123,但是,第二个后卫isFinite无论如何都会失败。
使用一元+运算符,它将死于第一个守卫,因为+为这样的混合动力投掷NaN :)
有点表现,但我认为有一个可靠的语义增益。

其它参考15


我对@CMS的答案唯一的问题是NaN和Infinity的排除,这对于很多情况都是有用的数字。检查NaN的一种方法是检查数字值等于自己,NaN != NaN!所以你真的想要处理3个测试...


function isNumber(n) {
  n = parseFloat(n);
  return !isNaN(n) || n != n;
}
function isFiniteNumber(n) {
  n = parseFloat(n);
  return !isNaN(n) && isFinite(n);
}    
function isComparableNumber(n) {
  n = parseFloat(n);
  return (n >=0 || n < 0);
}

isFiniteNumber('NaN')
false
isFiniteNumber('OxFF')
true
isNumber('NaN')
true
isNumber(1/0-1/0)
true
isComparableNumber('NaN')
false
isComparableNumber('Infinity')
true


我的isComparableNumber非常接近另一个优雅的答案,但处理数字的十六进制和其他字符串表示。

其它参考16


要添加的几个测试:


IsNumeric('01.05') => false
IsNumeric('1.') => false
IsNumeric('.') => false


我想出了这个:


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


解决方案包括:



  • 开头的可选负号

  • 单个零,或一个或多个不以0开头的数字,或只要一个句点跟随

  • 一个后跟一个或多个数字的句号


其它参考17


我的解决方案


function isNumeric(input) {
    var number = /^\-{0,1}(?:[0-9]+){0,1}(?:\.[0-9]+){0,1}$/i;
    var regex = RegExp(number);
    return regex.test(input) && input.length>0;
}


它似乎适用于所有情况,但我可能错了。

其它参考18


这应该工作。这里提供的一些功能是有缺陷的,也应该比这里的任何其他功能更快。


        function isNumeric(n)
        {
            var n2 = n;
            n = parseFloat(n);
            return (n!='NaN' && n2==n);
        }


解释:


创建自身的副本,然后将数字转换为float,然后将其自身与原始数字进行比较,如果它仍然是数字(无论是整数还是浮点数),并且与原始数字匹配,这意味着它确实是一个数字。


它适用于数字字符串和普通数字。不适用于十六进制数字。


警告:使用风险自负,不保证。

其它参考19


我想添加以下内容:


1. IsNumeric('0x89f') => true
2. IsNumeric('075') => true


正十六进制数以0x开头,负十六进制数以-0x开头。
正oct数以0开头,负oct数以-0开头。
这个考虑了已经提到的大部分内容,但包括十六进制和八进制数,负科学,无穷大并删除了十进制科学(4e3.2无效)。


function IsNumeric(input){
  var RE = /^-?(0|INF|(0[1-7][0-7]*)|(0x[0-9a-fA-F]+)|((0|[1-9][0-9]*|(?=[\.,]))([\.,][0-9]+)?([eE]-?\d+)?))$/;
  return (RE.test(input));
}

其它参考20


我使用更简单的解决方案:


function isNumber(num) {
    return parseFloat(num).toString() == num
}

其它参考21


对于空字符串,没有任何答案返回false,修复了...


function is_numeric(n)
{
 return (n != '' && !isNaN(parseFloat(n)) && isFinite(n));
}

其它参考22


@CMS回答:你的代码片段在我的机器上使用nodejs的空白情况下失败了。所以我把它结合起来
@joel对以下内容的回答:


is_float = function(v) {
    return !isNaN(v) && isFinite(v) &&
        (typeof(v) == 'number' || v.replace(/^\s+|\s+$/g, '').length > 0);
}


我将它与那些浮动的案例进行了单独测试:


var t = [
        0,
        1.2123,
        '0',
        '2123.4',
        -1,
        '-1',
        -123.423,
        '-123.432',
        07,
        0xad,
        '07',
        '0xad'
    ];


和那些没有浮点数的情况(包括空白空间和对象/数组):


    var t = [
        'hallo',
        [],
        {},
        'jklsd0',
        '',
        "\t",
        "\n",
        ' '
    ];


一切都按预期工作。也许这有帮助。


完整的源代码可以在这里找到。[130]

其它参考23


以下似乎适用于许多情况:


function isNumeric(num) {
    return (num > 0 || num === 0 || num === '0' || num < 0) && num !== true && isFinite(num);
}


这是建立在这个答案的基础上(也是这个答案):
https://stackoverflow.com/a/1561597/1985601

其它参考24


我意识到这已被多次回答,但以下是一个不错的候选人,在某些情况下可能会有用。


应该注意的是,它假设.42不是数字,而4不是数字,所以应该考虑到这一点。


function isDecimal(x) {
  return '' + x === '' + +x;
}

function isInteger(x) {
  return '' + x === '' + parseInt(x);
}


isDecimal通过以下测试:


function testIsNumber(f) {
  return f('-1') && f('-1.5') && f('0') && f('0.42')
    && !f('.42') && !f('99,999') && !f('0x89f')
    && !f('#abcdef') && !f('1.2.3') && !f('') && !f('blah');
}


这里的想法是每个数字或整数都有一个规范字符串表示,并且每个非规范表示都应该被拒绝。所以我们转换为数字并返回,并查看结果是否是原始字符串。


这些功能是否对您有用取决于用例。一个特征是不同的字符串代表不同的数字(如果两者都通过isNumber()测试)。


这是相关的,例如数字作为对象属性名称。


var obj = {};
obj['4'] = 'canonical 4';
obj['04'] = 'alias of 4';
obj[4];  // prints 'canonical 4' to the console.

其它参考25


knockoutJs Inbuild库验证功能


通过扩展它,字段得到验证


1)号码


self.number = ko.observable(numberValue) .extend({number:true});


测试用例


numberValue = '0.0'    --> true
numberValue = '0'      --> true
numberValue = '25'     --> true
numberValue = '-1'     --> true
numberValue = '-3.5'   --> true
numberValue = '11.112' --> true
numberValue = '0x89f'  --> false
numberValue = ''       --> false
numberValue = 'sfsd'   --> false
numberValue = 'dg##$'  --> false


2)数字


self.number = ko.observable(numberValue) .extend({digit:true});


测试用例


numberValue = '0'      --> true
numberValue = '25'     --> true
numberValue = '0.0'    --> false
numberValue = '-1'     --> false
numberValue = '-3.5'   --> false
numberValue = '11.112' --> false
numberValue = '0x89f'  --> false
numberValue = ''       --> false
numberValue = 'sfsd'   --> false
numberValue = 'dg##$'  --> false


3)最小和最大


self.number = ko.observable(numberValue) .extend({min:5})。extend({max:10});


此字段仅接受5到10之间的值


测试用例


numberValue = '5'    --> true
numberValue = '6'    --> true
numberValue = '6.5'  --> true
numberValue = '9'    --> true
numberValue = '11'   --> false
numberValue = '0'    --> false
numberValue = ''    --> false

其它参考26


检查变量是否包含有效数字
只是一个看起来像数字的字符串,
可以使用Number.isFinite(value)


这是该语言的一部分
ES2015 [132]


例子:


Number.isFinite(Infinity)   // false
Number.isFinite(NaN)        // false
Number.isFinite(-Infinity)  // false

Number.isFinite(0)          // true
Number.isFinite(2e64)       // true

Number.isFinite('0')        // false
Number.isFinite(null)       // false

其它参考27


您可以通过很多方式最小化此功能,也可以使用自定义正则表达式为负值或自定义图表实现它:


$('.number').on('input',function(){
    var n=$(this).val().replace(/ /g,'').replace(/\D/g,'');
    if (!$.isNumeric(n))
        $(this).val(n.slice(0, -1))
    else
        $(this).val(n)
});

其它参考28


function inNumeric(n){
   return Number(n).toString() === n;
}


如果n为数字Number(n)将返回数值,toString()将其返回字符串。但如果n不是数字Number(n)将返回NaN所以它不会与原始n匹配