Pregunta ¿Hay una forma (incorporada) en JavaScript para verificar si una cadena es un número válido?


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


799
2017-10-06 19:12


origen


Respuestas:


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

Esto funciona independientemente de si la variable contiene una cadena o 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 IsNumeric ejemplo que diste:

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

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

solo funciona si la cadena solamente 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 en 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. 

Flotadores

Tenga en cuenta que, a diferencia +num, parseInt (como su nombre indica) convertirá un flotador en un entero al cortar todo lo que sigue al punto decimal (si desea usar parseInt()  porque este comportamiento, Probablemente es mejor usar otro método en su lugar)

+'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. +num convierte cadenas vacías a cero, y isNaN() asume lo mismo:

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

Pero parseInt() no está de acuerdo:

parseInt('')       // NaN

1667
2017-10-06 19:24



Y podrías ir al RegExp-way:

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
}

35
2017-10-06 19:20



Prueba el 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 número específico Number.isNaN () método.

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

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


21
2017-10-06 19:14



Si realmente desea asegurarse de que una cadena contiene solo un número, cualquier número (entero o punto flotante) y exactamente un número, usted no poder utilizar parseInt()/ parseFloat(), Number(), o !isNaN() por ellos mismos. Tenga en cuenta que !isNaN() en realidad está volviendo true cuando Number() devolvería un número, y false cuando volvería NaN, entonces lo excluiré del resto de la discusión.

El problema con parseFloat() es que devolverá un número si la cadena contiene cualquier número, incluso si la cadena no contiene solamente 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 con 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 el despliegue de su propia expresión regular es que, a menos que cree la expresión regular exacta para hacer coincidir un número de punto flotante, como Javascript lo reconoce, se perderán casos o se reconocerán casos en los que no debería hacerlo. E incluso si puedes sacar 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 saber si una cadena es realmente exactamente y solo un número, llame a ambas funciones y vea si ambos devolver 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))
}

20
2018-03-02 22:56



Si solo está tratando de verificar si una cadena es un número entero (sin decimales), la expresión regular es una buena forma de hacerlo. Otros métodos como isNaN son 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 positivo los números enteros usan esto:

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

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

17
2018-06-27 17:13



Una vieja pregunta, pero faltan varios puntos en las respuestas dadas.

Notación cientifica.

!isNaN('1e+30') es trueSin 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 manera extraña

Observe (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, entonces mejor limite sus cadenas a 15 dígitos como máximo (después de omitir los ceros a la izquierda).

infinito

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

Dado todo eso, verificando que la cadena dada sea un número que satisfaga todo lo siguiente:

  • notación no científica
  • conversión predecible a Number y de vuelta a String
  • 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 ser completo. Los ceros a la izquierda no se manejan aquí, pero se atornillan la prueba de longitud.


10
2017-10-02 11:28



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


5
2017-10-06 19:16



Puedes usar el resultado de Número 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 fue un número válido o no.

Notas: Tenga en cuenta al pasar cadena vacía o '\t\t' y '\n\t' como Number devolverá 0; Pasar true arrojará 1 y devuelve falso 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

5
2018-03-13 09:31



Tal vez hay una o dos personas que se encuentran con esta pregunta que necesitan un mucho más estricto comprobar de lo habitual (como lo hice). 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 delicado, la cadena debe coincidir con el "forma perfecta mínima"del número para que pase esta prueba.

Utiliza el String y Number constructor para convertir la cadena en un número y viceversa, y así verifica si la "forma mínima perfecta" del motor de JavaScript (la que se convirtió con la inicial Number constructor) coincide con la cadena original.


5
2018-01-09 10:57



He probado y la solución de Michael es la mejor. Vota por su respuesta anterior (busca en esta página "Si realmente quieres asegurarte de que haya una cuerda" 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 todos los casos de prueba, que documenté aquí: https://jsfiddle.net/wggehvp9/5/

Muchas de las otras soluciones fallan para estos casos extremos: '', null, "", 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 /, null, "", true, false, [] (y otros?)


5
2018-02-21 00:00



Bueno, estoy usando este que hice ...

Ha estado funcionando hasta ahora:

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

Si detecta algún problema con él, dígame, por favor.


4
2018-03-19 18:56