검증 소수에서 자바스크립트 숫자()

https://stackoverflow.com/questions/18082

09-06-2019
|

문제

What's 는 가장 깨끗한,가장 효과적인 방법을 검증하는 소수의 숫자에서 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

해결책

@엘의 대답이 은 아주 가까이 있지만,그것은 실패에는 다음과 같은 경우:

// 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 을 포함하는 숫자 값(I 을 고려했다 또한 표기 지수,etc.), a Number 체,거의 아무것도 전달될 수 있는 기능도 못하고 어떤 형식 가정을 복용,치료의 유형을 강제(예. +true == 1; 지 true 로 간주되어서는 안됩 "numeric").

나는 생각은 가치 공유 이 설정의 +30 단위 테스트 로 만든 다양한 기능을 구현하고 또한 공유 중 하나를 통과하는 내 모든 테스트:

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

P.S. isNaN & isFinite 는 혼란스러운 동작으로 인해 강제로 전환하는 숫자입니다.에 ES6, 숫자입니다.isNaN & 숫자입니다.isFinite 을 해결할 것이라 이러한 문제를 해결합니다.을 유지할 때 마음에 그들을 사용하고 있습니다.

업데이트 : 여기에 어떻게 jQuery 그것은 이제(2.2-안정):

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

업데이트 : 모 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) 식 힘을 자바스크립트를 입력 강압에서 당신의 입력 값;그것이 첫째 숫자로 해석을 위한 빼기 작업입니다.는 경우는 변환하여 숫자가 실패하면 표현과 NaN.이 숫자 결과는 다음에 비해 원래 값을 전달됩니다.이후 왼쪽 지금은 숫자 입력 강압은 다시 사용됩니다.지금 하는 입력 양측에서였을 강요하는 동일한 유형에서 같은 원래 값으로,당신이 생각하는 것입니다 그들은 항상 같은 항상(진실).그러나,거기에 특별한 규칙을 말한다 NaN 은 결과를 만들기 위해보 NaN, 고,그래서 값을 수 없는 숫자로 변환(과 값만으로 변환할 수 없 숫자)결과 거짓입니다.

에 체크의 길이는 특별한 경우를 포함하 빈 문자열입니다.또한 그것을 아래로 떨어지에 0x89f 테스트,하지만 그것 때문에 많은 환경에서는 좋은 방법을 정의하는 번호로 문자적입니다.는 경우를 잡으려고 하는 특정 시나리오에 추가할 수 있습니다 추가 확인합니다.더 좋은 경우에는 이를 사용하지 않는 isNaN() 그냥 포장 자신의 기능을위 isNaN() 할 수 있는지 추가적인 확인합니다.

에 요약 를 알고 싶은 경우에는 경우 값을 변환할 수 있는 번호로 변환하려고하는 숫자입니다.

나는 돌아갔고 어떤 연구 유 공백 문자열이 있지 않은 예상 출력,그리고 나는 생각에 나는 지금 그것을 얻을:빈 문자열은 강요하 0 보 NaN.단순히 트리밍하기 전에 이 문자열의 길이를 확인이 처리합니다.

실행한 단위 테스트에 대한 새 코드고 그것만 실패에 대한 무한대 및 리터럴만 시간이어야 하는 문제를 생성하는 경우에는 코드는 정말(사람,것에서 형식 문자와 확인하면 그 숫자?야 알고),그리고 그것은 것 몇 가지 이상한 코드를 생성한다.

하지만,다시, 이를 사용하여 이 경우 어떤 이유는 당신이 피하기 위해 isNaN().

이 방법은 보이 잘 작동:

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

Yahoo!UI 이 사용:

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

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

이 작품에 대한 0x23 유형 숫자 뿐만 아니라.

허용에 대답하지 못했 테스트#7 및 그런 것이기 때문에 당신의 마음을 변경.그래서 이것은 응답을 받아들이 대답으로,나는 문제입니다.

중 일부 프로젝트가 필요한 유효성 검사 데이터로 가능한 것은 javascript 숫자 값에서 사용할 수 있는 수학적 작업입니다.

jQuery,그리고 다른 어떤 자바스크립트 라이브러리 이미 포함한 이러한 기능으로 불 isNumeric.도 게시물에서 유래 가 널리 받아들에 대한 답변으로,같은 일반적인 일과하는 벌 라이브러리를 사용하고 있습니다.

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

첫째,위의 코드를 반환하는 경우 true 인수되었는 배열의 길이 1,고는 하나의 요소의 유형으로 간주되는 숫자에 의하여 위의 논리입니다.내 생각에는 경우,그 배열은 다음 그것의 숫자입니다.

이 문제를 줄이기 위해서는 추가 확인하 할인 배열에서 논리

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(/^-/, ''));
}

에 대해 걱정하는 경우의 창조 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, ''));
  };
}());

그때 나 cms 에 +30 테스트 사례 와 복제 에 대한 테스트 jsfiddle 추가되는 내 여분의 테스트 사례와 내술 솔루션입니다.

그것을 대체 할 수 있으로 널리 사용에 대답하지만 이것이 무엇을 더 기대한 결과로서 귀하의 숫자는 기능 다음 희망이 될 것입니다 어떤 도움이됩니다.

편집: 으로 지적하여 Bergi, 있다,가능한 다른 개체로 간주될 수 있는 숫자와 더 나은 것을 허용 블랙리스트보다.이에 따라 추가하는 기준입니다.

나는 나의 숫자는 기능만을 고려한 숫자 또는 문자열

이 마음으로,그것은 더 나은 것을 사용하여

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) 것보다 훨씬 빨리 모든 정규 표현식 파싱하기 때문에,그것의 내장에서 컴파일하는 대신,해석됩니다.

지만 결과는 다소 차이가 당신이 찾고있는 것(도):

                                              // 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) 그것은 잘 작동을 위한 이러한 상황입니다.

이후 jQuery1.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/ (로 jQuery1.7)

내가 틀리지 않는 경우,이와 일치해야 합 모든 유효한 자바스크립트 번호 값을 제외하고,상수(Infinity, NaN 다)및 부호는 연산자 +/- (하지 않기 때문에 그들은 실제로 부분은 숫자로 지금까지 우려하고,그들은 별도의 운영):

내가 필요로 이에 대해 토,어디로 보내는 숫자 자바 스크립트를 위해 평가되지 않았...그것은 확실히지 않은 짧은 가능한 정규 표현식,그러나 나는 그것을 믿는 모든 미세한의 미묘한 자바 스크립트의 수문입니다.

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

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

작동 하지 않았습니다.을 넣을 때에는 경고하고,테스트 input.length 였 undefined.나는 생각은 없는 시설을 확인하는 정수 길이 있습니다.그래서 무엇을 했

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

에 있습니다.

나를 위해,이것은 가장 좋은 방법:

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

만 문제가 있었으로@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 은 아주 가까이 다른 호 응답, 하지만 손잡이 진수와 다른 문자열 표현의 숫자가 있습니다.

정수 값을 확인할 수 있습니다:

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

이 방법을 쉽고 빠르게!모든 테스트를 확인!

Here's a lil bit 버전을 향상(아마도 가장 빠른 방법이다)내가 사용하는 대신 정확한 jQuery 의 변형,정말 몰라 왜 그들이 하나를 사용:

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

의 단점 jQuery 의 버전이 있는 경우 문자열을 전달과 함께 주요 수치와 끄는 편지 "123abc" 이 parseFloat | parseInt 추출합니다 숫자 부분을 반환 123 지만,두 번째가드 isFinite 실패할 것입니다.으로 단항 + 운전자 죽을 것이다 첫번째에 가드부터+발생 할머니는 그러한 하이브리드:) 조금 성능은 아직 생각하는 단단한 의미 얻을 수 있다.

내가 좋아하는 다음을 추가합니다:

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

의 몇 가지 테스트를 추가합니다:

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

나이:

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

의 솔루션:

선택적인정 시작 부분에서
단일,또는 하나 이상의 자리하지 않을 시작으로 0,또는 아무것도 그렇게 오랜 기간으로 다음과 같이
기간 뒤에는 1 또는 그 이상의 숫자

나의 솔루션,

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 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 isNumber(num) {
    return parseFloat(num).toString() == num
}

내가 이것을 실현가 응답되었습니다 많은 시간을,그 다음은 괜찮은 후보에 유용할 수 있는 몇 가지 시나리오.

는 것을 주목해야한다고 가정하는'.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.

knockoutJs Inbuild 라이브러리 유효성 검사 기능

을 확장하여 그 분야를 얻을 검증

1)번호

self.number = ko.observable(numberValue).장({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).장({숫자: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).장({min:5}).장({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

을 최소화할 수 있습니다 이 함수에 많은 방법,그리고 구현할 수도 있습니다 그것은 사용자 지정 regex 에 대한 부정적인 값 또는 사용자 정의 차트:

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

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

N 경우이 숫자 Number(n) 이 반환됩니다 숫자 값과 toString() 이 그것을 다시 설정하는 문자열을 사용합니다.하지만 만약 n 지 않다 숫자 Number(n) 환 NaN 지 않습니다 그래서 원본 n

내 생각에서는 parsefloat 기능이 모든 작업을 수행 할 수 있습니다 여기에.아래의 기능이 모든 테스트를 통과 이 페이지에 포함 isNumeric(Infinity) == true:

function isNumeric(n) {

    return parseFloat(n) == n;
}

@CMS'응답:귀하의 조각은 실패에 공백을 경우에는 내 컴퓨터 사용 및 라이브러리.그래서 나는 결과 @엘의 대답이 을 다음과 같다:

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

I unittested 로 이러한 경우는 뜨:

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

고 이러한 경우는 없이 뜹니다(를 포함하여 빈 공백 및 개/배):

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

모든 것이 예상대로 작동합니다 여기에.어쩌면 이것은 도움이됩니다.

전체 소스 코드를 이 찾을 수 있습니다 기.

라이센스 : CC-BY-SA ~와 함께 속성

제휴하지 않습니다 StackOverflow