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

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

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
}

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

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

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

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

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.

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

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

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.

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

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)

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

No es válido para TypeScript como:

declare function isNaN(number: number): boolean;

Para TypeScript puede usar:

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

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.

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

Usando JavaScript simple:

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

Usando Lodash:

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

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

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

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

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

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

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

PFB la solución de trabajo:

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

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'

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
}

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

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.

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.

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!

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

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

Estoy usando lo siguiente:

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