allow - javascript keycode only number




Validar números decimais em JavaScript-IsNumeric() (20)

Qual é a maneira mais eficiente e eficaz de validar números decimais em JavaScript?

Pontos de bônus para:

  1. Clareza. A solução deve ser limpa e simples.
  2. Plataforma cruzada.

Casos de teste:

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

A resposta aceita falhou no seu teste # 7 e eu acho que é porque você mudou de idéia. Então, esta é uma resposta à resposta aceita, com a qual eu tive problemas.

Durante alguns projetos eu precisei validar alguns dados e ter o máximo possível de que é um valor numérico de javascript que pode ser usado em operações matemáticas.

jQuery, e algumas outras bibliotecas javascript já incluem essa função, geralmente chamada isNumeric . Há também uma postagem em que foi amplamente aceita como a resposta, a mesma rotina geral que as bibliotecas mencionadas anteriormente estão usando.

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

Primeiro, o código acima retornaria true se o argumento fosse uma matriz de comprimento 1 e esse elemento único fosse de um tipo considerado numérico pela lógica acima. Na minha opinião, se é um array, então não é numérico.

Para aliviar este problema, adicionei um cheque para descontar arrays da lógica

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

Naturalmente, você também pode usar Array.isArray , jquery $.isArray ou protótipo Object.isArray vez de Object.prototype.toString.call(n) !== '[object Array]'

Meu segundo problema foi que as sequências literais inteiras hexadecimais negativas ("-0xA" -> -10) não estavam sendo contadas como numéricas. No entanto, cadeias literais inteiras hexadecimais positivas ("0xA" -> 10) foram tratadas como numéricas. Eu precisava de ambos para ser numérico válido.

Então modifiquei a lógica para levar isso em conta.

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

Se você está preocupado com a criação da regex cada vez que a função é chamada, então você pode reescrevê-la dentro de um fechamento, algo como isto

var isNumber = (function () {
  var rx = /^-/;

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

Em seguida, tomei CMSs +30 casos de teste e clonei o teste em jsfiddle, adicionei meus casos de teste extras e minha solução descrita acima.

Pode não substituir a resposta amplamente aceita / usada, mas se isto é mais do que você espera como resultados da sua função numérica, então, espero que isso seja de alguma ajuda.

EDIT: Como apontado por Bergi , existem outros objetos possíveis que poderiam ser considerados numéricos e seria melhor whitelist do que lista negra. Com isso em mente, gostaria de acrescentar aos critérios.

Eu quero minha função numérica para considerar apenas números ou seqüências de caracteres

Com isso em mente, seria melhor usar

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

Teste as soluções

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>


Aqui está uma versão melhorada lil (provavelmente a maneira mais rápida que existe) que eu uso em vez da variante exata do jQuery, eu realmente não sei porque eles não usam este:

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

A desvantagem da versão do jQuery é que, se você passar uma string com os principais números e letras finais, como "123abc" o parseFloat | parseInt parseFloat | parseInt extrairá a fração numérica e retornará 123, MAS, o segundo guarda isFinite falhará de qualquer forma.Com o +operador unário , ele morrerá no primeiro guarda, já que + lança NaN para tais híbridos :) Um pouco de desempenho, porém, acho que um sólido ganho semântico.


Desde o jQuery 1.7, você pode usar api.jquery.com/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

Apenas note que, ao contrário do que você disse, 0x89f é um número válido (hexa)


Desta forma parece funcionar bem:

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

E para testá-lo:

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

Eu pedi emprestado esse regex de http://www.codetoad.com/javascript/isnumeric.asp . Explicação:

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

Isso pode ser feito sem o RegExp como

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

Para mim, esta é a melhor maneira:

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

Sim, o built-in isNaN(object) será muito mais rápido do que qualquer análise de regex, porque é embutido e compilado, em vez de interpretado na hora.

Embora os resultados sejam um pouco diferentes do que você está procurando ( experimente ):

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

Um valor inteiro pode ser verificado por:

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

Desta forma é mais fácil e rápido! Todos os testes são verificados!


Resposta do @CMS : Seu snippet falhou em casos de espaços em branco na minha máquina usando o nodejs. Então combinei com a resposta de @ joel ao seguinte:

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

Eu testei com os casos que são floats:

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

e os casos que não são flutuantes (incluindo espaços em branco vazios e objetos / matrizes):

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

Tudo funciona como esperado aqui. Talvez isso ajude.

O código fonte completo para isso pode ser encontrado here .


A resposta do @Joel está bem próxima, mas irá falhar nos seguintes casos:

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

Algum tempo atrás eu tive que implementar uma função IsNumeric , para descobrir se uma variável continha um valor numérico, independentemente do seu tipo , poderia ser uma String contendo um valor numérico (eu tinha que considerar também a notação exponencial, etc.), um Objeto Number , praticamente qualquer coisa poderia ser passada para essa função, eu não poderia fazer nenhum tipo de suposição, cuidando da coerção de tipo (por exemplo, +true == 1; mas true não deveria ser considerado como "numeric" ).

Eu acho que vale a pena compartilhar este conjunto de testes de unidade de +30 feitos para numerosas implementações de função, e também compartilhar aquele que passa todos os meus testes:

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

PS isNaN e isFinite têm um comportamento confuso devido à conversão forçada para o número. No ES6, Number.isNaN & Number.isFinite iria corrigir esses problemas. Tenha isso em mente ao usá-los.

Atualização : Veja como o jQuery faz isso agora (2.2 estável) :

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

Atualização : Angular 4.3 :

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

funções de validação da biblioteca inbuild do knockoutJs

Ao estendê-lo, o campo é validado

1) número

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

Caso de teste

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

2) dígito

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

Caso de teste

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

3) min e max

self.number = ko.observable(numberValue) .extend ({min: 5}). extend ({max: 10}) ;

Este campo aceita valores entre 5 e 10 apenas

Caso de teste

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

Estou usando uma solução mais simples:

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

Eu percebo que isso foi respondido muitas vezes, mas o seguinte é um candidato decente que pode ser útil em alguns cenários.

deve-se notar que ele assume que '.42' NÃO é um número e '4.' NÃO é um número, então isso deve ser levado em consideração.

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

O isDecimalpassa o teste a seguir:

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

A idéia aqui é que todo número ou inteiro tem uma representação de cadeia "canônica", e toda representação não canônica deve ser rejeitada. Então, lançamos um número e voltamos e vemos se o resultado é a string original.

Se essas funções são úteis para você depende do caso de uso. Uma característica é que cadeias distintas representam números distintos (se ambos passarem no isNumber()teste).

Isto é relevante, por exemplo, para números como nomes de propriedades de objetos.

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

Minha solução

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

Parece funcionar em todas as situações, mas posso estar errado.


Um par de testes para adicionar:

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

Eu inventei isso:

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

A solução cobre:

  • Um sinal negativo opcional no início
  • Um único zero, ou um ou mais dígitos que não iniciam com 0, ou nada, desde que um período siga
  • Um período que é seguido por 1 ou mais números

Você pode minimizar essa função de várias maneiras e também pode implementá-la com uma regex personalizada para valores negativos ou gráficos personalizados:

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

Nenhuma das respostas retorna falsepara strings vazias, uma correção para isso ...

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

O único problema que tive com a answer do @ CMS é a exclusão de NaNe Infinity, que são números úteis para muitas situações. Uma maneira de verificar NaNé verificar os valores numéricos que não são iguais a si mesmos NaN != NaN! Então, existem 3 testes com os quais você gostaria de lidar ...

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

Meu isComparableNumber está bem próximo de outra answer elegante , mas lida com representações de números hexadecimais e outras cadeias de caracteres.


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

Isso funciona para números do tipo 0x23 também.


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

Se n for numérico Number(n), retornará o valor numérico e toString()o retornará para uma string. Mas se n não for numérico Number(n), retornará NaNpara não corresponder ao originaln





numbers