这是一个简单的（已在Chrome，Firefox和IE中测试）：

Question

在JavaScript中验证十进制数字的最简洁，最有效的方法是什么？

奖励积分：

净度。解决方案应该简洁明了。
跨平台。

测试用例：

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

Answer 1

@Joel's answer非常接近，但在以下情况下会失败：

// 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 unit tests对众多功能实现，并分享通过我所有测试的那一个：

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

P.S。 isNaN＆amp;由于强制转换为数字，isFinite会产生令人困惑的行为。在ES6中，Number.isNaN＆amp; Number.isFinite会解决这些问题。使用它们时请记住这一点。

更新： Here's how jQuery does it now (2.2-stable)：

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

更新： Angular 4.3：

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

Answer 2

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（）。

Answer 3

这种方式似乎运作良好：

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借用了这个正则表达式。说明：

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

Answer 4

Yahoo! UI使用此：

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

Answer 5

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

这也适用于0x23类型的数字。

Answer 6

接受的答案未通过您的测试＃7，我想这是因为您改变主意。所以这是对已接受答案的回应，我遇到了问题。

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

jQuery和其他一些javascript库已经包含了这样一个函数，通常称为isNumeric。还有一个post on 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, ''));
  };
}());

然后我使用了CMS +30 test cases并克隆了testing on jsfiddle添加了我的额外测试用例和上述解决方案。

它可能无法取代广泛接受/使用过的答案，但如果您的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>

Answer 7

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

虽然结果与您要查找的内容有些不同（try it）：

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

Answer 8

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

Answer 9

从jQuery 1.7开始，您可以使用jQuery.isNumeric()：

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

Answer 10

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

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

Answer 11

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

$.isNumeric(val)

简单。

https://api.jquery.com/jQuery.isNumeric/（从jQuery 1.7开始）

Answer 12

如果我没弄错的话，这应该匹配任何有效的JavaScript数值，不包括常量（Infinity，NaN）和符号运算符+ / -（因为就我而言，它们实际上并不是数字的一部分，它们是独立的运算符）：

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

/^(?:(?:(?:[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

Answer 13

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

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

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

工作正常。

Answer 14

对我来说，这是最好的方式：

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

Answer 15

我在@ CMS的answer中遇到的问题是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非常接近另一个优雅的answer，但处理数字的十六进制和其他字符串表示。

Answer 16

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

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

这种方式更容易，更快捷！检查所有测试！

Answer 17

这是一个小小的改进版本（可能是最快的方式）我使用而不是精确的jQuery变体，我真的不知道他们为什么不使用这个：

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

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

Answer 18

我想添加以下内容：

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

Answer 19

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

这是该语言的一部分 ES2015

示例：

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

Answer 20

要添加几项测试：

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

我想出了这个：

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

解决方案包括：

开头的可选负号
单个零，或一个或多个不以0开头的数字，或只要一个句点跟随
一个后跟一个或多个数字的句号

Answer 21

对于空字符串，没有一个答案返回false，这是一个修复...

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

Answer 22

我的解决方案，

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

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

Answer 23

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

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

说明：

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

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

警告：使用风险自负，无保证。

Answer 24

我正在使用更简单的解决方案：

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

Answer 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）min和max

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

Answer 26

您可以通过多种方式最大限度地减少此功能，还可以使用自定义正则表达式为负值或自定义图表实现此功能：

$('.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)
});

Answer 27

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

如果n是数字Number(n)将返回数值，toString()会将其变回字符串。但是，如果n不是数字Number(n)，则会返回NaN，因此它与原始n不匹配

Answer 28

我认为parseFloat函数可以在这里完成所有工作。下面的函数通过了此页面上的所有测试，包括isNumeric(Infinity) == true：

function isNumeric(n) {

    return parseFloat(n) == n;
}

Answer 29

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

应该注意的是，它假设'.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.

Answer 30

我认为我的代码很完美......

＆＃13;

/**
 * @param {string} s
 * @return {boolean}
 */
var isNumber = function(s) {
    return s.trim()!=="" && !isNaN(Number(s));
};

＆＃13;

Answer 31

无需额外使用lib。

const IsNumeric = (...numbers) => {
  return numbers.reduce((pre, cur) => pre && !!(cur === 0 || +cur), true);
};

测试

> IsNumeric(1)
true
> IsNumeric(1,2,3)
true
> IsNumeric(1,2,3,0)
true
> IsNumeric(1,2,3,0,'')
false
> IsNumeric(1,2,3,0,'2')
true
> IsNumeric(1,2,3,0,'200')
true
> IsNumeric(1,2,3,0,'-200')
true
> IsNumeric(1,2,3,0,'-200','.32')
true

Answer 32

最好的方法就是这样：

function isThisActuallyANumber(data){
    return ( typeof data === "number" && !isNaN(data) );
}

Answer 33

利用语言的动态类型检查，这是一种简单干净的解决方案：

function IsNumeric (string) {
   if(string === ' '.repeat(string.length)){
     return false
   }
   return string - 0 === string * 1
}

如果您不关心空格，则可以删除“ if”

请参阅下面的测试用例

function IsNumeric (string) {
   if(string === ' '.repeat(string.length)){
      return false
   }
   return string - 0 === string * 1
}


console.log('-1' + ' → ' + IsNumeric('-1'))    
console.log('-1.5' + ' → ' + IsNumeric('-1.5')) 
console.log('0' + ' → ' + IsNumeric('0'))     
console.log('0.42' + ' → ' + IsNumeric('0.42'))   
console.log('.42' + ' → ' + IsNumeric('.42'))    
console.log('99,999' + ' → ' + IsNumeric('99,999'))
console.log('0x89f' + ' → ' + IsNumeric('0x89f'))  
console.log('#abcdef' + ' → ' + IsNumeric('#abcdef'))
console.log('1.2.3' + ' → ' + IsNumeric('1.2.3')) 
console.log('' + ' → ' + IsNumeric(''))    
console.log('33 ' + ' → ' + IsNumeric('33 '))

Answer 34

isNumeric=(el)=>{return Boolean(parseFloat(el)) && isFinite(el)}

没有什么不同，但我们可以使用布尔构造函数

Answer 35

@CMS' answer：您的代码使用nodejs在我的机器上的空白案例中失败了。所以我把它结合起来 @joel's answer以下内容：

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",
        ' '
    ];

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

可以找到here的完整源代码。

Answer 36

如果需要验证一组特殊的小数y 你可以使用这个简单的javascript：

http://codesheet.org/codesheet/x1kI7hAD

<input type="text" name="date" value="" pattern="[0-9]){1,2}(\.){1}([0-9]){2}" maxlength="6" placeholder="od npr.: 16.06" onchange="date(this);" />

Javascript：

function date(inputField) {        
  var isValid = /^([0-9]){1,2}(\.){1}([0-9]){2}$/.test(inputField.value);   
  if (isValid) {
    inputField.style.backgroundColor = '#bfa';
  } else {
    inputField.style.backgroundColor = '#fba';
  }
  return isValid;
}

Answer 37

可以使用https://github.com/arasatasaygin/is.js之类的类型检查库，或者只是从那里提取检查片段（https://github.com/arasatasaygin/is.js/blob/master/is.js#L131）：

is.nan = function(value) {    // NaN is number :) 
  return value !== value;
};
 // is a given value number?
is.number = function(value) {
    return !is.nan(value) && Object.prototype.toString.call(value) === '[object Number]';
};

通常，如果您需要它来验证参数类型（在函数调用的入口点），您可以使用符合JSDOC的合同（https://www.npmjs.com/package/bycontract）：

/**
 * This is JSDOC syntax
 * @param {number|string} sum
 * @param {Object.<string, string>} payload
 * @param {function} cb
 */
function foo( sum, payload, cb ) {
  // Test if the contract is respected at entry point
  byContract( arguments, [ "number|string", "Object.<string, string>", "function" ] );
}
// Test it
foo( 100, { foo: "foo" }, function(){}); // ok
foo( 100, { foo: 100 }, function(){}); // exception

Answer 38

function isNumber(n) {
    return (n===n+''||n===n-0) && n*0==0 && /\S/.test(n);
}

<强>说明：

(n===n-0||n===n+'')验证n是数字还是字符串（丢弃数组，布尔值，日期，空值，...）。您可以将(n===n-0||n===n+'')替换为n!==undefined && n!==null && (n.constructor===Number||n.constructor===String)：明显更快但更简洁。

n*0==0验证n是否为isFinite(n)的有限数。如果您需要检查代表负十六进制的字符串，只需将n*0==0替换为n.toString().replace(/^\s*-/,'')*0==0。
它的成本当然很低，所以如果你不需要它，就不要使用它。

/\S/.test(n)会丢弃空字符串或字符串，只包含空格（在此情况下isFinite(n) or n*0==0返回false肯定时必需）。您可以使用.test(n)代替(n!=0||/0/.test(n))来减少拨打/\S/.test(n)的次数，或者您可以使用稍快但不太简洁的测试，例如(n!=0||(n+'').indexOf('0')>=0)：微小的改进。

Answer 39

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

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

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

Answer 40

我在下面运行了以下内容，它通过了所有测试用例......

它利用parseFloat和Number处理其输入的不同方式......

function IsNumeric(_in) {
    return (parseFloat(_in) === Number(_in) && Number(_in) !== NaN);
}

Answer 41

我找到了简单的解决方案，可能不是最好的，但它的工作正常：）

所以，接下来，我将字符串解析为Int，并检查现在为int类型的新变量的长度是否与原始字符串变量的长度相同。逻辑上，如果大小相同，则意味着字符串被完全解析为int，并且只有在字符串为＆＃34; make＆＃34;只有数字。

var val=1+$(e).val()+'';
var n=parseInt(val)+'';
if(val.length == n.length )alert('Is int');

您可以轻松地将该代码放入函数中，而不是使用警报，如果是int，则返回true。请记住，如果您在字符串中使用点或逗号，那么您正在检查它仍然是错误的，因为您正在解析为int。

注意：在e.val上添加1+，因此不会删除0开始。

Answer 42

这是一个简单的（已在Chrome，Firefox和IE中测试）：

function isNumeric(x) {
  return parseFloat(x) == x;
}

测试问题案例：

console.log('trues');
console.log(isNumeric('-1'));
console.log(isNumeric('-1.5'));
console.log(isNumeric('0'));
console.log(isNumeric('0.42'));
console.log(isNumeric('.42'));

console.log('falses');
console.log(isNumeric('99,999'));
console.log(isNumeric('0x89f'));
console.log(isNumeric('#abcdef'));
console.log(isNumeric('1.2.3'));
console.log(isNumeric(''));
console.log(isNumeric('blah'));

更多测试用例：

console.log('trues');
console.log(isNumeric(0));
console.log(isNumeric(-1));
console.log(isNumeric(-500));
console.log(isNumeric(15000));
console.log(isNumeric(0.35));
console.log(isNumeric(-10.35));
console.log(isNumeric(2.534e25));
console.log(isNumeric('2.534e25'));
console.log(isNumeric('52334'));
console.log(isNumeric('-234'));
console.log(isNumeric(Infinity));
console.log(isNumeric(-Infinity));
console.log(isNumeric('Infinity'));
console.log(isNumeric('-Infinity'));

console.log('falses');
console.log(isNumeric(NaN));
console.log(isNumeric({}));
console.log(isNumeric([]));
console.log(isNumeric(''));
console.log(isNumeric('one'));
console.log(isNumeric(true));
console.log(isNumeric(false));
console.log(isNumeric());
console.log(isNumeric(undefined));
console.log(isNumeric(null));
console.log(isNumeric('-234aa'));

请注意，它会将无穷大视为数字。

Answer 43

我用这种方式检查变量是否为数字：

v * 1 == v

Answer 44

function isNumeric(n) {
    var isNumber = true;

    $.each(n.replace(/ /g,'').toString(), function(i, v){
        if(v!=',' && v!='.' && v!='-'){
            if(isNaN(v)){
               isNumber = false;
               return false;
            }
         }
     });

    return isNumber;
}

isNumeric(-3,4567.89);   // true <br>

isNumeric(3,4567.89);   // true <br>

isNumeric("-3,4567.89");   // true <br>

isNumeric(3d,4567.89);   // false

Answer 45

$('.rsval').bind('keypress', function(e){  
        var asciiCodeOfNumbers = [48,46, 49, 50, 51, 52, 53, 54, 54, 55, 56, 57];
        var keynum = (!window.event) ? e.which : e.keyCode; 
        var splitn = this.value.split("."); 
        var decimal = splitn.length;
        var precision = splitn[1]; 
        if(decimal == 2 && precision.length >= 2  ) { console.log(precision , 'e');   e.preventDefault(); } 
        if( keynum == 46 ){  
            if(decimal > 2) { e.preventDefault(); }  
        } 
        if ($.inArray(keynum, asciiCodeOfNumbers) == -1)
            e.preventDefault();    
  });

Answer 46

<@> @Zoltan Lengyel'其他地区'评论（4月26日2:14）@CMS Dec回答（2009年2月2日5:36）：

我建议测试typeof (n) === 'string'：

    function isNumber(n) {
        if (typeof (n) === 'string') {
            n = n.replace(/,/, ".");
        }
        return !isNaN(parseFloat(n)) && isFinite(n);
    }

这扩展了Zoltans的建议，不仅能够测试isNumber('12,50')之类的“本地化数字”，还能测试isNumber(2011)等“纯粹”数字。

Answer 47

好吧，我正在使用我制作的那个...

到目前为止一直在努力：

function checkNumber(value) {
    if ( value % 1 == 0 )
        return true;
    else
        return false;
}

如果您发现任何问题，请告诉我。

就像任何数字都可以被一个没有任何数字的数字整除一样，我想我可以使用该模块，如果你尝试将一个字符串分成一个数字，结果就不会那样。如此。

Answer 48

以下内容也可以。

function isNumeric(v) {
         return v.length > 0 && !isNaN(v) && v.search(/[A-Z]|[#]/ig) == -1;
   };

Answer 49

在这里，我从这个页面收集了“好的”并将它们放入一个简单的测试模式中，供您自己评估。

对于新手来说，console.log是一个内置函数（在所有现代浏览器中都可用），它允许您将结果输出到JavaScript控制台（挖掘，你会找到它），而不是输出到你的HTML页面。

var isNumeric = function(val){
    // --------------------------
    // Recommended
    // --------------------------

    // jQuery - works rather well
    // See CMS's unit test also: http://dl.getdropbox.com/u/35146/js/tests/isNumber.html
    return !isNaN(parseFloat(val)) && isFinite(val);

    // Aquatic - good and fast, fails the "0x89f" test, but that test is questionable.
    //return parseFloat(val)==val;

    // --------------------------
    // Other quirky options
    // --------------------------
    // Fails on "", null, newline, tab negative.
    //return !isNaN(val);

    // user532188 - fails on "0x89f"
    //var n2 = val;
    //val = parseFloat(val);
    //return (val!='NaN' && n2==val);

    // Rafael - fails on negative + decimal numbers, may be good for isInt()?
    // return ( val % 1 == 0 ) ? true : false;

    // pottedmeat - good, but fails on stringy numbers, which may be a good thing for some folks?
    //return /^-?(0|[1-9]\d*|(?=\.))(\.\d+)?$/.test(val);

    // Haren - passes all
    // borrowed from http://www.codetoad.com/javascript/isnumeric.asp
    //var RE = /^-{0,1}\d*\.{0,1}\d+$/;
    //return RE.test(val);

    // YUI - good for strict adherance to number type. Doesn't let stringy numbers through.
    //return typeof val === 'number' && isFinite(val);

    // user189277 - fails on "" and "\n"
    //return ( val >=0 || val < 0);
}

var tests = [0, 1, "0", 0x0, 0x000, "0000", "0x89f", 8e5, 0x23, -0, 0.0, "1.0", 1.0, -1.5, 0.42, '075', "01", '-01', "0.", ".0", "a", "a2", true, false, "#000", '1.2.3', '#abcdef', '', "", "\n", "\t", '-', null, undefined];

for (var i=0; i<tests.length; i++){
    console.log( "test " + i + ":    " + tests[i] + "    \t   " + isNumeric(tests[i]) );
}

在JavaScript中验证十进制数 - IsNumeric（）

49 个答案:

这是一个简单的（已在Chrome，Firefox和IE中测试）：