Forma (incorporada) en JavaScript para verificar si una cadena es un número válido

1190

¿Espero que haya algo en el mismo espacio conceptual que la antigua IsNumeric()función VB6 ?

Electrones_Ahoy
fuente
3
Vea esta pregunta relacionada , que hice hace algún tiempo.
Michael Haren
38
Si responde a esta pregunta, intente omitir todas las respuestas de RegEx. Esa NO es la forma de hacerlo.
Joel Coehoorn el
14
A menos que uno quiera hacer exactamente eso: Verificar si una cadena dada tiene un formato de flujo de dígitos válido. ¿Por qué debería estar mal entonces?
SasQ
17
¡La respuesta seleccionada es incorrecta! Ver sus comentarios, pero básicamente se produce un error con, por ejemplo isNaN(""), isNaN(" "), isNaN(false), etc. Devuelve falsepara éstos, lo que implica que son los números.
Andrew
1
entonces la respuesta seleccionada es incorrecta, regexp tampoco es la forma de hacerlo. ¿Cuál es correcto entonces?
vir us

Respuestas:

2322

Para verificar si una variable (incluyendo una cadena) es un número, verifique si no es un número:

Esto funciona independientemente de si el contenido variable es una cadena o un número.

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

Ejemplos

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

Por supuesto, puede negar esto si lo necesita. Por ejemplo, para implementar el IsNumericejemplo que dio:

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

Para convertir una cadena que contiene un número en un número:

Solo funciona si la cadena solo contiene caracteres numéricos, de lo contrario, regresa NaN.

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

Ejemplos

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

Para convertir una cadena libremente a un número

Útil para convertir '12px' a 12, por ejemplo:

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

Ejemplos

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. 

Carrozas

Tenga en cuenta que, a diferencia de +num, parseInt(como su nombre lo indica) convertirá un flotador en un entero cortando todo siguiendo el punto decimal (si desea usarlo parseInt() debido a este comportamiento, probablemente sea mejor usar otro método ) :

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

Cadenas vacías

Las cadenas vacías pueden ser un poco contra-intuitivas. +numconvierte cadenas vacías o cadenas con espacios a cero, y isNaN()asume lo mismo:

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

Pero parseInt()no está de acuerdo:

parseInt('')       // NaN
parseInt('   ')    // NaN
Dan
fuente
133
Una nota muy importante sobre parseInt es que le permitirá especificar una raíz para convertir la cadena en un int. Este es un gran problema ya que trata de adivinar una raíz para ti si no la suministras. Entonces, por ejemplo: parseInt ("17") da como resultado 17 (decimal, 10), pero parseInt ("08") da como resultado 0 (octal, 8). Entonces, a menos que intente lo contrario, es más seguro usar parseInt (número, 10), especificando 10 como la raíz explícitamente.
Adam Raney
36
Tenga en cuenta que! IsNaN (undefined) devuelve falso.
David Hellsing, el
111
Esto es simplemente incorrecto: ¿cómo obtuvo tantos votos a favor? No puede usar isNaN"Para verificar si una variable no es un número". "no es un número" no es lo mismo que "IEEE-794 NaN", que es lo que se isNaNprueba. En particular, este uso falla al probar booleanos y cadenas vacías, al menos. Ver developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
EML
46
La forma más rápida posible de verificar si algo es un número es la comprobación de "igual a sí mismo": var n = 'a'; if (+n === +n) { // is number }es ~ 3994% más rápido que isNaN en la última versión de Chrome. Vea la prueba de rendimiento aquí: jsperf.com/isnan-vs-typeof/5
Kevin Jurkowski
22
** Advertencia ** Esta respuesta es incorrecta. Úselo bajo su propio riesgo. Ejemplo:isNaN(1 + false + parseInt("1.do you trust your users?"))
keithpjolley
55

Y usted podría seguir el camino 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
fuente
40
En este caso, RegExp == malo
Joel Coehoorn
10
Esto falla en números hexadecimales (0x12, por ejemplo), flota sin un cero a la izquierda (.42, por ejemplo) y números negativos.
Ori
17
@JoelCoehoorn Care para explicar por qué RegExp == está mal aquí? Parece ser un caso de uso válido para mí.
computrius
66
Hay más formas de lo que parece construir un número (los números hexadecimales en otro comentario son solo un ejemplo), y hay muchos números que pueden no considerarse válidos (desbordar el tipo, demasiado preciso, etc.). Además, la expresión regular es más lenta y más complicada que simplemente usar los mecanismos integrados
Joel Coehoorn
1
también debe coincidir con la notación científica ... 1e10 etc.
Joseph Merdrignac
51

Si solo está tratando de verificar si una cadena es un número entero (sin decimales), la expresión regular es una buena manera de hacerlo. Otros métodos como isNaNson demasiado complicados para algo tan simple.

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 solo números enteros positivos , use esto:

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

console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false
Gavin
fuente
11
console.log (isNumeric ('- 1'));
yongnan
55
console.log (isNumeric ('2e2'));
Gaël Barbin
11
Quizás solo cambie el nombre de "isNumeric" a "hasOnlyDigits". en muchos casos, ese es exactamente el cheque que está buscando.
gus3001
1
Esto es lo que estaba buscando, el equivalente a php ctype_digit
Miguel Pynto
/^-?\d+$/¿Correcto?
Sukima
36

Si realmente quiere asegurarse de que una cadena contiene sólo un número, cualquier número (entero o de coma flotante), y exactamente un número, no se puede utilizar parseInt()/ parseFloat(), Number()o !isNaN()por sí mismos. Tenga en cuenta que en !isNaN()realidad está devolviendo truecuándo Number()devolvería un número y falsecuándo volvería NaN, por lo que lo excluiré del resto de la discusión.

El problema con parseFloat()es que devolverá un número si la cadena contiene algún número, incluso si la cadena no contiene solo y exactamente un número:

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

¡El problema Number()es que devolverá un número en los casos en que el valor pasado no sea un número en absoluto!

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

El problema con rodar su propia expresión regular es que, a menos que cree la expresión regular exacta para que coincida con un número de coma flotante, ya que Javascript lo reconoce, perderá casos o reconocerá casos donde no debería hacerlo. E incluso si puedes rodar tu propia expresión regular, ¿por qué? Hay formas integradas más simples de hacerlo.

Sin embargo, resulta que Number()(y isNaN()) hace lo correcto para cada caso donde parseFloat()devuelve un número cuando no debería, y viceversa. Entonces, para averiguar si una cadena es realmente exacta y solo un número, llame a ambas funciones y vea si ambas devuelven verdadero:

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))
}
Miguel
fuente
2
Esto devuelve verdadero cuando la cadena tiene espacios iniciales o finales. ' 1', '2 'y ' 3 'todo vuelve verdadero.
Rudey
Agregar algo como esto a la declaración de devolución resolvería eso: &&! / ^ \ S + | \ s + $ / g.test (str)
Ultroman the Tacoman
2
@RuudLenders: a la mayoría de las personas no les importará si hay espacios finales que se cortan para hacer que la cadena sea un número válido, porque es fácil colocar accidentalmente espacios adicionales en muchas interfaces.
Ian
3
Eso es cierto en caso de que la cadena numérica provenga de la entrada del usuario. Pero pensé que debería mencionar espacios de todos modos, porque creo que la mayoría de las personas que necesitan una isNumberfunción no están tratando con interfaces de usuario. Además, una buena entrada de números no permitirá espacios para comenzar.
Rudey
36

La respuesta aceptada para esta pregunta tiene bastantes fallas (como lo destacan algunos otros usuarios). Esta es una de las formas más fáciles y probadas de abordarlo en javascript:

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

A continuación se presentan algunos buenos casos de prueba:

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
fuente
22

Pruebe la función isNan :

La función isNaN () determina si un valor es un número ilegal (No es un número).

Esta función devuelve verdadero si el valor equivale a NaN. De lo contrario, devuelve falso.

Esta función es diferente del método Number.isNaN () específico del número .

  La función global isNaN (), convierte el valor probado en un Número, luego lo prueba.

Number.isNan () no convierte los valores en un Número, y no devolverá verdadero para cualquier valor que no sea del tipo Número ...

theraccoonbear
fuente
2
Asegúrese de agregar un cheque para la cadena vacía. isNaN ('') devuelve falso, pero probablemente desee que devuelva verdadero en este caso.
Michael Haren
3
isFinite es un mejor cheque: trata con el extraño caso de Infinity en la esquina
JonnyRaa
3
@MichaelHaren ¡No es lo suficientemente bueno! isNaN()retornos falsepara cualquier cadena que contiene sólo espacios en blanco caracteres, incluyendo cosas como '\ u00a0'.
Michael
1
ADVERTENCIA: No funciona para los valores: nulo, "" (cadena vacía) y falso.
Jenny O'Reilly
Me doy cuenta de que esta respuesta se dio hace 11 años y unos minutos antes de la aceptada, pero me guste o no, la respuesta aceptada tiene MUCHA más conversación, por lo que esta respuesta realmente no agrega nada a la respuesta a la pregunta. Le sugiero que lo elimine, para evitar distraer a los nuevos lectores. También creo que obtendrás la insignia Disciplinado si haces eso.
Dan Dascalescu
14

Antigua pregunta, pero faltan varios puntos en las respuestas dadas.

Notación cientifica.

!isNaN('1e+30')es true, sin embargo, en la mayoría de los casos cuando las personas piden números, no quieren hacer coincidir cosas como 1e+30.

Los grandes números flotantes pueden comportarse de forma extraña.

Observar (usando 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 otra parte:

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

Entonces, si uno espera String(Number(s)) === s, mejor limite sus cadenas a 15 dígitos como máximo (después de omitir los ceros iniciales).

infinito

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

Dado todo eso, comprobar que la cadena dada es un número que satisface todo lo siguiente:

  • notación no científica
  • conversión predecible ay Numbervolver aString
  • finito

No es una tarea tan fácil. Aquí hay una versión simple:

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

Sin embargo, incluso este está lejos de estar completo. Los ceros iniciales no se manejan aquí, pero sí atornillan la prueba de longitud.

marca
fuente
1
"Sin embargo, en la mayoría de los casos, cuando las personas piden números, no quieren hacer coincidir cosas como 1e + 30" ¿Por qué dirías esto? Si alguien quiere saber si una cadena contiene un número, me parece que querría saber si contiene un número, y 1e + 30 es un número. Ciertamente, si estuviera probando una cadena para un valor numérico en JavaScript, me gustaría que coincidiera.
Dan Jones
9

Lo he probado y la solución de Michael es la mejor. Vote por su respuesta anterior (busque en esta página "Si realmente quiere asegurarse de que hay una cadena" para encontrarla). En esencia, su respuesta es esta:

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

Funciona para cada caso de prueba, que documenté aquí: https://jsfiddle.net/wggehvp9/5/

Muchas de las otras soluciones fallan para estos casos extremos: '', nulo, "", verdadero y []. En teoría, podría usarlos, con el manejo adecuado de errores, por ejemplo:

return !isNaN(num);

o

return (+num === +num);

con manejo especial para / \ s /, nulo, "", verdadero, falso, [] (y otros?)

JohnP2
fuente
1
Esto aún se cumple con espacios finales / iniciales. Agregar algo como esto a la declaración de devolución resolvería eso: &&! / ^ \ S + | \ s + $ / g.test (str)
Ultroman the Tacoman
2
¿Entonces '123' debería ser falso, no un número, mientras que '1234' debería ser un número? Me gusta cómo es, de modo que "123" es un número, pero eso puede depender de la discreción del desarrollador si los espacios iniciales o finales deben cambiar el valor.
JohnP2
8

Puede usar el resultado de Number al pasar un argumento a su constructor.

Si el argumento (una cadena) no se puede convertir en un número, devuelve NaN, por lo que puede determinar si la cadena proporcionada es un número válido o no.

Notas: Nota al pasar una cadena vacía o '\t\t', y '\n\t'como número devolverá 0; Pasar verdadero devolverá 1 y falso devolverá 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
fuente
El Numberconstructor es exactamente el mismo que +x.
GregRos
Como nota al margen, tenga en cuenta que el ES6 también Number()maneja números flotantes, como Number.parseFloat()noNumber.parseInt()
zurfyx
7

Tal vez haya una o dos personas que se encuentren con esta pregunta y necesiten una verificación mucho más estricta de lo habitual (como hice yo). En ese caso, esto podría ser útil:

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

¡Tener cuidado! Esto rechazará cadenas como .1, 40.000, 080, 00.1. Es muy exigente: la cadena debe coincidir con la " forma perfecta más mínima " del número para que pase esta prueba.

Utiliza el constructor Stringy Numberpara convertir la cadena a un número y viceversa y, por lo tanto, comprueba si la "forma mínima perfecta" del motor JavaScript (la que se convirtió con el Numberconstructor inicial ) coincide con la cadena original.


fuente
2
Gracias @JoeRocc. Necesitaba esto también, pero sólo para los números enteros, por lo que añade: (str === String(Math.round(Number(str)))).
keithpjolley
Tenga en cuenta eso "Infinity", "-Infinity"y "NaN"pase esta prueba. Sin embargo, esto se puede solucionar mediante una Number.isFiniteprueba adicional .
GregRos
Esto es exactamente lo mismo que str === ("" + +str). Básicamente verifica si la cadena es el resultado de stringificar un número JS. Sabiendo esto, también podemos ver un problema: la prueba pasa 0.000001pero falla 0.0000001, que es cuando 1e-7pasa. Lo mismo para números muy grandes.
GregRos
5

parseInt (), pero tenga en cuenta que esta función es un poco diferente en el sentido de que, por ejemplo, devuelve 100 para parseInt ("100px").

liggett78
fuente
Y 11 para parseInt(09).
djechlin
10
porque necesitas usarparaseInt(09, 10)
Gavin
1
A partir de ECMAScript 5 , que tiene un amplio soporte de navegador (IE≥9), ya no necesita el , 10argumento. parseInt('09')ahora es igual a 9.
Rory O'Kane
4

Citar:

isNaN (num) // devuelve verdadero si la variable NO contiene un número válido

no es del todo cierto si necesita verificar espacios iniciales / finales - por ejemplo, cuando se requiere una cierta cantidad de dígitos, y necesita obtener, digamos, '1111' y no '111' o '111' para quizás un PIN entrada.

Mejor usar:

var num = /^\d+$/.test(num)
Siubear
fuente
Los valores '-1', '0.1'y '1e10'todas falsas retorno. Además, los valores mayores que el infinito positivo o menores que el infinito negativo devuelven verdadero, mientras que probablemente deberían devolver falso.
Rudey
4

¿Por qué la implementación de jQuery no es lo suficientemente buena?

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

Michael sugirió algo como esto (aunque he robado la versión alterada de "user1691651 - John" aquí):

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

La siguiente es una solución con muy probablemente un mal desempeño, pero resultados sólidos. Es un artilugio hecho a partir de la implementación de jQuery 1.12.4 y la respuesta de Michael, con una verificación adicional para espacios iniciales / finales (porque la versión de Michael devuelve verdadero para los números con espacios iniciales / finales):

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

Sin embargo, la última versión tiene dos nuevas variables. Uno podría evitar uno de esos, haciendo:

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

No he probado mucho de estos, por otros medios que no son los manuales de los pocos casos de uso a los que me enfrentaré con mi situación actual, que es algo muy estándar. Esta es una situación de "pararse sobre los hombros de los gigantes".

Ultroman el Tacoman
fuente
4

No es válido para TypeScript como:

declare function isNaN(number: number): boolean;

Para TypeScript puede usar:

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

Greg Woz
fuente
3

Bueno, estoy usando este que hice ...

Ha estado funcionando hasta ahora:

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

Si encuentra algún problema, dígame, por favor.

Rafael
fuente
12
Esto da el resultado incorrecto para la cadena vacía, la matriz vacía, falso y nulo.
Ori
2
¿No debería ser un triple igual?
toasted_flakes
1
En mi aplicación solo permitimos az AZ y 0-9 caracteres. Descubrí que lo anterior funcionó a menos que la cadena comenzara con 0xnn y luego lo devolvería como numérico cuando no debería haberlo hecho. He publicado un comentario a continuación para que el formato esté intacto.
rwheadon
66
simplemente podría hacer 'valor de retorno% 1 === 0'
Brian Schermerhorn
Just doreturn !isNaN(parseInt(value, 10));
DarkNeuron
3

Si alguien llega tan lejos, pasé algún tiempo pirateando esto tratando de parchar moment.js ( https://github.com/moment/moment ). Aquí hay algo que le quité:

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

Maneja los siguientes casos:

¡Cierto! :

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

Irónicamente, con el que estoy luchando más:

isNumeric(new Number(1)) => false

Cualquier sugerencia bienvenida. :]

El Dembinski
fuente
2
¿Qué hay de isNumeric(' ')y isNumeric('')?
Alex Cory
Yo añadiría && (val.replace(/\s/g,'') !== '') //Empty && (val.slice(-1) !== '.') //Decimal without Numbera fin de adress el problema antes mencionado y que tuve yo.
frankenapps
3

Usando JavaScript simple:

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

Usando Lodash:

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true
Abtin Gramian
fuente
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
fuente
Gracias, gran respuesta!
M.Abulsoud
3

2019: Incluye ejemplos de ES3, ES6 y TypeScript

Tal vez esto se ha repetido muchas veces, sin embargo, luché con este hoy también y quería publicar mi respuesta, ya que no vi ninguna otra respuesta que lo haga de manera simple o 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);

Mecanografiado

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

Esto parece bastante simple y cubre todas las bases que vi en muchas otras publicaciones y pensé:

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

También puede probar su propia isNumericfunción y simplemente pasar en estos casos de uso y buscar "verdadero" para todos ellos.

O, para ver los valores que cada uno devuelve:

Los resultados de cada prueba contra <code> isNumeric () </code>

Jeremy
fuente
3

2019: comprobación de validez numérica práctica y estricta

A menudo, un 'número válido' significa un número Javascript excluyendo NaN e Infinity, es decir, un 'número finito'.

Para verificar la validez numérica de un valor (de una fuente externa, por ejemplo), puede definir en el estilo de 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;
}

y úsalo de esta manera:

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

PFB la solución de trabajo:

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

Ahórrese el dolor de cabeza de tratar de encontrar una solución "incorporada".

No hay una buena respuesta, y la respuesta enormemente votada en este hilo es incorrecta.

npm install is-number

En JavaScript, no siempre es tan sencillo como debería ser verificar de manera confiable si un valor es un número. Es común que los desarrolladores usen +, - o Number () para convertir un valor de cadena en un número (por ejemplo, cuando los valores se devuelven de la entrada del usuario, coincidencias de expresiones regulares, analizadores, etc.). Pero hay muchos casos extremos no intuitivos que producen resultados inesperados:

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

Recientemente escribí un artículo sobre formas de garantizar que una variable sea un número válido: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md. El artículo explica cómo garantizar un punto flotante o un entero, si eso es importante ( +xvs ~~x).

El artículo asume que la variable es a stringo a numberpara empezar y trimestá disponible / polyfilled. No sería difícil extenderlo para manejar otros tipos, también. Aquí está la 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
fuente
1

Mi intento de un poco confuso, quizás no sea la mejor solución

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
Sin fin
fuente
No está tan mal, dos mal, no funciona para ninguna notación no decimal, como (1) notación científica y (2) notación no-base-10, como octal ( 042) y hexadecimal ( 0x45f)
Domi
Esto no responde a la pregunta de buscar un valor numérico, solo busca un int.
Jeremy
0

En mi aplicación solo permitimos az AZ y 0-9 caracteres. Encontré que la respuesta anterior usando " string % 1 === 0" funcionó a menos que la cadena comenzara con 0xnn (como 0x10) y luego la devolvería como numérica cuando no quisiéramos. La siguiente trampa simple en mi verificación numérica parece hacer el truco en nuestros 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;}

Advertencia : Esto podría estar explotando un error de larga data en Javascript y Actionscript [Número ("1" + the_string)% 1 === 0)], no puedo hablar de eso, pero es exactamente lo que necesitábamos.

rwheadon
fuente
¿Por qué sería un error en JavaScript?
Bergi
Simplemente no veo el mismo comportamiento con una solución similar en perl o C, y dado que no soy un desarrollador de lenguaje de programación para javascript o actionscript, no sé si el comportamiento que estoy experimentando es realmente intencional o no.
rwheadon
Bueno, javascript es un poco descuidado sobre la conversión de tipos implícita, pero una vez que sabe que puede comprender fácilmente cómo funciona. Está convirtiendo cadenas en números (al invocar la % 1operación numérica en ellas), y eso interpretará la cadena como un literal hexadecimal o flotante.
Bergi
0

Mi solución:

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

Puede agregar condiciones adicionales dentro del ciclo, para satisfacer sus necesidades particulares.

Ir
fuente
0

Puede utilizar tipos, como con la biblioteca de flujo , para obtener una comprobación de tiempo de compilación estática. Por supuesto, no es terriblemente útil para la entrada del usuario.

// @flow

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

acceptsNumber(42);       // Works!
acceptsNumber(3.14);     // Works!
acceptsNumber(NaN);      // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo");    // Error!
Lo que sería genial
fuente
0

Aquí hay una línea para verificar si sNumes un valor numérico válido; Ha sido probado para una amplia variedad de entradas:

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

Solo use isNaN(), esto convertirá la cadena a un número y si obtiene un número válido , devolverá false...

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

Estoy usando lo siguiente:

const isNumber = s => !isNaN(+s)
haxpanel
fuente
Funciona relativamente bien es muchos casos, pero falla en casos como 1..1, 1,1, -32.1.12, y lo más importante falla undefinedy NaN. Si pasó undefinedo NaNque eso le devolvería un falso positivo diciendo que era un número.
Jeremy