Проверка десятичных чисел в JavaScript - IsNumeric()

@Joel's ответ довольно близок, но он потерпит неудачу в следующих случаях:

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

P.S. isNaN & isFinite имеют сбивающее с толку поведение из-за принудительного преобразования в число. В ES6 Number.isNaN & Number.isFinite исправит эти проблемы. Имейте это в виду, когда используете их.

Обновление : Вот как jQuery делает это сейчас (2.2-stable) :

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

Обновление : Angular 4.3 :

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

Аррр! Не слушайте ответы регулярного выражения. RegEx-это мерзко для этого, и я говорю не только о производительности. Это так легко сделать тонкие, невозможно обнаружить ошибки с вашим регулярным выражением лица.

Если вы не можете использовать isNaN() , это должно работать намного лучше:

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

Вот как это работает:

Выражение (input - 0) вынуждает JavaScript выполнять приведение типа к вашему входному значению; сначала оно должно быть интерпретировано как число для операции вычитания. Если это преобразование в число завершится неудачей, выражение приведет к NaN . Этот числовой результат затем сравнивается с исходным значением, которое вы передали. Поскольку левая сторона теперь числовая, снова используется принуждение типа. Теперь, когда входные данные с обеих сторон были принудительно приведены к одному и тому же типу из одного и того же исходного значения, можно было бы подумать, что они всегда должны быть одинаковыми (всегда истинными). Однако есть специальное правило, которое гласит, что NaN никогда не равно NaN, и поэтому значение, которое не может быть преобразовано в число (и только значения, которые не могут быть преобразованы в числа), приведет к ложному результату.

Проверка длины производится для особого случая, включающего пустые строки. Также обратите внимание, что он падает на ваш тест 0x89f, но это потому, что во многих средах это хороший способ определить числовой литерал. Если вы хотите поймать этот конкретный сценарий, вы можете добавить дополнительную проверку. Еще лучше, если это ваша причина не использовать isNaN() , тогда просто оберните свою собственную функцию вокруг isNaN() , которая также может выполнить дополнительную проверку.

Таким образом, если вы хотите узнать, можно ли преобразовать значение в число, на самом деле попробуйте преобразовать его в число.

Я вернулся назад и провел некоторое исследование, почему строка whitespace не имеет ожидаемого результата, и я думаю, что теперь я его получаю: пустая строка принуждается к 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;
}

Я позаимствовал этот 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, и я думаю, что это потому, что вы передумали. Так что это ответ на принятый ответ, с которым у меня были проблемы.

Во время некоторых проектов мне нужно было проверить некоторые данные и быть как можно более уверенным, что это числовое значение javascript, которое может быть использовано в математических операциях.

jQuery, и некоторые другие библиотеки javascript уже включают такую функцию, обычно называемую isNumeric . Существует также сообщение о stackoverflow , которое было широко принято в качестве ответа, та же самая общая процедура, которую используют вышеупомянутые библиотеки.

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

Затем я взял CMSs +30 тестовых случаев и клонировал тестирование на jsfiddle, добавив свои дополнительные тестовые случаи и мое вышеописанное решение.

Он не может заменить широко принятый / используемый ответ, но если это больше того, что вы ожидаете в результате своей функции isNumeric, то, надеюсь, это будет иметь некоторую помощь.

EDIT: как указал Берги, есть и другие возможные объекты, которые можно считать числовыми, и лучше было бы внести их в белый список, чем в черный. Имея это в виду, я бы добавил к критериям.

Я хочу, чтобы моя функция 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 ) и операторы знака + / - (поскольку они на самом деле не являются частью числа, насколько я знаю, они являются отдельными операторами):

Мне это было нужно для токенизатора, где отправка номера в 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

Для меня это самый лучший способ:

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

Единственная проблема, которая у меня была с @CMS's ответом , - это исключение NaN и Бесконечности, которые являются полезными числами для многих ситуаций. Один из способов проверить наличие NaN ' S-это проверить наличие числовых значений, которые не равны сами себе, 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 довольно близок к другому элегантному ответу, но обрабатывает hex и другие строковые представления чисел.

Целочисленное значение может быть проверено с помощью:

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

Этот путь проще и быстрее! Все тесты проверены!

Я хотел бы добавить следующее:

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

Положительные числа hex начинаются с 0x , а отрицательные числа hex-с -0x . Положительных чисел октября начнется с 0 и отрицательных чисел октября начнется с -0 . Этот метод учитывает большую часть того, что уже было упомянуто, но включает в себя hex и восьмеричные числа, отрицательные научные, бесконечность и удалил десятичные научные ( 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));
}

Вот немного улучшенная версия lil (вероятно, самый быстрый выход), которую я использую вместо точного варианта jQuery, я действительно не знаю, почему они не используют этот вариант:

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

Недостатком версии jQuery является то, что если вы передадите строку с ведущими цифрами и буквами trailing, такими как "123abc" , то parseFloat | parseInt извлечет числовую дробь и вернет 123, BUT, а второй охранник isFinite все равно ее не выполнит. С унарным оператором + он умрет на самом первом охраннике, так как + бросает NaN для таких гибридов :) Небольшое выступление, но я думаю, что это солидный семантический выигрыш.

Это должно сработать. Некоторые из функций, представленных здесь, имеют недостатки, а также должны быть быстрее, чем любая другая функция здесь.

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

Объясненный:

Создайте копию самого себя, затем преобразуйте число в float, затем сравните себя с исходным числом, если это все еще число (будь то целое число или float) , и соответствует исходному числу, то есть это действительно число.

Он работает как с числовыми строками, так и с простыми числами. Не работает с шестнадцатеричными числами.

Предупреждение: используйте на свой страх и риск, никаких гарантий.

Мое решение,

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

Похоже, это работает в любой ситуации, но я могу ошибаться.

Несколько тестов, чтобы добавить:

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

Я придумал вот это:

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

Решение охватывает:

• Необязательный отрицательный знак в начале
• Один ноль, или одна или несколько цифр, не начинающихся с 0, или ничего, пока следует точка
• Период, за которым следует 1 или более чисел

Ни один из ответов не возвращает 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
}

knockoutJs встроенные функции проверки библиотеки

Расширяя его поле получают валидацию

1) число

self.number = ko.observable(numberValue) .extend({ число: 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({ цифра: 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) .удлинить ({min: 5}).extend ({ max: 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