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

最新推荐文章于 2023-11-14 14:31:37 发布

p15097962069

最新推荐文章于 2023-11-14 14:31:37 发布

阅读量1.9k

点赞数

文章标签： javascript validation numbers

原文链接：https://ar.sofbug.com/question/4he

版权

这篇博客讨论了JavaScript中验证十进制数字的各种方法，包括使用正则表达式、内置函数如isNaN()和parseFloat()，以及jQuery和其他库中的函数。文章提供了多个测试用例和解决方案，探讨了不同方法的优缺点，强调简洁、跨平台的解决方案。

摘要由CSDN通过智能技术生成

在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

#1楼

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

我需要用它作为令牌生成器，在其中不能将数字发送到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

#2楼

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

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

#3楼

雅虎！ UI使用此：

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

#4楼

从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是有效数字（六）

#5楼

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

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

jQuery和其他一些JavaScript库已经包含了这样的函数，通常称为isNumeric 。关于堆栈溢出的文章也已被广泛接受为答案，与上述库所使用的一般例程相同。

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个测试用例，并在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>

#6楼

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

#7楼

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

这也适用于0x23类型编号。

#8楼

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

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

jQuery版本的缺点是，如果您传递带有前导数字和结尾字母（如"123abc"的字符串，则parseFloat | parseInt parseFloat | parseInt将提取数字分数并返回123，但是，第二个保护isFinite会失败。如果使用一元+运算符，它将在第一个警卫阵亡，因为+会对此类混合运算符抛出NaN ：)一点点的性能，但我认为这是可靠的语义收益。

#9楼

我对@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非常接近另一个优雅的答案，但可以处理十六进制和其他数字的字符串表示形式。

#10楼

啊！不要听正则表达式的答案。正则表达式对此很讨厌，我不只是在谈论性能。使用正则表达式可以轻松，轻松地发现错误非常容易。

如果您不能使用isNaN() ，这应该会更好：

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

运作方式如下：

(input - 0)表达式强制JavaScript对您的输入值进行强制类型转换；首先必须将其解释为减法运算的数字。如果该转换为数字失败，则表达式将得出NaN 。然后将此数字结果与您传入的原始值进行比较。由于左侧现在是数字，因此再次使用强制类型。现在，将来自双方的输入从相同的原始值强制转换为相同的类型，您将认为它们应该始终相同（始终为true）。但是，有一条特殊的规则说NaN永远不等于NaN ，因此不能转换为数字的值（只有不能转换为数字的值）将导致错误。

长度检查是针对涉及空字符串的特殊情况。另请注意，它取决于您的0x89f测试，但这是因为在许多环境中，这是定义数字文字的一种好方法。如果要赶上特定情况，可以添加其他检查。更好的是，如果这是您不使用isNaN()原因，那么只需将您自己的函数包装在isNaN()周围，该函数也可以执行其他检查。

总之， 如果您想知道一个值是否可以转换为数字，请实际尝试将其转换为数字。

我回过头去做了一些研究，研究为什么空白字符串没有预期的输出，我想我现在明白了：一个空字符串被强制为0而不是NaN 。只需在长度检查之前修剪字符串即可解决这种情况。

针对新代码运行单元测试，它仅在无穷和布尔文字上失败，并且唯一应该出现问题的时间是您是否正在生成代码（确实，谁会输入文字并检查其是否为数字？您应该知道），这将生成一些奇怪的代码。

但是，再次使用此方法的唯一原因是，由于某种原因必须避免使用isNaN（）。

#11楼

这种方式似乎很好用：

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

#12楼

要添加几个测试：

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

我想出了这个：

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

该解决方案涵盖：

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

#13楼

我想添加以下内容：

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

正十六进制数以0x ，负十六进制数以-0x 。八进制正数以0开头，八进制负数以-0开头。该代码考虑了大部分已提及的内容，但包括十六进制和八进制数字，负数科学4e3.2 ，无穷大并删除了十进制科学4e3.2 （ 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));
}

#14楼

@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单元测试 ，还应该分享通过我所有测试的测试：

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

由于强制转换为数字，因此PS isNaN和isFinite的行为令人困惑。在ES6中， Number.isNaN和Number.isFinite将解决这些问题。使用它们时请记住这一点。

更新：这是jQuery现在的方式（2.2稳定）：

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

#15楼

使用isNaN函数。我相信，如果您测试!isNaN(yourstringhere)则在任何情况下都可以正常工作。

#16楼

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

尽管结果与您要查找的内容有所不同（尝试）：

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

#17楼

我意识到原来的问题没有提到jQuery，但是如果您确实使用jQuery，则可以执行以下操作：

$.isNumeric(val)

简单。

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

#18楼

无需RegExp即可完成，因为

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

#19楼

我知道这个问题已经被回答了很多次，但是以下是一个不错的候选人，在某些情况下可能会有用。

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

#20楼

对于空字符串，所有答案都不会返回false ，对此的解决方法是...

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

#21楼

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

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

#22楼

如果您需要验证一组特殊的小数点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;
}

#23楼

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

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

#24楼

要检查变量是否包含有效数字，而不仅仅是一个看起来像数字的字符串，可以使用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

#25楼

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

function isNumeric(n) {

    return parseFloat(n) == n;
}

#26楼

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

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

#27楼

这应该工作。这里提供的某些功能有缺陷，也应该比这里的任何其他功能都快。

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

解释：

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

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

警告：使用后果自负，不做任何保证。

#28楼

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

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

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

工作正常。

#29楼

我的解决方案

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

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

#30楼

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

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

这样更容易，更快！所有测试均已检查！