(Incorporado) no JavaScript para verificar se uma sequência é um número válido

1190

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

Electrons_Ahoy
fonte
3
Veja esta pergunta relacionada , que eu perguntei há algum tempo.
Michael Haren
38
Se você for fazer essa pergunta, tente pular todas as respostas do RegEx. Essa não é apenas a maneira de fazê-lo.
Joel Coehoorn
14
A menos que se queira fazer exatamente isso: Para verificar se uma determinada sequência possui um formato de um fluxo de dígitos válido. Por que deveria estar errado então?
SasQ
17
A resposta selecionada está incorreta !!! Veja seus comentários, mas basicamente ele falhar com, por exemplo isNaN(""), isNaN(" "), isNaN(false), etc. ele retorna falsepara estes, o que implica que eles são números.
Andrew
1
para que a resposta selecionada esteja incorreta, a regexp também não é a maneira de fazer isso. Qual deles está correto então?
vir us

Respostas:

2322

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
Dan
fonte
133
Uma observação muito importante sobre o parseInt é que ele permitirá que você especifique uma raiz para converter a string em um int. Este é um grande problema, pois tenta adivinhar uma raiz para você, se você não a fornecer. Assim, por exemplo: parseInt ("17") resulta em 17 (decimal, 10), mas parseInt ("08") resulta em 0 (octal, 8). Portanto, a menos que você pretenda o contrário, é mais seguro usar parseInt (número, 10), especificando 10 como o radical explicitamente.
31511 Adam Raney
36
Observe que! IsNaN (indefinido) retorna falso.
David Hellsing
111
Isso está totalmente errado - como conseguiu tantos votos positivos? Você não pode usar isNaN"Para verificar se uma variável não é um número". "não é um número" não é o mesmo que "IEEE-794 NaN", que é o que isNaNtesta. Em particular, esse uso falha ao testar booleanos e seqüências de caracteres vazias, pelo menos. Consulte developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
EML
46
A maneira mais rápida possível de verificar se algo é um número é a verificação "igual a si mesmo": var n = 'a'; if (+n === +n) { // is number }é ~ 3994% mais rápido que o isNaN na versão mais recente do Chrome. Veja o teste de desempenho aqui: jsperf.com/isnan-vs-typeof/5
Kevin Jurkowski
22
** Aviso ** Esta resposta está errada. Use por sua conta e risco. Exemplo:isNaN(1 + false + parseInt("1.do you trust your users?"))
keithpjolley
55

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
}
roenving
fonte
40
Nesse caso, RegExp == ruim
Joel Coehoorn
10
Isso falha nos números hexadecimais (0x12, por exemplo), flutua sem um zero à esquerda (0,42, por exemplo) e números negativos.
Ori
17
@JoelCoehoorn Cuidado para explicar por que a RegExp é ruim aqui? Parece ser um caso de uso válido para mim.
computrius
6
Existem mais maneiras do que parece criar um número (números hexadecimais em outro comentário são apenas um exemplo), e há muitos números que podem não ser considerados válidos (transbordar o tipo, muito preciso, etc.). Além disso, regex é tanto mais lento e mais complicado do que apenas usando o built-in mecanismos
Joel Coehoorn
1
também deve coincidir com a notação científica ... 1e10 etc.
Joseph Merdrignac 30/10
51

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
Gavin
fonte
11
console.log (isNumeric ('- 1'));
Yongnan
5
console.log (isNumeric ('2e2'));
Gaël Barbin 02/03
11
Talvez apenas renomeie "isNumeric" para "hasOnlyDigits". em muitos casos, essa é exatamente a verificação que você está procurando.
precisa saber é o seguinte
1
Isto é o que eu estava procurando, o equivalente a ctype_digit php
Miguel Pynto
/^-?\d+$/direita?
Sukima 15/04
36

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))
}
Michael
fonte
2
Isso retorna true quando a string possui espaços à esquerda ou à direita. ' 1', '2 'E ' 3 'todos return true.
Rudey
Adicionar algo assim à declaração de retorno resolveria o seguinte: &&! / ^ \ S + | \ s + $ / g.test (str)
Ultroman the Tacoman
2
@RuudLenders - a maioria das pessoas não se importa se houver espaços à direita para tornar a string um número válido, porque é fácil colocar acidentalmente os espaços extras em muitas interfaces.
Ian
3
Isso é verdade caso a sequência numérica venha da entrada do usuário. Mas pensei em mencionar espaços de qualquer maneira, porque acho que a maioria das pessoas que precisam de uma isNumberfunção não está lidando com interfaces de usuário. Além disso, uma boa entrada de número não permitirá espaços para começar.
Rudey
36

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
Hamzeen Hameem
fonte
22

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

theraccoonbear
fonte
2
Certifique-se de adicionar uma verificação para a sequência vazia. isNaN ('') retorna false, mas você provavelmente deseja que ele retorne true nesse caso.
Michael Haren
3
O isFinite é uma verificação melhor - ele lida com o caso estranho do Infinity
JonnyRaa
3
@MichaelHaren Não é bom o suficiente! isNaN()retorna falsepara QUALQUER string que contenha apenas caracteres de espaço em branco, incluindo coisas como '\ u00A0'.
Michael
1
AVISO: Não funciona para os valores: null, "" (string vazia) e false.
21917 Jenny O'Reilly
Sei que esta resposta foi dada há 11 anos e alguns minutos antes da resposta aceita, mas, gostando ou não, a resposta aceita tem MUITO mais conversa a seu respeito, portanto, essa resposta realmente não adiciona nada para responder à pergunta. Gostaria de sugerir a exclusão, para evitar a distração de novos leitores. Eu também acho que você receberá o distintivo Disciplinado se fizer isso.
Dan Dascalescu
14

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.

marca
fonte
1
"no entanto, na maioria dos casos, quando as pessoas pedem números, elas não querem corresponder a coisas como 1e + 30" Por que você diz isso? Se alguém quiser saber se uma string contém um número, parece-me que eles gostariam de saber se ela contém um número e 1e + 30 é um número. Certamente, se eu estivesse testando uma string para um valor numérico em JavaScript, gostaria que ela correspondesse.
Dan Jones
9

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?)

JohnP2
fonte
1
Isso ainda retorna verdadeiro com espaços à direita / à direita. Adicionando algo assim para o retorno declaração resolveria que: && / ^ \ s + | \ s + $ / g.test (str)!
Ultroman o Tacoman
2
Então '123' deve ser falso, não um número, enquanto '1234' deve ser um número? Eu gosto de como é, de modo que "123" é um número, mas isso pode ser do critério do desenvolvedor, se espaços à esquerda ou à direita mudarem o valor.
JohnP2
8

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
GibboK
fonte
O Numberconstrutor é exatamente o mesmo que +x.
GregRos
Como uma observação lateral, lembre-se de que o ES6 também Number()lida com números flutuantes, como Number.parseFloat()nãoNumber.parseInt()
zurfyx
7

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.


fonte
2
Obrigado @JoeRocc. Eu precisava disso também, mas apenas para números inteiros, então eu adicionei: (str === String(Math.round(Number(str)))).
Keithpjolley
Esteja ciente de que "Infinity", "-Infinity"e "NaN"passe neste teste. No entanto, isso pode ser corrigido usando um Number.isFiniteteste adicional .
GregRos
Isto é exatamente o mesmo que str === ("" + +str). Ele basicamente verifica se a sequência é o resultado da sequência de um número JS. Sabendo disso, também podemos ver um problema: o teste passa, 0.000001mas falha 0.0000001, e é quando 1e-7passa. O mesmo para números muito grandes.
GregRos
5

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

liggett78
fonte
E 11 para parseInt(09).
djechlin
10
porque você precisa usarparaseInt(09, 10)
Gavin
1
No ECMAScript 5 , que possui amplo suporte ao navegador (IE≥9), você não precisa mais do , 10argumento. parseInt('09')agora é igual a 9.
Rory O'Kane
4

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)
Siubear
fonte
Os valores '-1', '0.1'e '1e10'tudo falso retorno. Além disso, valores maiores que o infinito positivo ou menores que o infinito negativo retornam true, enquanto provavelmente devem retornar false.
Rudey
4

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".

Ultroman, o Tacoman
fonte
4

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

declare function isNaN(number: number): boolean;

Para TypeScript, você pode usar:

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

Greg Woz
fonte
3

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.

Rafael
fonte
12
Isso fornece o resultado errado para a sequência vazia, matriz vazia, false e nulo.
Ori
2
Não deveria ser um triplo igual?
toasted_flakes
1
Na minha aplicação, estamos apenas permitindo az AZ e 0-9 caracteres. Eu descobri que o acima funcionou, a menos que a string iniciasse com 0xnn e, em seguida, retornaria como numérica quando não deveria.
Rwheadon 8/07
6
você poderia apenas fazer 'valor de retorno% 1 === 0'
Brian Schermerhorn
Apenas façareturn !isNaN(parseInt(value, 10));
DarkNeuron 25/10/19
3

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. :]

O Dembinski
fonte
2
Que tal isNumeric(' ')e isNumeric('')?
Alex Cory
Eu acrescentaria && (val.replace(/\s/g,'') !== '') //Empty && (val.slice(-1) !== '.') //Decimal without Numberpara abordar a questão acima mencionada e uma que eu mesmo.
frankenapps
3

Usando JavaScript simples:

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

Usando o Lodash:

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true
Abtin Gramian
fonte
3
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 ...
}
gvlax
fonte
Obrigado, ótima resposta!
M.Abulsoud
3

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:

Resultados de cada teste em relação a <code> isNumeric () </code>

Jeremy
fonte
3

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');
}
JP Duvet
fonte
2

PFB a solução de trabalho:

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

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'
cdeutsch
fonte
1

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
}
Travis Parks
fonte
1

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
Sem fim
fonte
Não é muito ruim, dois ruins não funcionam para nenhuma notação não decimal, como (1) notação científica e (2) notação não-base-10, como octal ( 042) e hexadecimal ( 0x45f)
Domi
Isso não responde à questão de procurar um valor numérico, apenas procura um int.
Jeremy
0

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.

rwheadon
fonte
Por que isso seria um bug no JavaScript?
Bergi 08/07/19
Simplesmente não vejo o mesmo comportamento com uma solução semelhante em perl ou C, e como não sou desenvolvedor de linguagem de programação para javascript ou actionscript, não sei se o comportamento que estou enfrentando é realmente intencional ou não.
Rwheadon 8/07
Bem, o javascript é um pouco superficial sobre a conversão implícita de tipos, mas depois que você souber que poderá entender facilmente como ele funciona. Você está convertendo strings para números (invocando a % 1operação numérica neles), e isso interpretará a string como um literal hexadecimal ou flutuante.
Bergi 08/07/19
0

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.

Vamos para
fonte
0

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!
O que seria legal
fonte
0

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
equilíbrio
fonte
0

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
Alireza
fonte
0

Estou usando o seguinte:

const isNumber = s => !isNaN(+s)
haxpanel
fonte
Funciona relativamente bem é muitos casos, mas não consegue casos como 1..1, 1,1, -32.1.12e, mais importante falha undefinede NaN. Se você aprovou undefinedou NaNlhe devolveu um falso positivo, dizendo que era um número.
Jeremy