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

1512

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

7
  • 4
    Vea esta pregunta relacionada , que hice hace algún tiempo. Michael Haren 6/108 a las 19:17
  • 47
    Si va a esta pregunta, intente omitir todas las respuestas RegEx. Esa NO es la manera de hacerlo. Joel Coehoorn 6 de octubre de 2008 a las 19:20
  • 14
    A menos que uno quiera hacer exactamente eso: verificar si una cadena dada tiene un formato de flujo válido de dígitos. Entonces, ¿por qué debería estar mal? SasQ 18 de mayo de 2014 a las 23:53
  • 27
    ¡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 5 oct 2017 a las 20:42
  • 3
    por lo que la respuesta seleccionada es incorrecta, regexp tampoco es la forma de hacerlo. ¿Cuál es el correcto entonces? vir us 9 de mayo de 2020 a las 8:10
2741

2 de octubre de 2020: tenga en cuenta que muchos enfoques básicos están plagados de errores sutiles (por ejemplo, espacios en blanco, análisis parcial implícito, base, coerción de matrices, etc.) que muchas de las respuestas aquí no tienen en cuenta. La siguiente implementación podría funcionar para usted, pero tenga en cuenta que no tiene en cuenta los separadores de números que no sean el punto decimal " .":

function isNumeric(str) {
  if (typeof str != "string") return false // we only process strings!  
  return !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
         !isNaN(parseFloat(str)) // ...and ensure strings of whitespace fail
}

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

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

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

Ejemplos de

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

Por supuesto, puede negar esto si es necesario. 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 de

+'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 de

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 de +num, parseInt(como su nombre indica) convertirá un flotante en un número entero cortando todo lo que sigue al punto decimal (si desea usarlo parseInt() debido a este comportamiento, probablemente sea mejor que use 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 contrarias a la intuición. +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
28
  • 154
    Una nota muy importante sobre parseInt es que le permitirá especificar una base para convertir la cadena en un int. Este es un gran problema, ya que intenta adivinar una base para usted si no la proporciona. Entonces, por ejemplo: parseInt ("17") da como resultado 17 (decimal, 10), pero parseInt ("08") da como resultado 0 (octal, 8). Entonces, a menos que tenga la intención de lo contrario, es más seguro usar parseInt (número, 10), especificando 10 como la base explícitamente. Adam Raney 28/04/09 a las 22:48
  • 43
    Tenga en cuenta que! IsNaN (undefined) devuelve falso. David Hellsing 6 de noviembre de 2010 a las 5:34
  • 142
    Esto es simplemente incorrecto: ¿cómo consiguió tantos votos a favor? No puede utilizar isNaN"Para comprobar 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. Consulte developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… . EML 30 de diciembre de 2013 a las 0:33
  • 57
    La forma más rápida posible de verificar si algo es un número es la verificación "igual a uno mismo": var n = 'a'; if (+n === +n) { // is number }es ~ 3994% más rápido que esNaN en la última versión de Chrome. Vea la prueba de rendimiento aquí: jsperf.com/isnan-vs-typeof/5Kevin Jurkowski 22 de enero de 2014 a las 0:59
  • 27
    ** Advertencia ** Esta respuesta es incorrecta. Úselo bajo su propio riesgo. Ejemplo:isNaN(1 + false + parseInt("1.do you trust your users?"))keithpjolley 31 de mayo de 2017 a las 14:50
110

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 /^-?\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(1234n));          // 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
8
  • 14
    console.log (isNumeric ('- 1')); yongnan 13/11/2014 a las 1:02
  • 6
    console.log (isNumeric ('2e2')); Gaël Barbin 2 mar 15 a las 15:27
  • 19
    Quizás simplemente cambie el nombre de "isNumeric" a "hasOnlyDigits". en muchos casos, ese es exactamente el cheque que está buscando. gus3001 9/10/2017 a las 20:39
  • 2
    Esto es lo que estaba buscando, el equivalente a php ctype_digitMiguel Pynto 20/09/19 a las 11:17
  • 5
    Un poco mejor ... no permitir caracteres numéricos de idiomas como el árabe/^[0-9]+$/.test(value)Devin Rhode 19/10/20 a las 18:53
62

Y podría seguir el camino de RegExp:

var num = "987238";

if(num.match(/^-?\d+$/)){
  //valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
  //valid float
}else{
  //not valid number
}
9
  • 45
    En este caso, RegExp == badJoel Coehoorn 6/108 a las 19:27
  • 10
    Esto falla en números hexadecimales (0x12, por ejemplo), flota sin un cero inicial (.42, por ejemplo) y números negativos. Ori 18/04/12 a las 1:25
  • 20
    @JoelCoehoorn ¿Te importaría explicar por qué RegExp == está mal aquí? Me parece un caso de uso válido. computrius 30/12/14 a las 16:02
  • 7
    Hay más formas de las que parece para 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 precisos, etc.). Además, la expresión regular es más lenta y complicada que simplemente usar los mecanismos incorporadosJoel Coehoorn 30/12/14 a las 18:18
  • 1
    también debe coincidir con la notación científica ... 1e10 etc.Joseph Merdrignac 30 oct 2017 a las 21:45
56

La respuesta aceptada para esta pregunta tiene bastantes defectos (como lo destacaron 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 muestran 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
3
  • 2
    parseFloates insuficiente para esta aplicación porque devolverá un número válido analizado hasta ahora, cuando encuentre el primer carácter que no se puede analizar como un número. p.ej. parseFloat('1.1ea10') === 1.1. Ben Aston 2/10/20 a las 10:35
  • cuidado, si usa Number.isNan y Number.isFinite, esto no funcionará. Yohan Dahmani 2 de julio a las 13:54
  • Para cadenas Number.isNaNy Number.isFiniteno funcionarán porque no lanzarán una cadena a un número. Cas 27 de julio a las 8:49
45

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 cualquier 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 de rodar 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, ya que Javascript lo reconoce, perderá casos o reconocerá casos en los que no debería hacerlo. E incluso si puede rodar su propia expresión regular, ¿por qué? Hay formas integradas más sencillas de hacerlo.

Sin embargo, resulta que Number()(y isNaN()) hace lo correcto en todos los casos en los que parseFloat()devuelve un número cuando no debería, y viceversa. Entonces, para averiguar si una cadena es realmente exactamente 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))
}
4
  • 2
    Esto devuelve verdadero cuando la cadena tiene espacios iniciales o finales. ' 1', '2 'y ' 3 'todos vuelven verdaderos. Rudey 22/0217 a las 20:07
  • Agregar algo como esto a la declaración de retorno resolvería que: &&! / ^ \ S + | \ s + $ / g.test (str)Ultroman the Tacoman 15 de mayo de 2017 a las 13:07
  • 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 los espacios adicionales en muchas interfaces. Ian 3 de nov. De 2017 a las 19:34
  • 6
    Eso es cierto en caso de que la cadena de números provenga de la entrada del usuario. Pero pensé que debería mencionar los espacios de todos modos, porque creo que la mayoría de las personas que necesitan una isNumberfunción no están lidiando con interfaces de usuario. Además, una buena entrada numérica no permitirá que los espacios comiencen con. Rudey 4/11/2017 a las 21:25
23

Prueba la función isNan :

The isNaN() function determines whether a value is an illegal number (Not-a-Number).

This function returns true if the value equates to NaN. Otherwise it returns false.

This function is different from the Number specific Number.isNaN() method.

  The global isNaN() function, converts the tested value to a Number, then tests it.

Number.isNan() does not convert the values to a Number, and will not return true for any value that is not of the type Number...

5
  • 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 6/108 a las 19:44
  • 3
    isFinite es un mejor control: se trata del extraño caso de la esquina de InfinityJonnyRaa 20 de enero de 2015 a las 12:02
  • 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 2 mar 16 a las 22:13
  • 2
    ADVERTENCIA: No funciona para los valores: nulo, "" (cadena vacía) y falso. Krisztián Balla 27 de julio de 2017 a las 8:02
  • Me doy cuenta de que esta respuesta se dio hace 11 años y unos minutos antes de la aceptada, pero nos guste o no, la respuesta aceptada tiene MUCHO más conversación al respecto, 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 Disciplinada si haces eso. Dan Dascalescu 6/10/19 a las 6:15
17

Pregunta antigua, 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 la gente pregunta por los números, que no quieren que relacione lo como 1e+30.

Los números flotantes grandes 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 es mejor limitar 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, verificar que la cadena dada sea un número que satisfaga todo lo siguiente:

  • notación no científica
  • conversión predecible ay de Numberregreso 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 ser completo. Los ceros iniciales no se manejan aquí, pero atornillan la prueba de longitud.

1
  • 2
    "sin embargo, en la mayoría de los casos, cuando las personas piden números, no quieren coincidir con 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 4 de ene. De 2017 a las 17:42
15

Lo he probado y la solución de Michael es la mejor. Vote por su respuesta anterior (busque en esta página "Si realmente desea asegurarse de que haya 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 todos los casos 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 un manejo adecuado de errores, por ejemplo:

return !isNaN(num);

o

return (+num === +num);

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

2
  • 1
    Esto todavía devuelve verdadero con espacios finales / iniciales. Agregar algo como esto a la declaración de retorno resolvería que: &&! / ^ \ S + | \ s + $ / g.test (str)Ultroman the Tacoman 15 de mayo de 2017 a las 13:13
  • 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 quedar a criterio del desarrollador si los espacios iniciales o finales deben cambiar el valor. JohnP2 14 de junio de 2017 a las 19:10
10

Puede utilizar 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 era un número válido o no.

Notas: Tenga en cuenta 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
2
  • El Numberconstructor es exactamente el mismo que +x. GregRos 28/12/18 a las 21:56
  • Como nota al margen, tenga en cuenta que el ES6 también Number()maneja números flotantes, como Number.parseFloat()noNumber.parseInt()zurfyx 20/01/20 a las 20:27
10

Tal vez haya una o dos personas que se encuentren con esta pregunta y que necesiten un control mucho más estricto de lo habitual (como lo 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 delicado: la cadena debe coincidir con la " forma mínima perfecta " del número para que se apruebe esta prueba.

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

4
  • 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 31 de mayo de 2017 a las 14:43
  • Tenga en cuenta eso "Infinity", "-Infinity"y "NaN"pase esta prueba. Sin embargo, esto se puede solucionar mediante una Number.isFiniteprueba adicional . GregRos 28/12/18 a las 21:53
  • 1
    Esto es exactamente lo mismo que str === ("" + +str). Básicamente, verifica si la cadena es el resultado de la cadena de 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 28/12/18 a las 22:19
  • Esta respuesta es incorrecta. 1e10es "perfectamente válido y formateado" y, sin embargo, falla este algoritmo. Ben Aston 2/10/20 a las 10:52
10

2019: incluidos ejemplos de ES3, ES6 y TypeScript

Tal vez esto se haya repetido demasiadas 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 las muchas otras publicaciones y pensé yo mismo:

// 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 devuelve cada uno:

Resultados de cada prueba contra <code> isNumeric () </code>

3
  • 1
    bueno, excepto por ejemplo para '0x10' (¡devuelve verdadero!)S.Serpooshan 8 de marzo a las 18:45
  • @ S.Serpooshan, 0x10 debería devolver verdadero, es un número hexadecimal. 0x1 se muestra en los casos de prueba y se espera que devuelva verdadero, es un número. Si su caso de uso específico requiere que los números hexadecimales se traten como una cadena, deberá escribir la solución de manera un poco diferente. Jeremy 26 abr a las 21:39
  • Sí, depende de nuestro escenarioS.Serpooshan 29 abr a las 10:22
6

¿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 probablemente un mal rendimiento, pero con 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 los 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 sortear 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 ninguno de estos mucho, por otros medios que no sea probando manualmente los pocos casos de uso que enfrentaré con mi situación actual, que es todo muy estándar. Esta es una situación de "estar sobre los hombros de gigantes".

6

2019: control de validez numérico práctico y estricto

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

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

y utilícelo de esta manera:

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}
1
  • Excelente. ¡Gracias! 👋GollyJer 26/07/20 a las 17:41
5

No es válido para TypeScript como:

declare function isNaN(number: number): boolean;

Para TypeScript puede usar:

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

1
  • /^\d+$/.test("-1") // falsePara el uso isNaNcon los no números en TS, sólo puede convertir el valor a any, o uso una de las otras soluciones más completas aquí que hacer uso de Number, parseFloat, etc.John Montgomery 13/07/20 a las 17:51
4

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

3
4

Cita:

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

no es del todo cierto si necesita verificar los 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 tal vez un PIN aporte.

Mejor usar:

var num = /^\d+$/.test(num)
1
  • 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 22/02/2017 a las 20:11
4

Al protegerse contra cuerdas vacías y null

// Base cases that are handled properly
Number.isNaN(Number('1')); // => false
Number.isNaN(Number('-1')); // => false
Number.isNaN(Number('1.1')); // => false
Number.isNaN(Number('-1.1')); // => false
Number.isNaN(Number('asdf')); // => true
Number.isNaN(Number(undefined)); // => true

// Special notation cases that are handled properly
Number.isNaN(Number('1e1')); // => false
Number.isNaN(Number('1e-1')); // => false
Number.isNaN(Number('-1e1')); // => false
Number.isNaN(Number('-1e-1')); // => false
Number.isNaN(Number('0b1')); // => false
Number.isNaN(Number('0o1')); // => false
Number.isNaN(Number('0xa')); // => false

// Edge cases that will FAIL if not guarded against
Number.isNaN(Number('')); // => false
Number.isNaN(Number(' ')); // => false
Number.isNaN(Number(null)); // => false

// Edge cases that are debatable
Number.isNaN(Number('-0b1')); // => true
Number.isNaN(Number('-0o1')); // => true
Number.isNaN(Number('-0xa')); // => true
Number.isNaN(Number('Infinity')); // => false 
Number.isNaN(Number('INFINITY')); // => true  
Number.isNaN(Number('-Infinity')); // => false 
Number.isNaN(Number('-INFINITY')); // => true  

Cuando NO protege contra cadenas vacías y null

Utilizando parseInt:

// Base cases that are handled properly
Number.isNaN(parseInt('1')); // => false
Number.isNaN(parseInt('-1')); // => false
Number.isNaN(parseInt('1.1')); // => false
Number.isNaN(parseInt('-1.1')); // => false
Number.isNaN(parseInt('asdf')); // => true
Number.isNaN(parseInt(undefined)); // => true
Number.isNaN(parseInt('')); // => true
Number.isNaN(parseInt(' ')); // => true
Number.isNaN(parseInt(null)); // => true

// Special notation cases that are handled properly
Number.isNaN(parseInt('1e1')); // => false
Number.isNaN(parseInt('1e-1')); // => false
Number.isNaN(parseInt('-1e1')); // => false
Number.isNaN(parseInt('-1e-1')); // => false
Number.isNaN(parseInt('0b1')); // => false
Number.isNaN(parseInt('0o1')); // => false
Number.isNaN(parseInt('0xa')); // => false

// Edge cases that are debatable
Number.isNaN(parseInt('-0b1')); // => false
Number.isNaN(parseInt('-0o1')); // => false
Number.isNaN(parseInt('-0xa')); // => false
Number.isNaN(parseInt('Infinity')); // => true 
Number.isNaN(parseInt('INFINITY')); // => true  
Number.isNaN(parseInt('-Infinity')); // => true 
Number.isNaN(parseInt('-INFINITY')); // => true 

Utilizando parseFloat:

// Base cases that are handled properly
Number.isNaN(parseFloat('1')); // => false
Number.isNaN(parseFloat('-1')); // => false
Number.isNaN(parseFloat('1.1')); // => false
Number.isNaN(parseFloat('-1.1')); // => false
Number.isNaN(parseFloat('asdf')); // => true
Number.isNaN(parseFloat(undefined)); // => true
Number.isNaN(parseFloat('')); // => true
Number.isNaN(parseFloat(' ')); // => true
Number.isNaN(parseFloat(null)); // => true

// Special notation cases that are handled properly
Number.isNaN(parseFloat('1e1')); // => false
Number.isNaN(parseFloat('1e-1')); // => false
Number.isNaN(parseFloat('-1e1')); // => false
Number.isNaN(parseFloat('-1e-1')); // => false
Number.isNaN(parseFloat('0b1')); // => false
Number.isNaN(parseFloat('0o1')); // => false
Number.isNaN(parseFloat('0xa')); // => false

// Edge cases that are debatable
Number.isNaN(parseFloat('-0b1')); // => false
Number.isNaN(parseFloat('-0o1')); // => false
Number.isNaN(parseFloat('-0xa')); // => false
Number.isNaN(parseFloat('Infinity')); // => false 
Number.isNaN(parseFloat('INFINITY')); // => true  
Number.isNaN(parseFloat('-Infinity')); // => false 
Number.isNaN(parseFloat('-INFINITY')); // => true

Notas:

  • Solo los valores de cadena, vacíos y no inicializados se consideran de acuerdo con el tratamiento de la pregunta original. Existen casos extremos adicionales si las matrices y los objetos son los valores que se están considerando.
  • Los caracteres en notación binaria, octal, hexadecimal y exponencial no distinguen entre mayúsculas y minúsculas (es decir: '0xFF', '0XFF', '0xfF', etc., darán el mismo resultado en los casos de prueba que se muestran arriba).
  • A diferencia de Infinity(distingue entre mayúsculas y minúsculas) en algunos casos, se determinará que las constantes de los objetos Numbery Mathpasados ​​como casos de prueba en formato de cadena a cualquiera de los métodos anteriores no son números.
  • Consulte aquí para obtener una explicación de cómo los argumentos se convierten en a Numbery por qué nullexisten los casos extremos y las cadenas vacías.
3
  • Consulte también stackoverflow.com/questions/46677774/…Philip 13/03/20 a las 17:26
  • falla "", null, undefinedygman 12 de enero a las 5:36
  • @gman gracias por señalar los casos extremos. Actualicé la respuesta para abordar los que mencionaste, así como Infinityy "Infinity". También parece que undefinedya se maneja correctamente, pero lo agregué explícitamente para dejarlo en claro. Abtin Gramian 16 de enero a las 4:41
3

Si alguien llega tan abajo, pasé un tiempo pirateando esto tratando de parchear moment.js ( https://github.com/moment/moment ). Aquí hay algo que saqué de él:

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 más estoy luchando:

isNumeric(new Number(1)) => false

Cualquier sugerencia bienvenida. :]

2
  • 2
    ¿Qué pasa con isNumeric(' ')y isNumeric('')? Alex Cory 31 de enero de 2017 a las 4:00
  • 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 15 de enero de 2018 a las 19:08
3

Recientemente escribí un artículo sobre formas de asegurar 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 asegurar el punto flotante o entero, si eso es importante ( +xvs ~~x).

Para empezar, el artículo asume que la variable es a stringo numbera y trimestá disponible / polietileno. No sería difícil extenderlo para manejar otros tipos también. Aquí está el meollo de la cuestión:

// 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
}
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 ...
}
1
  • ¡Gracias, gran respuesta! M.Abulsoud 27/03/19 a las 16:43
3

Bueno, estoy usando este que hice ...

Ha estado funcionando hasta ahora:

function checkNumber(value) {
    return value % 1 == 0;
}

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

5
  • 18
    Esto da un resultado incorrecto para la cadena vacía, la matriz vacía, falso y nulo. Ori 18/04/12 a las 1:23
  • 2
    ¿No debería ser triple igual? toasted_flakes 9 de mayo de 13 a las 15:44
  • 1
    En mi aplicación solo permitimos az AZ y 0-9 caracteres. Encontré que lo anterior funcionó a menos que la cadena comenzara con 0xnn y luego la devolvería como numérica cuando no debería haberlo hecho. Publiqué en un comentario a continuación para que el formato esté intacto. rwheadon 8 de julio de 2014 a las 15:10
  • 7
    podría simplemente hacer 'valor de retorno% 1 === 0'Brian Schermerhorn 10/07/2015 a las 21:42
  • Solo hazloreturn !isNaN(parseInt(value, 10)); ... DarkNeuron 25/10/19 a las 13:45
3

Comprobando el número en JS:

  1. La mejor forma de comprobar si es un número:

    isFinite(20)
    //True
    
  2. Leer un valor de una cadena. CSS *:

    parseInt('2.5rem')
    //2
    parseFloat('2.5rem')
    //2.5  
    
  3. Para un entero:

    isInteger(23 / 0)
    //False
    
  4. Si el valor es NaN:

    isNaN(20)
    //False
    
1
  • ¿Qué tal un BigInt? Es mejor escribir en Infinitylugar de dividir por cero para mejorar la legibilidad, pero tal vez ese sea yo. A1rPun 24 de mayo a las 13:46
2

PFB la solución de trabajo:

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

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

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

npm install is-number

In JavaScript, it's not always as straightforward as it should be to reliably check if a value is a number. It's common for devs to use +, -, or Number() to cast a string value to a number (for example, when values are returned from user input, regex matches, parsers, etc). But there are many non-intuitive edge cases that yield unexpected results:

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

Esto se basa en algunas de las respuestas y comentarios anteriores. Lo siguiente cubre todos los casos extremos y también es bastante conciso:

const isNumRegEx = /^-?(\d*\.)?\d+$/;

function isNumeric(n, allowScientificNotation = false) {
    return allowScientificNotation ? 
                !Number.isNaN(parseFloat(n)) && Number.isFinite(n) :
                isNumRegEx.test(n);
}
2

Esto parece captar el número aparentemente infinito de casos extremos:

function isNumber(x, noStr) {
    /*

        - Returns true if x is either a finite number type or a string containing only a number
        - If empty string supplied, fall back to explicit false
        - Pass true for noStr to return false when typeof x is "string", off by default

        isNumber(); // false
        isNumber([]); // false
        isNumber([1]); // false
        isNumber([1,2]); // false
        isNumber(''); // false
        isNumber(null); // false
        isNumber({}); // false
        isNumber(true); // false
        isNumber('true'); // false
        isNumber('false'); // false
        isNumber('123asdf'); // false
        isNumber('123.asdf'); // false
        isNumber(undefined); // false
        isNumber(Number.POSITIVE_INFINITY); // false
        isNumber(Number.NEGATIVE_INFINITY); // false
        isNumber('Infinity'); // false
        isNumber('-Infinity'); // false
        isNumber(Number.NaN); // false
        isNumber(new Date('December 17, 1995 03:24:00')); // false
        isNumber(0); // true
        isNumber('0'); // true
        isNumber(123); // true
        isNumber(123.456); // true
        isNumber(-123.456); // true
        isNumber(-.123456); // true
        isNumber('123'); // true
        isNumber('123.456'); // true
        isNumber('.123'); // true
        isNumber(.123); // true
        isNumber(Number.MAX_SAFE_INTEGER); // true
        isNumber(Number.MAX_VALUE); // true
        isNumber(Number.MIN_VALUE); // true
        isNumber(new Number(123)); // true
    */

    return (
        (typeof x === 'number' || x instanceof Number || (!noStr && x && typeof x === 'string' && !isNaN(x))) &&
        isFinite(x)
    ) || false;
};
2

Por lo tanto, dependerá de los casos de prueba que desee que maneje.

function isNumeric(number) {
  return !isNaN(parseFloat(number)) && !isNaN(+number);
}

Lo que estaba buscando eran tipos regulares de números en javascript. 0, 1 , -1, 1.1 , -1.1 , 1E1 , -1E1 , 1e1 , -1e1, 0.1e10, -0.1.e10 , 0xAF1 , 0o172, Math.PI, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY

Y también son representaciones como cadenas:
'0', '1', '-1', '1.1', '-1.1', '1E1', '-1E1', '1e1', '-1e1', '0.1e10', '-0.1.e10', '0xAF1', '0o172'

Quería omitirlos y no marcarlos como numéricos. '', ' ', [], {}, null, undefined, NaN

A partir de hoy, todas las demás respuestas parecían fallar en uno de estos casos de prueba.

1
  • Tenga en cuenta que isNumeric('007')devuelve trueen caso de que le importeepan 17 de junio a las 19:46
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
2
  • No es tan malo, 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 29 de abril de 2017 a las 8:58
  • Esto no responde a la pregunta de buscar un valor numérico, solo busca un int. Jeremy 25/10/19 a las 21:53
1

Usé esta función como una herramienta de validación de formularios y no quería que los usuarios pudieran escribir funciones exponenciales, así que se me ocurrió esta función:

<script>

    function isNumber(value, acceptScientificNotation) {

        if(true !== acceptScientificNotation){
            return /^-{0,1}\d+(\.\d+)?$/.test(value);
        }

        if (true === Array.isArray(value)) {
            return false;
        }
        return !isNaN(parseInt(value, 10));
    }


    console.log(isNumber(""));              // false
    console.log(isNumber(false));           // false
    console.log(isNumber(true));            // false
    console.log(isNumber("0"));             // true
    console.log(isNumber("0.1"));           // true
    console.log(isNumber("12"));            // true
    console.log(isNumber("-12"));           // true
    console.log(isNumber(-45));             // true
    console.log(isNumber({jo: "pi"}));      // false
    console.log(isNumber([]));              // false
    console.log(isNumber([78, 79]));        // false
    console.log(isNumber(NaN));             // false
    console.log(isNumber(Infinity));        // false
    console.log(isNumber(undefined));       // false
    console.log(isNumber("0,1"));           // false



    console.log(isNumber("1e-1"));          // false
    console.log(isNumber("1e-1", true));    // true
</script>
1

TL; DR

Depende en gran medida de lo que desee analizar como número.

Comparación entre funciones integradas

Como ninguna de las fuentes existentes satisfizo mi alma, traté de averiguar qué estaba sucediendo realmente con estas funciones.

Tres respuestas inmediatas a esta pregunta se sintieron como:

  1. !isNaN(input)(que da el mismo resultado que +input === +input)
  2. !isNaN(parseFloat(input))
  3. isFinite(input)

Pero, ¿alguno de ellos es correcto en todos los escenarios?

Probé estas funciones en varios casos y generé resultados como rebajas. Esto es lo que parece:

input !isNaN(input) o
+input===+input
!isNaN(
parseFloat(
input))
isFinite(
input)
Comentario
123 ✔️ ✔️ ✔️ -
'123' ✔️ ✔️ ✔️ -
12,3 ✔️ ✔️ ✔️ -
'12 .3 ' ✔️ ✔️ ✔️ -
"12,3" ✔️ ✔️ ✔️ Espacio en blanco vacío recortado, como se esperaba.
1_000_000 ✔️ ✔️ ✔️ Separador numérico comprendido, también esperado.
'1_000_000' ✔️ ¡Sorpresa! JS simplemente no analizará el separador numérico dentro de una cadena. Para obtener más detalles, consulte este problema. (¿Por qué entonces el análisis como flotante funcionó? Bueno, no funcionó. 😉)
'0b11111111' ✔️ ✔️ ✔️ Forma binaria entendida, como debería haberlo hecho.
'0o377' ✔️ ✔️ ✔️ La forma octal también se entiende.
'0xFF' ✔️ ✔️ ✔️ Por supuesto que se entiende hexadecimal. ¿Alguien pensó lo contrario? 😒
'' ✔️ ✔️ ¿Debería ser un número una cadena vacía?
'' ✔️ ✔️ ¿Una cadena de solo espacios en blanco debería ser un número?
'a B C' Todos están de acuerdo, no un número.
'12 .34Ab! @ # $ ' ✔️ ¡Ah! Ahora es bastante comprensible lo que parseFloat()hace. No me impresiona, pero puede resultar útil en ciertos casos.
'10e100' ✔️ ✔️ ✔️ 10 100 es un número de hecho.
¡Pero cuidado! Es mucho más grande que el valor entero seguro máximo 2 53 (aproximadamente 9 × 10 15 ). Lea esto para más detalles.
'10e1000' ✔️ ✔️ ¡Di conmigo, ayuda!
Aunque no tan loco como parece. En JavaScript, un valor mayor que ~ 10 308 se redondea al infinito, por eso. Busque aquí los detalles.
Y sí, isNaN()considera el infinito como un número y parseFloat()analiza el infinito como infinito.
nulo ✔️ ✔️ Ahora bien, esto es incómodo. En JS, cuando se necesita una conversión, nulo se convierte en cero y obtenemos un número finito.
Entonces, ¿por qué parseFloat(null)debería devolver un NaNaquí? Alguien, por favor, explíqueme este concepto de diseño.
indefinido Como se esperaba.
infinito ✔️ ✔️ Como se explicó anteriormente, isNaN()considera el infinito como un número y parseFloat()analiza el infinito como infinito.

Entonces ... ¿cuál de ellos es "correcto"?

Debería estar claro a estas alturas, depende en gran medida de lo que necesitemos . Por ejemplo, es posible que queramos considerar una entrada nula como 0. En ese caso isFinite(), funcionará bien.

Nuevamente, tal vez necesitemos un poco de ayuda de isNaN()cuando se necesita 10 10000000000 para ser considerado un número válido (aunque la pregunta sigue siendo: ¿por qué lo sería y cómo lo manejaríamos?).

Por supuesto, podemos excluir manualmente cualquiera de los escenarios.

Como en mi caso, necesitaba exactamente las salidas de isFinite(), excepto el caso nulo, el caso de cadena vacía y el caso de cadena de solo espacios en blanco. Además, no tuve ningún dolor de cabeza por los números realmente grandes . Entonces mi código se veía así:

/**
 * My necessity was met by the following code.
 */

if (input === null) {
    // Null input
} else if (input.trim() === '') {
    // Empty or whitespace-only string
} else if (isFinite(input)) {
    // Input is a number
} else {
    // Not a number
}

Y también, este era mi JavaScript para generar la tabla:

/**
 * Note: JavaScript does not print numeric separator inside a number.
 * In that single case, the markdown output was manually corrected.
 * Also, the comments were manually added later, of course.
 */

let inputs = [
    123, '123', 12.3, '12.3', '   12.3   ',
    1_000_000, '1_000_000',
    '0b11111111', '0o377', '0xFF',
    '', '    ',
    'abc', '[email protected]#$',
    '10e100', '10e1000',
    null, undefined, Infinity];

let markdownOutput = `| \`input\` | \`!isNaN(input)\` or <br>\`+input === +input\` | \`!isNaN(parseFloat(input))\` | \`isFinite(input)\` | Comment |
| :---: | :---: | :---: | :---: | :--- |\n`;

for (let input of inputs) {
    let outputs = [];
    outputs.push(!isNaN(input));
    outputs.push(!isNaN(parseFloat(input)));
    outputs.push(isFinite(input));

    if (typeof input === 'string') {
        // Output with quotations
        console.log(`'${input}'`);
        markdownOutput += `| '${input}'`;
    } else {
        // Output without quotes
        console.log(input);
        markdownOutput += `| ${input}`;
    }

    for (let output of outputs) {
        console.log('\t' + output);
        if (output === true) {
            markdownOutput += ` | <div style="color:limegreen">true</div>`;
            // markdownOutput += ` | ✔️`; // for stackoverflow
        } else {
            markdownOutput += ` | <div style="color:orangered">false</div>`;
            // markdownOutput += ` | ❌`; // for stackoverflow
        }
    }

    markdownOutput += ` ||\n`;
}

// Replace two or more whitespaces with $nbsp;
markdownOutput = markdownOutput.replaceAll(`  `, `&nbsp;&nbsp;`);

// Print markdown to console
console.log(markdownOutput);