48 题: 在JavaScript中验证十进制数 - IsNumeric()

在...创建的问题 Wed, Dec 7, 2016 12:00 AM

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

奖励积分:

  1. 净度。解决方案应该简洁明了。
  2. 跨平台。
  3. 醇>

    测试用例:

     
    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
    
        
2269
  1. 只是一个注释99,999是法国的有效数字,它与英国/美国格式的99.999相同,所以如果你正在读一个输入形式的字符串那么99,999可能是真的。
    2008-08-20 14:31:46Z
  2. 2009-11-23 18:05:06Z
  3. 十进制逗号是整个欧洲和俄罗斯(英国除外)的标准
    2011-02-16 14:29:25Z
  4. jQuery 1.7引入了jQuery.isNumeric实用程序函数: api.jquery.com/jQuery.isNumeric
    2011-11-16 20:04:53Z
  5. jQuery.isNumeric将失败OP的第七个测试用例(IsNumeric('0x89f') => *false*)。但是,我不确定我是否同意这个测试用例。
    2012-08-27 16:42:48Z
  6. 醇>
    30答案                              30 跨度>                         

    @ 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));
    }
    
        
    2836
    2018-06-01 15:21:11Z
    1. 这与我们使用十进制逗号的其他语言环境失败,但添加`n = n.replace(/,/,“。”);'在返回修复它之前。
      2011-04-26 02:14:28Z
    2. @ RobG,该行为是在从2e308 > Number.MAX_VALUE开始,2e308 == Infinity。如果您想要一个也为正负无穷大值返回true的函数,请检查函数否。 2 测试套件中。欢呼声。
      2011-06-24 18:30:34Z
    3. 顺便说一下, jQuery项目
      2012-01-31 19:13:56Z
    4. jQuery现在也使用这个实现。
      2012-12-01 11:33:20Z
    5. 这里的解决方案就是使用JQuery。他们现在有更好的实现: github.com/的jquery /jquery的/斑点/主/SRC /core.js#L230
      2013-10-06 04:44:48Z
    6. 醇>

    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()。

        
    325
    2015-01-28 20:47:01Z
    1. 甚至更好,如果你只需要考虑0x89f的特殊情况就是在isNaN()周围包装一个IsNumeric()函数,然后只在isNaN()时进行特殊检查返回false。
      2008-11-25 18:21:54Z
    2. 这在空白字符串上失败,例如IsNumeric(' '),IsNumeric('\n\t')等都返回true
      2009-12-02 04:36:06Z
    3. 它也将失败Number文字IsNumeric(5) == false;检查我发布的单元测试集,此功能是测试套件上的数字16 stackoverflow.com/questions/18082 /...
      2009-12-02 05:52:38Z
    4. 我不敢相信在没有使用正则表达式警告之后没有人指出使用正则表达式(替换)...当然,空格替换更简单除了数字解析之外,它仍然是“icky”。​​
      2013-06-20 14:41:58Z
    5. @Oriol这是一个大问题......在该日期之后没有发布任何安全修复程序,远离XP应该是一个优先事项。
      2013-10-20 04:38:12Z
    6. 醇>

    这种方式似乎运作良好:

     
    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
    
        
    61
    2008-08-20 14:22:56Z
    1. //还应该添加到你的测试结果+ =(!IsNumeric(' - ')?“Pass”:“Fail”)+“:IsNumeric(' - ')=> false \n“;结果+ =(!IsNumeric('01')?“Pass”:“Fail”)+“:IsNumeric('01')=> false \n”;结果+ =(!IsNumeric(' - 01')?“Pass”:“Fail”)+“:IsNumeric(' - 01')=> false \n”;结果+ =(!IsNumeric('000')?“Pass”:“Fail”)+“:IsNumeric('000')=> false \n”;
      2010-01-28 01:47:01Z
    2. 这是做什么的?/^ - {0,1} \d * \。{0,1} \d + $/
      2016-09-02 23:42:43Z
    3. 可以将“{0,1}”替换为“?”,这样你的正则表达式将如下所示:/^-?\d*\.?\d+ $/?
      2016-10-14 10:20:13Z
    4. 醇>

    Yahoo! UI 使用此:

     
    isNumber: function(o) {
        return typeof o === 'number' && isFinite(o);
    }
    
        
    48
    2013-04-02 00:39:05Z
    1. 这是更多地检查变量类型而不是数字的内容。使用new Number(1)创建的数字也会失败。
      2011-06-23 05:33:17Z
    2. 正如亚历克斯所说,这实际上并没有回答所提出的问题,因为如果o =“1001”,这将失败。
      2013-01-25 23:49:26Z
    3. 醇>
     
    function IsNumeric(num) {
         return (num >=0 || num < 0);
    }
    

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

        
    46
    2012-06-16 13:01:37Z
    1. IsNumeric(''),IsNumeric(' '),IsNumeric(true),IsNumeric(false),IsNumeric(null)返回true而不是false
      2013-09-07 16:29:15Z
    2. 2014-04-02 16:27:27Z
    3. 醇>

    接受的答案未通过您的测试#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, ''));
      };
    }());
    

    然后我带了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>
        
    43
    2018-01-05 12:56:31Z
    1. 这是我看来屏蔽最多的功能;最后一个。接受的答案可能占所有案例的99.99%,但这一案件可能有100%的a)案件,开销很小。
      2014-01-07 03:59:31Z
    2. 你忘记了“99,999”Foating-Point文字。这是欧洲所有英国的有效号码
      2016-01-28 14:59:08Z
    3. 它没有被遗忘,它不是我认为Javascript数字意义上的数字,OP也说IsNumeric('99,999') => false
      2016-01-28 18:50:47Z
    4. 醇>

    是的,内置的 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
    
        
    33
    2013-08-08 14:39:20Z

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

        
    16
    2016-02-10 16:19:51Z
    1. 注意:!isNaN(null)== true,因为Number(null)== 0
      2008-10-15 04:50:47Z
    2. if(!(x == null || isNaN(x)))alert(“isNumeric”); //但是这个解决方案接受0x40,所以它仍然不是操作系统想要的。
      2008-12-15 04:58:18Z
    3. 注意isNaN(“Infinity”)=== false,这可能也不是你想要的(但在现实生活中也不会发生)。
      2010-02-10 15:13:50Z
    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是有效数字(hexa)

        
    15
    2013-02-18 09:01:43Z
    1. OP需要有效的十进制号码,因此jQuery isNumeric 不合适。对于非常大的数字也是如此。
      2015-11-02 21:21:50Z
    2. 醇>

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

     
    function IsNumeric(data){
        return parseFloat(data)==data;
    }
    
        
    11
    2008-08-22 15:08:05Z
    1. 不应该===
      2009-11-23 18:04:06Z
    2. 如果我们使用==,即使对于以字符串形式呈现的数字,它也会返回true。因此,对于“==”,“42”将被视为有效数字,如果===
      ,则将被视为无效
      2009-11-25 18:38:44Z
    3. 这在“-0。”,“ - 0”,“。0”和“0”上返回true。
      2012-09-28 22:16:44Z
    4. 醇>

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

     
    $.isNumeric(val)
    

    简单。

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

        
    7
    2014-01-13 16:42:50Z

    如果我没弄错的话,这应该匹配任何有效的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
    
        
    6
    2016-02-10 16:14:12Z
     
    return (input - 0) == input && input.length > 0;
    

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

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

    工作正常。

        
    6
    2018-01-05 13:04:36Z

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

     
    isNumber : function(v){
       return typeof v === 'number' && isFinite(v);
    }
    
        
    5
    2010-05-28 11:30:26Z
    1. 不幸的是,这是一种严格的数字检查器,对于任何只包含数字字母的字符串都会失败,例如“0”等......
      2013-05-20 16:36:43Z
    2. 醇>

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

        
    5
    2018-01-05 13:03:22Z

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

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

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

        
    4
    2013-01-06 18:36:05Z

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

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

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

        
    4
    2013-05-20 16:48:18Z
    1. 注意一元'+'将在对象上调用valueOf() - 请参阅 jsfiddle 。此外,对于领先的空白也是如此,前导答案也是如此。
      2013-09-24 23:34:21Z
    2. 醇>

    我想添加以下内容:

     
    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));
    }
    
        
    4
    2018-01-05 13:02:03Z
    1. 它是否适用于空字符串?
      2014-07-25 14:19:08Z
    2. 醇>

    要添加几项测试:

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

    我想出了这个:

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

    解决方案包括:

    • 开头的可选负号
    • 单个零,或打开e或更多数字不以0开头,或只要一个句号跟随
    • 一个后跟一个或多个数字的句号
    3
    2011-05-25 09:25:24Z

    我的解决方案,

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

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

        
    3
    2011-05-25 09:35:22Z
    1. 如果您没有不必要地转义字符,那么正则表达式会更少混淆,?用于{0,1}\d用于[0-9]。还有+,然后用(?:){0,1}包装它,你也可以使用*并忘记(非)捕获组。
      2013-08-07 22:04:07Z
    2. 醇>

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

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

    说明:

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

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

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

        
    3
    2013-08-07 21:59:27Z
    1. 使用后果风险自负,不保证我不会使用作​​者不自信的代码;)
      2013-08-07 22:00:00Z
    2. @ Alex,至少对事情有自己的看法。不要一直批评。
      2014-01-28 08:35:19Z
    3. 醇>

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

     
    function is_numeric(n)
    {
     return (n != '' && !isNaN(parseFloat(n)) && isFinite(n));
    }
    
        
    3
    2016-02-10 16:13:18Z

    检查变量是否包含有效数字 只是一个看起来像数字的字符串,  可以使用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
    
        
    3
    2016-04-12 20:00:46Z
    1. 我猜很多人会引用这个问题来解析用户输入,通常是字符串。在这些情况下,这个答案会失败,正如您在示例中正确列出的那样,例如Number.isFinite('0') -> false
      2016-04-12 19:46:50Z
    2. 你是完全正确的。我试图让这个清晰明白。
      2016-04-12 20:01:44Z
    3. 醇>

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

     
    function isNumeric(n) {
    
        return parseFloat(n) == n;
    }
    
        
    3
    2018-10-01 09:21:48Z
    1. 是的,我也得出了这个结论。我也非常喜欢使用这种方法处理数组的方式;一个具有单个值的数组计为该值,但其他一切都失败了:IsNumeric([3]) == true; IsNumeric([]) == false; IsNumeric([3, 4]) == false;但我想这是一个品味问题!
      2016-08-31 11:47:41Z
    2. 醇>

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

     
    function isNumber(num) {
        return parseFloat(num).toString() == num
    }
    
        
    2
    2012-06-16 12:25:25Z
    1. 这对于任何有多余0的东西都会失败。例如:“10.0”
      2012-09-28 22:13:33Z
    2. 醇>

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

    应该注意的是,它假设'.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.
    
        
    2
    2015-07-15 00:17:22Z

    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
    
        
    2
    2016-02-10 16:17:14Z

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

     
    $('.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)
    });
    
        
    2
    2017-02-23 15:16:43Z
     
    function inNumeric(n){
       return Number(n).toString() === n;
    }
    

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

        
    2
    2017-12-18 21:28:25Z
    1. 虽然此代码段可以解决问题,但包括解释确实有助于提高帖子的质量。请记住,您将来会回答读者的问题,而这些人可能不知道您的代码建议的原因。还请尽量不要在代码中加上解释性注释,因为这会降低代码和解释的可读性!
      2016-08-11 01:11:44Z
    2. 醇>

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

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

    可以在此处找到完整源代码。

        
    1
    2017-05-23 12:34:53Z
来源放置 这里