ตรวจสอบตัวเลขทศนิยมใน JavaScript - IsNumeric ()

วิธีที่สะอาดและมีประสิทธิภาพมากที่สุดในการตรวจสอบความถูกต้องของตัวเลขทศนิยมใน 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 หน่วยที่ทำเพื่อการใช้งานฟังก์ชั่นมากมายและยังแชร์การทดสอบที่ผ่านการทดสอบทั้งหมดของฉันด้วย:

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

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

วิธีนี้ดูเหมือนจะทำงานได้ดี:

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

ในหนึ่งบรรทัด:

const IsNumeric = (num) => /^-{0,1}\d*\.{0,1}\d+$/.test(num);

และเพื่อทดสอบ:

const IsNumeric = (num) => /^-{0,1}\d*\.{0,1}\d+$/.test(num);
    
    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;
    }

console.log(TestIsNumeric());

.as-console-wrapper { max-height: 100% !important; top: 0; }

ผมยืม regex ว่าจาก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

Yahoo! UIใช้สิ่งนี้:

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

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

ใช้งานได้กับหมายเลขประเภท 0x23 เช่นกัน

คำตอบที่ยอมรับนั้นล้มเหลวในการทดสอบ # 7 ของคุณและฉันเดาว่าเป็นเพราะคุณเปลี่ยนใจ ดังนั้นนี่คือคำตอบของคำตอบที่ยอมรับซึ่งฉันมีปัญหา

ในบางโครงการฉันจำเป็นต้องตรวจสอบความถูกต้องของข้อมูลและมั่นใจว่าเป็นค่าตัวเลขจาวาสคริปต์ที่สามารถใช้ในการดำเนินการทางคณิตศาสตร์ได้

jQuery และบางห้องสมุดจาวาสคริปต์อื่น ๆ isNumericอยู่แล้วรวมถึงฟังก์ชั่นดังกล่าวมักจะเรียกว่า นอกจากนี้ยังมีการโพสต์บน stackoverflowที่ได้รับการยอมรับอย่างกว้างขวางว่าเป็นคำตอบชุดคำสั่งทั่วไปเดียวกันกับที่ห้องสมุดดังกล่าวใช้

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

ขั้นแรกโค้ดด้านบนจะคืนค่าจริงถ้าอาร์กิวเมนต์เป็นอาร์เรย์ที่มีความยาว 1 และองค์ประกอบเดียวนั้นเป็นประเภทที่ถือว่าเป็นตัวเลขโดยตรรกะด้านบน ในความคิดของฉันถ้ามันเป็นอาร์เรย์ก็ไม่ได้เป็นตัวเลข

เพื่อลดปัญหานี้ฉันได้เพิ่มเช็คเพื่อลดอาร์เรย์จากตรรกะ

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

แน่นอนคุณสามารถใช้Array.isArrayjquery $.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(/^-/, ''));
}

หากคุณกังวลเกี่ยวกับการสร้าง regex ทุกครั้งที่มีการเรียกใช้ฟังก์ชันคุณสามารถเขียนใหม่ได้ภายในเวลาไม่กี่ครั้ง

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เพิ่มกรณีทดสอบพิเศษของฉันและวิธีการแก้ปัญหาที่อธิบายข้างต้นของฉัน

อาจไม่สามารถแทนที่คำตอบที่ได้รับการยอมรับ / ใช้กันอย่างแพร่หลาย แต่หากนี่เป็นสิ่งที่คุณคาดหวังว่าจะเป็นผลมาจากฟังก์ชั่น 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)จะเร็วกว่าการแยกวิเคราะห์ Regex ใด ๆ เนื่องจากมีการรวบรวมและเรียบเรียงในตัวแทนที่จะตีความได้ทันที

แม้ว่าผลลัพธ์จะค่อนข้างแตกต่างกับสิ่งที่คุณกำลังค้นหา ( ลองใช้ ):

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

isNaNใช้ฟังก์ชั่น ฉันเชื่อว่าถ้าคุณทดสอบ!isNaN(yourstringhere)ว่าใช้งานได้ดีกับสถานการณ์เหล่านี้

ตั้งแต่ 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)

มันสามารถทำได้โดยไม่ต้อง RegExp เป็น

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

ฉันรู้ว่าคำถามดั้งเดิมไม่ได้พูดถึง jQuery แต่ถ้าคุณใช้ jQuery คุณสามารถทำได้:

$.isNumeric(val)

ง่าย

https://api.jquery.com/jQuery.isNumeric/ (ตั้งแต่ jQuery 1.7)

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

ไม่ได้ผลสำหรับฉัน เมื่อฉันใส่ในการแจ้งเตือนและทดสอบเป็นinput.length undefinedฉันคิดว่าไม่มีคุณสมบัติในการตรวจสอบความยาวจำนวนเต็ม ดังนั้นสิ่งที่ฉันทำคือ

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

มันใช้งานได้ดี

หากฉันไม่เข้าใจผิดนี่ควรตรงกับค่าหมายเลข JavaScript ที่ถูกต้องใด ๆ ยกเว้นค่าคงที่ ( Infinity, NaN) และเครื่องหมายตัวดำเนินการ+/ -(เพราะพวกเขาไม่ได้เป็นส่วนหนึ่งของตัวเลขจริง ๆ เท่าที่ฉันเกี่ยวข้องพวกเขาเป็นตัวดำเนินการแยกต่างหาก):

ฉันต้องการสิ่งนี้สำหรับ tokenizer ซึ่งการส่งหมายเลขไปยัง 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

ปัญหาเดียวที่ฉันมีกับคำตอบของ @ CMS คือการยกเว้นNaNและไม่มีที่สิ้นสุดซึ่งเป็นตัวเลขที่มีประโยชน์สำหรับหลาย ๆ สถานการณ์ วิธีหนึ่งในการตรวจสอบ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 ของฉันค่อนข้างใกล้เคียงกับคำตอบที่สวยงามแต่จัดการกับเลขฐานสิบหกและตัวเลขอื่น ๆ

สำหรับฉันนี่เป็นวิธีที่ดีที่สุด:

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

ฉันต้องการเพิ่มสิ่งต่อไปนี้:

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

ตัวเลขฐานสิบหกบวกเริ่มต้นด้วยและตัวเลขฐานสิบหกเชิงลบเริ่มต้นด้วย0x -0xตัวเลขบวกตุลาคมเริ่มต้นด้วยและหมายเลขตุลาคมเชิงลบเริ่มต้นด้วย0 -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));
}

ฉันคิดว่าฟังก์ชั่น parseFloat สามารถทำงานได้ทั้งหมดที่นี่ ฟังก์ชั่นด้านล่างผ่านการทดสอบทั้งหมดในหน้านี้ ได้แก่isNumeric(Infinity) == true:

function isNumeric(n) {

    return parseFloat(n) == n;
}

การทดสอบสองสามข้อที่จะเพิ่ม:

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

ฉันมากับสิ่งนี้:

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

การแก้ปัญหาครอบคลุม:

• เครื่องหมายลบที่เป็นตัวเลือกที่จุดเริ่มต้น
• ศูนย์เดียวหรือหนึ่งหลักหรือมากกว่านั้นไม่ได้เริ่มต้นด้วย 0 หรือไม่มีอะไรตามระยะเวลาดังต่อไปนี้
• ช่วงเวลาที่ตามด้วยตัวเลข 1 ตัวหรือมากกว่า

ค่าจำนวนเต็มสามารถตรวจสอบได้โดย:

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

วิธีนี้ง่ายและเร็วขึ้น! การทดสอบทั้งหมดจะถูกตรวจสอบ!

นี่เป็นรุ่นปรับปรุง lil bit (อาจเป็นวิธีที่เร็วที่สุด) ที่ฉันใช้แทนตัวแปร jQuery ที่แน่นอนฉันไม่รู้จริงๆว่าทำไมพวกเขาถึงไม่ใช้อันนี้:

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

ข้อเสียของรุ่นของ jQuery คือว่าถ้าคุณผ่านสตริงกับผู้นำ numerics และลากตัวอักษรเหมือนจะแยกส่วนที่เป็นตัวเลขออกมาและกลับมา 123 แต่ยามที่สองจะล้มเหลวมันอยู่แล้ว ด้วยโอเปอเรเตอร์unary มันจะตายในยามแรกตั้งแต่ + ขว้าง NaN ให้กับลูกผสมดังกล่าว :) การแสดงเล็ก ๆ น้อย ๆ แต่ฉันคิดว่าได้รับความหมายที่แข็งแกร่ง"123abc"parseFloat | parseIntisFinite+

ทางออกของฉัน

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

ดูเหมือนจะทำงานได้ในทุกสถานการณ์ แต่ฉันอาจผิด

ฉันใช้โซลูชันที่ง่ายกว่า:

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

สิ่งนี้น่าจะใช้ได้ ฟังก์ชั่นบางอย่างที่มีให้ที่นี่มีข้อบกพร่องและควรเร็วกว่าฟังก์ชั่นอื่น ๆ ที่นี่

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

อธิบาย:

สร้างสำเนาของตัวเองจากนั้นแปลงตัวเลขให้เป็นทศนิยมจากนั้นเปรียบเทียบตัวเองกับหมายเลขเดิมหากยังคงเป็นตัวเลข (ไม่ว่าจะเป็นจำนวนเต็มหรือลอยตัว) และจับคู่กับตัวเลขดั้งเดิมนั่นหมายความว่าเป็นตัวเลขจริง ๆ

มันทำงานร่วมกับสตริงตัวเลขเช่นเดียวกับตัวเลขธรรมดา ไม่ทำงานกับตัวเลขฐานสิบหก

คำเตือน: ใช้ความเสี่ยงของคุณเองไม่มีการรับประกัน

ไม่มีคำตอบที่ส่งคืนfalseสำหรับสตริงว่างแก้ไขสำหรับ ...

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

เพื่อตรวจสอบว่าตัวแปรมีตัวเลขที่ถูกต้องหรือไม่และไม่ใช่เพียงแค่สตริงที่มีลักษณะเป็นตัวเลขหรือ 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

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

ถ้า n เป็นตัวเลขNumber(n)จะส่งคืนค่าตัวเลขและtoString()จะเปลี่ยนกลับเป็นสตริง แต่ถ้า n ไม่ใช่ตัวเลขNumber(n)จะกลับมาNaNดังนั้นมันจะไม่ตรงกับต้นฉบับn

ฉันรู้ว่าสิ่งนี้ได้รับการตอบแล้วหลายครั้ง แต่สิ่งต่อไปนี้คือผู้สมัครที่เหมาะสมซึ่งอาจมีประโยชน์ในบางสถานการณ์

ควรสังเกตว่าสมมติว่า '.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');
}

แนวคิดนี้คือทุกหมายเลขหรือจำนวนเต็มมีการแทนค่าสตริง "canonical" หนึ่งรายการและการแทนค่าที่ไม่ใช่แบบบัญญัติทั้งหมดควรถูกปฏิเสธ ดังนั้นเราจึงโยนไปที่ตัวเลขและย้อนกลับและดูว่าผลที่ได้คือสตริงเดิม

ฟังก์ชันเหล่านี้มีประโยชน์กับคุณหรือไม่ขึ้นอยู่กับกรณีการใช้งาน คุณลักษณะหนึ่งคือสตริงที่แตกต่างแทนตัวเลขที่แตกต่างกัน (ถ้าทั้งคู่ผ่านการisNumber()ทดสอบ)

สิ่งนี้เกี่ยวข้องเช่นตัวเลขเป็นชื่อคุณสมบัติวัตถุ

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

ฟังก์ชันการตรวจสอบความถูกต้องของไลบรารี knockoutJs Inbuild

เมื่อขยายฟิลด์จะได้รับการตรวจสอบความถูกต้อง

1) จำนวน

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

TestCase

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

TestCase

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 ({นาที: 5}). ขยาย ({สูงสุด: 10}) ;

ฟิลด์นี้ยอมรับค่าระหว่าง 5 ถึง 10 เท่านั้น

TestCase

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

หากคุณต้องการตรวจสอบชุดทศนิยมพิเศษ y คุณสามารถใช้จาวาสคริปต์ง่าย ๆ นี้:

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

จาวาสคริปต์:

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

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

ไม่มีอะไรแตกต่างกันมาก แต่เราสามารถใช้ตัวสร้างบูลีน