¿Compruebe si el carácter es un número?

Necesito comprobar si justPrices[i].substr(commapos+2,1).

La cadena es algo como: "blabla, 120"

En este caso, verificaría si '0' es un número. ¿Cómo se puede hacer esto?

Puede usar operadores de comparación para ver si está en el rango de caracteres de dígitos:

var c = justPrices[i].substr(commapos+2,1);
if (c >= '0' && c <= '9') {
    // it is a number
} else {
    // it isn't
}

puede usar parseInty luego consultar conisNaN

o si desea trabajar directamente en su cadena, puede usar regexp como este:

function is_numeric(str){
    return /^\d+$/.test(str);
}

EDITAR: La respuesta actualizada de Blender es la respuesta correcta aquí si solo está verificando un solo carácter (es decir !isNaN(parseInt(c, 10))). Mi respuesta a continuación es una buena solución si desea probar cadenas completas.

Aquí está la isNumericimplementación de jQuery (en JavaScript puro), que funciona con cadenas completas :

function isNumeric(s) {
    return !isNaN(s - parseFloat(s));
}

El comentario de esta función dice:

// parseFloat NaNs falsos positivos de conversión numérica (nulo | verdadero | falso | "")
// ... pero malinterpreta las cadenas de números iniciales, particularmente los literales hexadecimales ("0x ...")
// la resta fuerza los infinitos a NaN

¡Creo que podemos confiar en que estos muchachos han dedicado bastante tiempo a esto!

Fuente comentada aquí . Discusión súper geek aquí .

Me pregunto por qué nadie ha publicado una solución como:

var charCodeZero = "0".charCodeAt(0);
var charCodeNine = "9".charCodeAt(0);

function isDigitCode(n) {
   return(n >= charCodeZero && n <= charCodeNine);
}

con una invocación como:

if (isDigitCode(justPrices[i].charCodeAt(commapos+2))) {
    ... // digit
} else {
    ... // not a digit
}

Puedes usar esto:

function isDigit(n) {
    return Boolean([true, true, true, true, true, true, true, true, true, true][n]);
}

Aquí, lo comparé con el método aceptado: http://jsperf.com/isdigittest/5 . No esperaba mucho, así que me sorprendió bastante cuando descubrí que el método aceptado era mucho más lento.

Lo interesante es que, si bien el método aceptado es una entrada correcta más rápida (por ejemplo, '5') y más lento para incorrecto (por ejemplo, 'a'), mi método es exactamente lo contrario (rápido para incorrecto y más lento para correcto).

Aún así, en el peor de los casos, mi método es 2 veces más rápido que la solución aceptada para la entrada correcta y más de 5 veces más rápido para la entrada incorrecta.

Creo que es muy divertido encontrar formas de resolver esto. A continuación se muestran algunos.
(Todas las funciones siguientes asumen que el argumento es un solo carácter. Cambie a n[0]para aplicarlo)

Método 1:

function isCharDigit(n){
  return !!n.trim() && n > -1;
}

Método 2:

function isCharDigit(n){
  return !!n.trim() && n*0==0;
}

Método 3:

function isCharDigit(n){
  return !!n.trim() && !!Number(n+.1); // "+.1' to make it work with "." and "0" Chars
}

Método 4:

var isCharDigit = (function(){
  var a = [1,1,1,1,1,1,1,1,1,1];
  return function(n){
    return !!a[n] // check if `a` Array has anything in index 'n'. Cast result to boolean
  }
})();

Método 5:

function isCharDigit(n){
  return !!n.trim() && !isNaN(+n);
}

Cadena de prueba:

var str = ' 90ABcd#?:.+', char;
for( char of str ) 
  console.log( char, isCharDigit(char) );

Función simple

function isCharNumber(c){
    return c >= '0' && c <= '9';
}

Si está probando caracteres individuales, entonces:

var isDigit = (function() {
    var re = /^\d$/;
    return function(c) {
        return re.test(c);
    }
}());

devolverá verdadero o falso dependiendo de si c es un dígito o no.

Sugiero una expresión regular simple.

Si está buscando solo el último carácter de la cadena:

/^.*?[0-9]$/.test("blabla,120");  // true
/^.*?[0-9]$/.test("blabla,120a"); // false
/^.*?[0-9]$/.test("120");         // true
/^.*?[0-9]$/.test(120);           // true
/^.*?[0-9]$/.test(undefined);     // false
/^.*?[0-9]$/.test(-1);            // true
/^.*?[0-9]$/.test("-1");          // true
/^.*?[0-9]$/.test(false);         // false
/^.*?[0-9]$/.test(true);          // false

Y la expresión regular es aún más simple si solo está verificando un solo carácter como entrada:

var char = "0";
/^[0-9]$/.test(char);             // true

La solución más corta es:

const isCharDigit = n => n < 10;

También puede aplicar estos:

const isCharDigit = n => Boolean(++n);

const isCharDigit = n => '/' < n && n < ':';

const isCharDigit = n => !!++n;

si desea verificar más de 1 personaje, puede usar las siguientes variantes

Expresión regular:

const isDigit = n => /\d+/.test(n);

Comparación:

const isDigit = n => +n == n;

Comprueba si no es NaN

const isDigit = n => !isNaN(n);

var Is = {
    character: {
        number: (function() {
            // Only computed once
            var zero = "0".charCodeAt(0), nine = "9".charCodeAt(0);

            return function(c) {
                return (c = c.charCodeAt(0)) >= zero && c <= nine;
            }
        })()
    }
};

isNumber = function(obj, strict) {
    var strict = strict === true ? true : false;
    if (strict) {
        return !isNaN(obj) && obj instanceof Number ? true : false;
    } else {
        return !isNaN(obj - parseFloat(obj));
    }
}

salida sin modo estricto:

var num = 14;
var textnum = '14';
var text = 'yo';
var nan = NaN;

isNumber(num);
isNumber(textnum);
isNumber(text);
isNumber(nan);

true
true
false
false

salida con modo estricto:

var num = 14;
var textnum = '14';
var text = 'yo';
var nan = NaN;

isNumber(num, true);
isNumber(textnum, true);
isNumber(text, true);
isNumber(nan);

true
false
false
false

Tratar:

function is_numeric(str){
        try {
           return isFinite(str)
        }
        catch(err) {
            return false
        }
    }

Esto parece funcionar:

Enlace estático:

String.isNumeric = function (value) {
    return !isNaN(String(value) * 1);
};

Encuadernación de prototipos:

String.prototype.isNumeric = function () {
    return !isNaN(this.valueOf() * 1);
};

Verificará caracteres individuales, así como cadenas completas para ver si son numéricos.

square = function(a) {
    if ((a * 0) == 0) {
        return a*a;
    } else {
        return "Enter a valid number.";
    }
}

Fuente

function is_numeric(mixed_var) {
    return (typeof(mixed_var) === 'number' || typeof(mixed_var) === 'string') &&
        mixed_var !== '' && !isNaN(mixed_var);
}

Código fuente

Puedes probar esto (funcionó en mi caso)

Si desea probar si el primer carácter de una cadena es un int:

if (parseInt(YOUR_STRING.slice(0, 1))) {
    alert("first char is int")
} else {
    alert("first char is not int")
}

Si desea probar si el carácter es un int:

if (parseInt(YOUR_CHAR)) {
    alert("first char is int")
} else {
    alert("first char is not int")
}

Esta función funciona para todos los casos de prueba que pude encontrar. También es más rápido que:

function isNumeric (n) {
  if (!isNaN(parseFloat(n)) && isFinite(n) && !hasLeading0s(n)) {
    return true;
  }
  var _n = +n;
  return _n === Infinity || _n === -Infinity;
}

var isIntegerTest = /^\d+$/;
var isDigitArray = [!0, !0, !0, !0, !0, !0, !0, !0, !0, !0];

function hasLeading0s(s) {
  return !(typeof s !== 'string' ||
    s.length < 2 ||
    s[0] !== '0' ||
    !isDigitArray[s[1]] ||
    isIntegerTest.test(s));
}
var isWhiteSpaceTest = /\s/;

function fIsNaN(n) {
  return !(n <= 0) && !(n > 0);
}

function isNumber(s) {
  var t = typeof s;
  if (t === 'number') {
    return (s <= 0) || (s > 0);
  } else if (t === 'string') {
    var n = +s;
    return !(fIsNaN(n) || hasLeading0s(s) || !(n !== 0 || !(s === '' || isWhiteSpaceTest.test(s))));
  } else if (t === 'object') {
    return !(!(s instanceof Number) || fIsNaN(+s));
  }
  return false;
}

function testRunner(IsNumeric) {
  var total = 0;
  var passed = 0;
  var failedTests = [];

  function test(value, result) {
    total++;
    if (IsNumeric(value) === result) {
      passed++;
    } else {
      failedTests.push({
        value: value,
        expected: result
      });
    }
  }
  // true
  test(0, true);
  test(1, true);
  test(-1, true);
  test(Infinity, true);
  test('Infinity', true);
  test(-Infinity, true);
  test('-Infinity', true);
  test(1.1, true);
  test(-0.12e-34, true);
  test(8e5, true);
  test('1', true);
  test('0', true);
  test('-1', true);
  test('1.1', true);
  test('11.112', true);
  test('.1', true);
  test('.12e34', true);
  test('-.12e34', true);
  test('.12e-34', true);
  test('-.12e-34', true);
  test('8e5', true);
  test('0x89f', true);
  test('00', true);
  test('01', true);
  test('10', true);
  test('0e1', true);
  test('0e01', true);
  test('.0', true);
  test('0.', true);
  test('.0e1', true);
  test('0.e1', true);
  test('0.e00', true);
  test('0xf', true);
  test('0Xf', true);
  test(Date.now(), true);
  test(new Number(0), true);
  test(new Number(1e3), true);
  test(new Number(0.1234), true);
  test(new Number(Infinity), true);
  test(new Number(-Infinity), true);
  // false
  test('', false);
  test(' ', false);
  test(false, false);
  test('false', false);
  test(true, false);
  test('true', false);
  test('99,999', false);
  test('#abcdef', false);
  test('1.2.3', false);
  test('blah', false);
  test('\t\t', false);
  test('\n\r', false);
  test('\r', false);
  test(NaN, false);
  test('NaN', false);
  test(null, false);
  test('null', false);
  test(new Date(), false);
  test({}, false);
  test([], false);
  test(new Int8Array(), false);
  test(new Uint8Array(), false);
  test(new Uint8ClampedArray(), false);
  test(new Int16Array(), false);
  test(new Uint16Array(), false);
  test(new Int32Array(), false);
  test(new Uint32Array(), false);
  test(new BigInt64Array(), false);
  test(new BigUint64Array(), false);
  test(new Float32Array(), false);
  test(new Float64Array(), false);
  test('.e0', false);
  test('.', false);
  test('00e1', false);
  test('01e1', false);
  test('00.0', false);
  test('01.05', false);
  test('00x0', false);
  test(new Number(NaN), false);
  test(new Number('abc'), false);
  console.log('Passed ' + passed + ' of ' + total + ' tests.');
  if (failedTests.length > 0) console.log({
    failedTests: failedTests
  });
}
testRunner(isNumber)

Hasta donde yo sé, la forma más fácil es simplemente multiplicar por 1:

var character = ... ; // your character
var isDigit = ! isNaN(character * 1);

La multiplicación por uno genera un número de cualquier cadena numérica (como solo tiene un carácter, siempre será un número entero de 0 a 9) y un NaNpara cualquier otra cadena.

Similar a una de las respuestas anteriores, usé

 var sum = 0; //some value
 let num = parseInt(val); //or just Number.parseInt
 if(!isNaN(num)) {
     sum += num;
 }

Esta entrada de blog arroja algo más de luz sobre esta verificación si una cadena es numérica en Javascript | Mecanografiado y ES6

Una solución simple al aprovechar la verificación dinámica de tipos del lenguaje:

function isNumber (string) {
   //it has whitespace
   if(string === ' '.repeat(string.length)){
     return false
   }
   return string - 0 === string * 1
}

ver casos de prueba a continuación

function isNumber (str) {
   if(str.trim() === ''){
     return false
   }
   return str - 0 === str * 1
}


console.log('-1' + ' → ' + isNumber ('-1'))    
console.log('-1.5' + ' → ' + isNumber ('-1.5')) 
console.log('0' + ' → ' + isNumber ('0'))    
console.log(', ,' + ' → ' + isNumber (', ,'))  
console.log('0.42' + ' → ' + isNumber ('0.42'))   
console.log('.42' + ' → ' + isNumber ('.42'))    
console.log('#abcdef' + ' → ' + isNumber ('#abcdef'))
console.log('1.2.3' + ' → ' + isNumber ('1.2.3')) 
console.log('' + ' → ' + isNumber (''))    
console.log('blah' + ' → ' + isNumber ('blah'))

Solo usa isFinite

const number = "1";
if (isFinite(number)) {
    // do something
}