Espero que exista algo no mesmo espaço conceitual que a antiga IsNumeric()função VB6 ?

Para verificar se uma variável (incluindo uma string) é um número, verifique se não é um número:

Isso funciona independentemente de o conteúdo da variável ser uma sequência ou número.

isNaN(num)         // returns true if the variable does NOT contain a valid number

Exemplos

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

Obviamente, você pode negar isso se precisar. Por exemplo, para implementar o IsNumericexemplo que você deu:

function isNumeric(num){
  return !isNaN(num)
}

Para converter uma string contendo um número em um número:

Só funciona se a string contiver apenas caracteres numéricos, caso contrário, ela retornará NaN.

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

Exemplos

+'12'              // 12
+'12.'             // 12
+'12..'            // NaN
+'.12'             // 0.12
+'..12'            // NaN
+'foo'             // NaN
+'12px'            // NaN

Para converter uma sequência frouxamente em um número

Útil para converter '12px' em 12, por exemplo:

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

Exemplos

parseInt('12')     // 12
parseInt('aaa')    // NaN
parseInt('12px')   // 12
parseInt('foo2')   // NaN      These last two may be different
parseInt('12a5')   // 12       from what you expected to see. 

Flutuadores

Tenha em mente que, ao contrário +num, parseInt(como o nome sugere) irá converter um float em um número inteiro por decepar tudo após o ponto decimal (se você quiser usar parseInt() por causa esse comportamento, você é provavelmente melhor fora de usar um outro método em vez ) :

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

Cordas vazias

Strings vazias podem ser um pouco contra-intuitivas. +numconverte cadeias vazias ou cadeias com espaços em zero e isNaN()assume o mesmo:

+''                // 0
+'   '             // 0
isNaN('')          // false
isNaN('   ')       // false

Mas parseInt()não concorda:

parseInt('')       // NaN
parseInt('   ')    // NaN

E você pode seguir o caminho RegExp:

var num = "987238";

if(num.match(/^-{0,1}\d+$/)){
  //valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
  //valid float
}else{
  //not valid number
}

Se você está apenas tentando verificar se uma string é um número inteiro (sem casas decimais), a regex é um bom caminho a percorrer. Outros métodos, como isNaNsão muito complicados para algo tão simples.

function isNumeric(value) {
    return /^-{0,1}\d+$/.test(value);
}

console.log(isNumeric('abcd'));         // false
console.log(isNumeric('123a'));         // false
console.log(isNumeric('1'));            // true
console.log(isNumeric('1234567890'));   // true
console.log(isNumeric('-23'));          // true
console.log(isNumeric(1234));           // true
console.log(isNumeric('123.4'));        // false
console.log(isNumeric(''));             // false
console.log(isNumeric(undefined));      // false
console.log(isNumeric(null));           // false

Para permitir apenas números inteiros positivos , use o seguinte:

function isNumeric(value) {
    return /^\d+$/.test(value);
}

console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false

Se você realmente quer ter certeza de que uma string contém apenas um número, qualquer número (inteiro ou ponto flutuante), e exatamente um número, você não pode usar parseInt()/ parseFloat(), Number()ou !isNaN()por si mesmos. Observe que, !isNaN()na verdade, está retornando truequando Number()retornaria um número e falsequando retornaria NaN, portanto, vou excluí-lo do restante da discussão.

O problema parseFloat()é que ele retornará um número se a sequência contiver algum número, mesmo que a sequência não contenha apenas e exatamente um número:

parseFloat("2016-12-31")  // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2

O problema Number()é que ele retornará um número nos casos em que o valor passado não é um número!

Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0   \t\n\r") // returns 0

O problema de rolar o seu próprio regex é que, a menos que você crie o regex exato para corresponder a um número de ponto flutuante, já que o Javascript o reconhece, você perderá casos ou reconhecerá casos em que não deveria. E mesmo que você possa rolar sua própria regex, por quê? Existem maneiras mais simples de fazer isso.

No entanto, acontece que Number()(e isNaN()) faz a coisa certa para todos os casos em que parseFloat()retorna um número quando não deveria e vice-versa. Então, para descobrir se uma string é realmente exatamente e apenas um número, ligue para ambas as funções e ver se eles tanto return true:

function isNumber(str) {
  if (typeof str != "string") return false // we only process strings!
  // could also coerce to string: str = ""+str
  return !isNaN(str) && !isNaN(parseFloat(str))
}

A resposta aceita para esta pergunta tem algumas falhas (conforme destacado por outros usuários). Essa é uma das maneiras mais fáceis e comprovadas de abordá-lo em javascript:

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

Abaixo estão alguns bons casos de teste:

console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 '));                 // true
console.log(isNumeric('-32.2 '));             // true
console.log(isNumeric(-32.2));                // true
console.log(isNumeric(undefined));            // false

// the accepted answer fails at these tests:
console.log(isNumeric(''));                   // false
console.log(isNumeric(null));                 // false
console.log(isNumeric([]));                   // false

Experimente a função isNan :

A função isNaN () determina se um valor é um número ilegal (Não é um número).

Esta função retorna true se o valor for igual a NaN. Caso contrário, ele retornará false.

Esta função é diferente do método Number.isNaN () específico de número .

  A função global isNaN () converte o valor testado em um número e o testa.

Number.isNan () não converte os valores em um número e não retornará true para qualquer valor que não seja do tipo Number ...

Pergunta antiga, mas há vários pontos ausentes nas respostas fornecidas.

Notação científica.

!isNaN('1e+30')é true, no entanto, na maioria dos casos, quando as pessoas pedem números, elas não querem corresponder a coisas como essa 1e+30.

Grandes números flutuantes podem se comportar de maneira estranha

Observe (usando o Node.js):

> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>

Por outro lado:

> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>

Portanto, se alguém espera String(Number(s)) === s, limite melhor suas seqüências para 15 dígitos no máximo (depois de omitir zeros à esquerda).

Infinidade

> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>

Dado tudo isso, verificar se a sequência fornecida é um número que satisfaz todos os seguintes itens:

• notação não científica
• conversão previsível para Numbere de volta paraString
• finito

não é uma tarefa tão fácil. Aqui está uma versão simples:

  function isNonScientificNumberString(o) {
    if (!o || typeof o !== 'string') {
      // Should not be given anything but strings.
      return false;
    }
    return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
  }

No entanto, mesmo este está longe de estar completo. Os zeros à esquerda não são manipulados aqui, mas estragam o teste de comprimento.

Eu testei e a solução de Michael é a melhor. Vote na resposta acima (pesquise nesta página "Se você realmente quer ter certeza de que tem uma string" para encontrá-la). Em essência, sua resposta é esta:

function isNumeric(num){
  num = "" + num; //coerce num to be a string
  return !isNaN(num) && !isNaN(parseFloat(num));
}

Ele funciona para todos os casos de teste que eu documentei aqui: https://jsfiddle.net/wggehvp9/5/

Muitas das outras soluções falham nesses casos extremos: '', null, "", true e []. Em teoria, você poderia usá-los, com o tratamento adequado de erros, por exemplo:

return !isNaN(num);

ou

return (+num === +num);

com tratamento especial para / \ s /, null, "", true, false, [] (e outros?)

Você pode usar o resultado de Number ao passar um argumento para seu construtor.

Se o argumento (uma sequência) não puder ser convertido em um número, ele retornará NaN, para que você possa determinar se a sequência fornecida era um número válido ou não.

Notas: Observe ao passar uma string vazia ou '\t\t'e '\n\t'como Number retornará 0; Passar true retornará 1 e retornos falsos 0.

    Number('34.00') // 34
    Number('-34') // -34
    Number('123e5') // 12300000
    Number('123e-5') // 0.00123
    Number('999999999999') // 999999999999
    Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
    Number('0xFF') // 255
    Number('Infinity') // Infinity  

    Number('34px') // NaN
    Number('xyz') // NaN
    Number('true') // NaN
    Number('false') // NaN

    // cavets
    Number('    ') // 0
    Number('\t\t') // 0
    Number('\n\t') // 0

Talvez haja uma ou duas pessoas que se deparem com essa pergunta que precisam de uma verificação muito mais rigorosa do que o habitual (como eu). Nesse caso, isso pode ser útil:

if(str === String(Number(str))) {
  // it's a "perfectly formatted" number
}

Cuidado! Isto irá rejeitar strings como .1, 40.000, 080, 00.1. É muito exigente - a string deve corresponder à " forma perfeita mínima " do número para que esse teste seja aprovado.

Ele usa o construtor Stringe Numberpara converter a string em um número e vice-versa e, assim, verifica se a "forma mínima perfeita" do mecanismo JavaScript (a qual foi convertida com o Numberconstrutor inicial ) corresponde à string original.

parseInt (), mas saiba que essa função é um pouco diferente no sentido de que, por exemplo, retorna 100 para parseInt ("100px").

Citar:

isNaN (num) // retorna true se a variável NÃO contém um número válido

não é totalmente verdade se você precisar verificar espaços à esquerda / à direita - por exemplo, quando uma certa quantidade de dígitos for necessária e você precisar obter, por exemplo, '1111' e não '111' ou '111' para talvez um PIN entrada.

Melhor usar:

var num = /^\d+$/.test(num)

Por que a implementação do jQuery não é boa o suficiente?

function isNumeric(a) {
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};

Michael sugeriu algo assim (embora eu tenha roubado a versão alterada de "user1691651 - John" aqui):

function isNumeric(num){
    num = "" + num; //coerce num to be a string
    return !isNaN(num) && !isNaN(parseFloat(num));
}

A seguir, é apresentada uma solução com provavelmente um desempenho ruim, mas com resultados sólidos. É uma engenhoca feita a partir da implementação do jQuery 1.12.4 e da resposta de Michael, com uma verificação extra para espaços iniciais / finais (porque a versão de Michael retorna verdadeira para números com espaços iniciais / finais):

function isNumeric(a) {
    var str = a + "";
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
           !/^\s+|\s+$/g.test(str) &&
           !isNaN(str) && !isNaN(parseFloat(str));
};

A última versão possui duas novas variáveis, no entanto. Pode-se contornar um desses, fazendo:

function isNumeric(a) {
    if ($.isArray(a)) return false;
    var b = a && a.toString();
    a = a + "";
    return b - parseFloat(b) + 1 >= 0 &&
            !/^\s+|\s+$/g.test(a) &&
            !isNaN(a) && !isNaN(parseFloat(a));
};

Não testei muito disso, por outros meios, além de testar manualmente os poucos casos de uso que farei com minha situação atual, que é uma coisa muito comum. Esta é uma situação "em pé sobre os ombros dos gigantes".

Não é válido para o TypeScript como:

declare function isNaN(number: number): boolean;

Para TypeScript, você pode usar:

/^\d+$/.test(key)

Bem, eu estou usando este que eu fiz ...

Está trabalhando até agora:

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

Se você encontrar algum problema, diga-me, por favor.

Se alguém chega a esse ponto, passei algum tempo tentando descobrir o moment.js ( https://github.com/moment/moment ). Aqui está uma coisa que eu tirei dela:

function isNumeric(val) {
    var _val = +val;
    return (val !== val + 1) //infinity check
        && (_val === +val) //Cute coercion check
        && (typeof val !== 'object') //Array/object check
}

Lida com os seguintes casos:

Verdade! :

isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))

Falso! :

isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))

Ironicamente, aquele com quem mais estou lutando:

isNumeric(new Number(1)) => false

Todas as sugestões são bem-vindas. :]

Usando JavaScript simples:

Number.isNaN(Number('1')); // false
Number.isNaN(Number('asdf')); // true

Usando o Lodash:

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true

function isNumberCandidate(s) {
  const str = (''+ s).trim();
  if (str.length === 0) return false;
  return !isNaN(+str);
}

console.log(isNumberCandidate('1'));       // true
console.log(isNumberCandidate('a'));       // false
console.log(isNumberCandidate('000'));     // true
console.log(isNumberCandidate('1a'));      // false 
console.log(isNumberCandidate('1e'));      // false
console.log(isNumberCandidate('1e-1'));    // true
console.log(isNumberCandidate('123.3'));   // true
console.log(isNumberCandidate(''));        // false
console.log(isNumberCandidate(' '));       // false
console.log(isNumberCandidate(1));         // true
console.log(isNumberCandidate(0));         // true
console.log(isNumberCandidate(NaN));       // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null));      // false
console.log(isNumberCandidate(-1));        // true
console.log(isNumberCandidate('-1'));      // true
console.log(isNumberCandidate('-1.2'));    // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity));    // true
console.log(isNumberCandidate(-Infinity));    // true

console.log(isNumberCandidate('Infinity'));  // true

if (isNumberCandidate(s)) {
  // use +s as a number
  +s ...
}

2019: Incluindo exemplos ES3, ES6 e TypeScript

Talvez isso tenha sido repetido muitas vezes, no entanto, eu lutei com essa também hoje e queria postar minha resposta, pois não vi nenhuma outra resposta que a faça de maneira simples ou completa:

ES3

var isNumeric = function(num){
    return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);  
}

ES6

const isNumeric = (num) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);

Texto datilografado

const isNumeric = (num: any) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num as number);

Isso parece bastante simples e abrange todas as bases que eu vi nas muitas outras postagens e pensei:

// Positive Cases
console.log(0, isNumeric(0) === true);
console.log(1, isNumeric(1) === true);
console.log(1234567890, isNumeric(1234567890) === true);
console.log('1234567890', isNumeric('1234567890') === true);
console.log('0', isNumeric('0') === true);
console.log('1', isNumeric('1') === true);
console.log('1.1', isNumeric('1.1') === true);
console.log('-1', isNumeric('-1') === true);
console.log('-1.2354', isNumeric('-1.2354') === true);
console.log('-1234567890', isNumeric('-1234567890') === true);
console.log(-1, isNumeric(-1) === true);
console.log(-32.1, isNumeric(-32.1) === true);
console.log('0x1', isNumeric('0x1') === true);  // Valid number in hex
// Negative Cases
console.log(true, isNumeric(true) === false);
console.log(false, isNumeric(false) === false);
console.log('1..1', isNumeric('1..1') === false);
console.log('1,1', isNumeric('1,1') === false);
console.log('-32.1.12', isNumeric('-32.1.12') === false);
console.log('[blank]', isNumeric('') === false);
console.log('[spaces]', isNumeric('   ') === false);
console.log('null', isNumeric(null) === false);
console.log('undefined', isNumeric(undefined) === false);
console.log([], isNumeric([]) === false);
console.log('NaN', isNumeric(NaN) === false);

Você também pode tentar sua própria isNumericfunção e simplesmente passar nesses casos de uso e procurar "true" em todos eles.

Ou, para ver os valores que cada retorno:

2019: Verificação prática e rigorosa da validade numérica

Freqüentemente, um 'número válido' significa um número Javascript excluindo NaN e Infinity, ou seja, um 'número finito'.

Para verificar a validade numérica de um valor (de uma fonte externa, por exemplo), você pode definir no estilo ESlint Airbnb:

/**
 * Returns true if 'candidate' is a finite number or a string referring (not just 'including') a finite number
 * To keep in mind:
 *   Number(true) = 1
 *   Number('') = 0
 *   Number("   10  ") = 10
 *   !isNaN(true) = true
 *   parseFloat('10 a') = 10
 *
 * @param {?} candidate
 * @return {boolean}
 */
function isReferringFiniteNumber(candidate) {
  if (typeof (candidate) === 'number') return Number.isFinite(candidate);
  if (typeof (candidate) === 'string') {
    return (candidate.trim() !== '') && Number.isFinite(Number(candidate));
  }
  return false;
}

e use desta maneira:

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}

PFB a solução de trabalho:

 function(check){ 
    check = check + "";
    var isNumber =   check.trim().length>0? !isNaN(check):false;
    return isNumber;
    }

Salve-se a dor de cabeça ao tentar encontrar uma solução "embutida".

Não há uma boa resposta, e a resposta altamente votada neste tópico está errada.

npm install is-number

Em JavaScript, nem sempre é tão simples como deve ser o de verificar com segurança se um valor é um número. É comum que os desenvolvedores usem +, - ou Number () para converter um valor de string em um número (por exemplo, quando os valores são retornados da entrada do usuário, correspondências de regex, analisadores, etc.). Mas há muitos casos extremos não intuitivos que produzem resultados inesperados:

console.log(+[]); //=> 0
console.log(+''); //=> 0
console.log(+'   '); //=> 0
console.log(typeof NaN); //=> 'number'

Recentemente, escrevi um artigo sobre maneiras de garantir que uma variável seja um número válido: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md O artigo explica como garantir ponto flutuante ou número inteiro, se for o caso importante ( +xvs~~x ).

O artigo pressupõe que a variável é a stringou a numberpara começar e trimestá disponível / preenchida com polyfilled. Não seria difícil estendê-lo para lidar com outros tipos também. Aqui está a carne:

// Check for a valid float
if (x == null
    || ("" + x).trim() === ""
    || isNaN(+x)) {
    return false;  // not a float
}

// Check for a valid integer
if (x == null
    || ("" + x).trim() === ""
    || ~~x !== +x) {
    return false;  // not an integer
}

Minha tentativa de um pouco confuso, talvez não seja a melhor solução

function isInt(a){
    return a === ""+~~a
}


console.log(isInt('abcd'));         // false
console.log(isInt('123a'));         // false
console.log(isInt('1'));            // true
console.log(isInt('0'));            // true
console.log(isInt('-0'));           // false
console.log(isInt('01'));           // false
console.log(isInt('10'));           // true
console.log(isInt('-1234567890'));  // true
console.log(isInt(1234));           // false
console.log(isInt('123.4'));        // false
console.log(isInt(''));             // false

// other types then string returns false
console.log(isInt(5));              // false
console.log(isInt(undefined));      // false
console.log(isInt(null));           // false
console.log(isInt('0x1'));          // false
console.log(isInt(Infinity));       // false

Na minha aplicação, estamos apenas permitindo az AZ e 0-9 caracteres. Eu encontrei a resposta acima usando " string % 1 === 0" funcionou, a menos que a string iniciasse com 0xnn (como 0x10) e depois a retornaria como numérica quando não desejássemos. A armadilha simples a seguir na minha verificação numérica parece fazer o truque em nossos casos específicos.

function isStringNumeric(str_input){   
    //concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up   
    //very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine   
    return '1'.concat(str_input) % 1 === 0;}

Aviso : Isso pode estar explorando um bug antigo no Javascript e no Actionscript [Number ("1" + the_string)% 1 === 0)]. Não posso falar sobre isso, mas é exatamente o que precisávamos.

Minha solução:

// returns true for positive ints; 
// no scientific notation, hexadecimals or floating point dots

var isPositiveInt = function(str) { 
   var result = true, chr;
   for (var i = 0, n = str.length; i < n; i++) {
       chr = str.charAt(i);
       if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
         result = false;
         break;
       };
       if (i == 0 && (chr == "0" || chr == ",")) {  //should not start with 0 or ,
         result = false;
         break;
       };
   };
   return result;
 };

Você pode adicionar condições adicionais dentro do loop, para atender às suas necessidades específicas.

Você pode fazer uso de tipos, como na biblioteca de fluxo y, para obter uma verificação estática e do tempo de compilação. Claro que não é muito útil para a entrada do usuário.

// @flow

function acceptsNumber(value: number) {
  // ...
}

acceptsNumber(42);       // Works!
acceptsNumber(3.14);     // Works!
acceptsNumber(NaN);      // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo");    // Error!

Aqui está uma lista para verificar se sNumé um valor numérico válido; foi testado para uma ampla variedade de entradas:

!isNaN(+s.replace(/\s|\$/g, ''));  // returns True if numeric value

Basta usar isNaN(), isso converterá a string em um número e, se receber um número válido , retornará false...

isNaN("Alireza"); //return true
isNaN("123"); //return false

Estou usando o seguinte:

const isNumber = s => !isNaN(+s)