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

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

И проверить это:

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

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

Это также работает для чисел типа 0x23.

Yahoo! Пользовательский интерфейс использует это:

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

Принятый ответ не прошел ваш тест № 7, и я предполагаю, что вы изменили свое мнение. Так что это ответ на принятый ответ, с которым у меня были проблемы.

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

jQuery и некоторые другие библиотеки javascript уже включают такую функцию, обычно называемую isNumeric. Существует также https://stackoverflow.com/questions/18082/validate-decimal-numbers-in-javascript-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(/^-/, ''));
}

Если вы беспокоитесь о создании регулярного выражения при каждом вызове функции, вы можете переписать его в закрытии, что-то вроде этого

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, то, надеюсь, это поможет.

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

Хотя результаты несколько отличаются от того, что вы ищете (попробуйте):

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

Начиная с 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)

Используйте функцию isNaN. Я считаю, что если вы тестируете !isNaN(yourstringhere), он отлично работает для любой из этих ситуаций.

Это можно сделать без RegExp как

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

Я понимаю, что исходный вопрос не упоминал jQuery, но если вы используете jQuery, вы можете сделать:

$.isNumeric(val)

Просто.

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

Если я не ошибаюсь, это должно соответствовать любому действительному значению номера 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

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 и 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 довольно близок к другому элегантному ответу, но обрабатывает шестнадцатеричные и другие строковые представления чисел.

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

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

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

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

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

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

Мое решение,

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

Разъяснения:

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

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

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

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

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

Положительные шестнадцатеричные числа начинаются с 0x а отрицательные шестнадцатеричные числа начинаются с -0x. Положительные номера oct начинаются с 0 а отрицательные номера -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));
}

Пара тестов для добавления:

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

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

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

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

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

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

Ни один из ответов не возвращает false для пустых строк, исправление для этого...

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

Я использую более простое решение:

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

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

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

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

следует отметить, что он предполагает, что ".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.

Похоже, что во многих случаях работает нормально:

function isNumeric(num) {
    return (num > 0 || num === 0 || num === '0' || num < 0) && num !== true && isFinite(num);
}

Это построено поверх этого ответа (что тоже для этого ответа): https://stackoverflow.com/questions/18082/validate-decimal-numbers-in-javascript-isnumeric

ответ @CMS: ваш фрагмент не выполнен в случайных пробелах на моей машине с помощью nodejs. Поэтому я объединил его с @joel answer:

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

Все работает так, как ожидалось. Возможно, это помогает.

Полный исходный код для этого можно найти здесь.

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) min и max

self.number = ko.observable(numberValue) .extend({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

Простое и понятное решение, использующее динамическую проверку типов языка:

function IsNumeric (string) {
   //it has whitespace
   if(string === ' '.repeat(string.length)){
     return false
   }
   return (string -1) *1 === (string *1) -1
}

см тестовые случаи ниже

function IsNumeric (string) {
   if(string === ' '.repeat(string.length)){
     return false
   }
   return (string -1)*1 === (string*1)-1
}

console.log('-1' + ' → ' + IsNumeric('-1'))    
console.log('-1.5' + ' → ' + IsNumeric('-1.5')) 
console.log('0' + ' → ' + IsNumeric('0'))     
console.log('0.42' + ' → ' + IsNumeric('0.42'))   
console.log('.42' + ' → ' + IsNumeric('.42'))    
console.log('99,999' + ' → ' + IsNumeric('99,999'))
console.log('0x89f' + ' → ' + IsNumeric('0x89f'))  
console.log('#abcdef' + ' → ' + IsNumeric('#abcdef'))
console.log('1.2.3' + ' → ' + IsNumeric('1.2.3')) 
console.log('' + ' → ' + IsNumeric(''))    
console.log('blah' + ' → ' + IsNumeric('blah'))

Используйте isNaN() в сочетании с parseInt()

const isNumeric = v => !parseInt(v) || '') || !isNaN(v) || !isNaN(v);

typeof(n) === 'number' && isFinite(n)

Не нужно использовать дополнительную lib.

const IsNumeric = (...numbers) => {
  return numbers.reduce((pre, cur) => pre && !!(cur === 0 || +cur), true);
};

Тест

> IsNumeric(1)
true
> IsNumeric(1,2,3)
true
> IsNumeric(1,2,3,0)
true
> IsNumeric(1,2,3,0,'')
false
> IsNumeric(1,2,3,0,'2')
true
> IsNumeric(1,2,3,0,'200')
true
> IsNumeric(1,2,3,0,'-200')
true
> IsNumeric(1,2,3,0,'-200','.32')
true

Я думаю, что мой код идеален...

/**
 * @param {string} s
 * @return {boolean}
 */
var isNumber = function(s) {
    return s.trim()!=="" && !isNaN(Number(s));
};

Лучший способ сделать это:

function isThisActuallyANumber(data){
    return ( typeof data === "number" && !isNaN(data) );
}

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

Ничего особенного, но мы можем использовать конструктор Boolean

Если вам нужно проверить специальный набор десятичных знаков y вы можете использовать этот простой javascript:

http://codesheet.org/codesheet/x1kI7hAD

<input type="text" name="date" value="" pattern="[0-9]){1,2}(\.){1}([0-9]){2}" maxlength="6" placeholder="od npr.: 16.06" onchange="date(this);" />

Javascript:

function date(inputField) {        
  var isValid = /^([0-9]){1,2}(\.){1}([0-9]){2}$/.test(inputField.value);   
  if (isValid) {
    inputField.style.backgroundColor = '#bfa';
  } else {
    inputField.style.backgroundColor = '#fba';
  }
  return isValid;
}

Можно использовать библиотеку проверки типов, например https://github.com/arasatasaygin/is.js, или просто извлечь оттуда фрагмент проверки (https://github.com/arasatasaygin/is.js/blob/master/is.js#L131):

is.nan = function(value) {    // NaN is number :) 
  return value !== value;
};
 // is a given value number?
is.number = function(value) {
    return !is.nan(value) && Object.prototype.toString.call(value) === '[object Number]';
};

В общем случае, если вам необходимо проверить типы параметров (в точке входа вызова функции), вы можете пойти с контрактами, совместимыми с JSDOC (https://www.npmjs.com/package/bycontract):

/**
 * This is JSDOC syntax
 * @param {number|string} sum
 * @param {Object.<string, string>} payload
 * @param {function} cb
 */
function foo( sum, payload, cb ) {
  // Test if the contract is respected at entry point
  byContract( arguments, [ "number|string", "Object.<string, string>", "function" ] );
}
// Test it
foo( 100, { foo: "foo" }, function(){}); // ok
foo( 100, { foo: 100 }, function(){}); // exception

function isNumber(n) {
    return (n===n+''||n===n-0) && n*0==0 && /\S/.test(n);
}

Пояснения:

(n===n-0||n===n+'') проверяет, является ли n числом или строкой (отбрасывает массивы, boolean, date, null,...). Вы можете заменить (n===n-0||n===n+'') на n!==undefined && n!==null && (n.constructor===Number||n.constructor===String): значительно быстрее, но менее кратким.

n*0==0 проверяет, является ли n конечным числом как isFinite(n). Если вам нужно проверить строки, представляющие отрицательные шестнадцатеричные числа, просто замените n*0==0 на что-то вроде n.toString().replace(/^\s*-/,'')*0==0.
Это стоит немного, конечно, поэтому, если вам это не нужно, не используйте его.

/\S/.test(n) отбрасывает пустые строки или строки, которые содержат только белые пробелы (необходимо, так как isFinite(n) or n*0==0 возвращает a false положительный в этом случае). Вы можете уменьшить число вызовов до .test(n), используя (n!=0||/0/.test(n)) вместо /\S/.test(n), или вы можете использовать несколько более быстрый, но менее сжатый тест, например (n!=0||(n+'').indexOf('0')>=0): небольшое улучшение.

Я выполнил следующее ниже, и он передает все тестовые примеры...

Он использует другой способ, с помощью которого parseFloat и Number обрабатывают свои входы...

function IsNumeric(_in) {
    return (parseFloat(_in) === Number(_in) && Number(_in) !== NaN);
}

Я нашел простое решение, возможно, не лучше, но он отлично работает:)

Итак, что я делаю дальше, я разбираю строку в Int и проверяю, является ли длина длины новой переменной, которая теперь является типом int, такая же, как длина исходной строковой переменной. Логически, если размер одинаковый, это означает, что строка полностью анализируется на int, и это возможно только в том случае, если строка "сделана" только из чисел.

var val=1+$(e).val()+'';
var n=parseInt(val)+'';
if(val.length == n.length )alert('Is int');

Вы можете легко поместить этот код в функцию, а вместо предупреждения использовать return true, если int. Помните, что если вы используете точную точку или запятую в строке, вы проверяете ее по-прежнему false, потому что вы обрабатываете int.

Примечание: добавление 1+ на e.val, так что начальный ноль не будет удален.

function isNumeric(n) {
    var isNumber = true;

    $.each(n.replace(/ /g,'').toString(), function(i, v){
        if(v!=',' && v!='.' && v!='-'){
            if(isNaN(v)){
               isNumber = false;
               return false;
            }
         }
     });

    return isNumber;
}

isNumeric(-3,4567.89);   // true <br>

isNumeric(3,4567.89);   // true <br>

isNumeric("-3,4567.89");   // true <br>

isNumeric(3d,4567.89);   // false

Я использую этот способ, чтобы поцарапать, что varible является числовым:

v * 1 == v

Комментарий @Zoltan Lengyel 'other locales' (26 апреля в 2:14) в @CMS Dec answer (2 '09 в 5:36):

Я бы рекомендовал тестировать typeof (n) === 'string':

    function isNumber(n) {
        if (typeof (n) === 'string') {
            n = n.replace(/,/, ".");
        }
        return !isNaN(parseFloat(n)) && isFinite(n);
    }

Это расширяет рекомендацию Zoltans не только для проверки "локализованных чисел", как isNumber('12,50'), но также и "чистых" чисел, таких как isNumber(2011).

$('.rsval').bind('keypress', function(e){  
        var asciiCodeOfNumbers = [48,46, 49, 50, 51, 52, 53, 54, 54, 55, 56, 57];
        var keynum = (!window.event) ? e.which : e.keyCode; 
        var splitn = this.value.split("."); 
        var decimal = splitn.length;
        var precision = splitn[1]; 
        if(decimal == 2 && precision.length >= 2  ) { console.log(precision , 'e');   e.preventDefault(); } 
        if( keynum == 46 ){  
            if(decimal > 2) { e.preventDefault(); }  
        } 
        if ($.inArray(keynum, asciiCodeOfNumbers) == -1)
            e.preventDefault();    
  });

Ну, я использую этот, который я сделал...

Он работает до сих пор:

function checkNumber(value) {
    if ( value % 1 == 0 )
        return true;
    else
        return false;
}

Если вы заметили какие-либо проблемы с этим, скажите мне, пожалуйста.

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

Также могут работать следующие.

function isNumeric(v) {
         return v.length > 0 && !isNaN(v) && v.search(/[A-Z]|[#]/ig) == -1;
   };

Здесь я собрал "хорошие" с этой страницы и поместил их в простой тестовый шаблон, чтобы вы могли сами оценить.

Для новичков console.log - встроенная функция (доступна во всех современных браузерах), которая позволяет выводить результаты на консоль JavaScript (выкапывайте, вы найдете ее), а не выводить на свою HTML-страницу.

var isNumeric = function(val){
    // --------------------------
    // Recommended
    // --------------------------

    // jQuery - works rather well
    // See CMS unit test also: http://dl.getdropbox.com/u/35146/js/tests/isNumber.html
    return !isNaN(parseFloat(val)) && isFinite(val);

    // Aquatic - good and fast, fails the "0x89f" test, but that test is questionable.
    //return parseFloat(val)==val;

    // --------------------------
    // Other quirky options
    // --------------------------
    // Fails on "", null, newline, tab negative.
    //return !isNaN(val);

    // user532188 - fails on "0x89f"
    //var n2 = val;
    //val = parseFloat(val);
    //return (val!='NaN' && n2==val);

    // Rafael - fails on negative + decimal numbers, may be good for isInt()?
    // return ( val % 1 == 0 ) ? true : false;

    // pottedmeat - good, but fails on stringy numbers, which may be a good thing for some folks?
    //return /^-?(0|[1-9]\d*|(?=\.))(\.\d+)?$/.test(val);

    // Haren - passes all
    // borrowed from http://www.codetoad.com/javascript/isnumeric.asp
    //var RE = /^-{0,1}\d*\.{0,1}\d+$/;
    //return RE.test(val);

    // YUI - good for strict adherance to number type. Doesn't let stringy numbers through.
    //return typeof val === 'number' && isFinite(val);

    // user189277 - fails on "" and "\n"
    //return ( val >=0 || val < 0);
}

var tests = [0, 1, "0", 0x0, 0x000, "0000", "0x89f", 8e5, 0x23, -0, 0.0, "1.0", 1.0, -1.5, 0.42, '075', "01", '-01', "0.", ".0", "a", "a2", true, false, "#000", '1.2.3', '#abcdef', '', "", "\n", "\t", '-', null, undefined];

for (var i=0; i<tests.length; i++){
    console.log( "test " + i + ":    " + tests[i] + "    \t   " + isNumeric(tests[i]) );
}