¿Cómo convertir NaN de parseInt en 0 para una cadena vacía?

¿Es posible de alguna manera devolver 0 en lugar de NaNanalizar valores en JavaScript?

En caso de que la cadena vacía parseIntregrese NaN.

¿Es posible hacer algo así en JavaScript para verificar NaN?

var value = parseInt(tbb) == NaN ? 0 : parseInt(tbb)

¿O tal vez hay otra función o complemento jQuery que puede hacer algo similar?

var s = '';

var num = parseInt(s) || 0;

Cuando no se utiliza con valores booleanos, el ||operador lógico OR ( ) devuelve la primera expresión ( parseInt(s)) si se puede evaluar como verdadero; de lo contrario, devuelve la segunda expresión (0). El valor de retorno de parseInt('')es NaN. NaN se evalúa como falso, por lo que numtermina en 0.

También puedes usar la isNaN()función:

var s = ''
var num = isNaN(parseInt(s)) ? 0 : parseInt(s)

Me sorprendió no ver a nadie mencionar el uso Number(). De acuerdo, analizará decimales si se proporcionan, por lo que actuará de manera diferente que parseInt(), sin embargo, ya asume la base 10 y convertirá "" o incluso "" en 0.

Para las personas que no están restringidas a parseInt, puede usar el operador OR a nivel de bit (que implícitamente llama ToInt32a sus operandos).

var value = s | 0;

// NaN | 0     ==>> 0
// ''  | 0     ==>> 0
// '5' | 0     ==>> 5
// '33Ab' | 0  ==>> 0
// '0x23' | 0  ==>> 35
// 113 | 0     ==>> 113
// -12 | 0     ==>> -12
// 3.9 | 0     ==>> 3

Nota: ToInt32es diferente de parseInt. (es decir parseInt('33Ab') === 33)

El problema

Otras respuestas no tienen en cuenta que 0es falso, y por lo tanto, el siguiente será 20 en lugar de 0:

const myNumber = parseInt('0') || 20; // 20

La solución

Propongo una función auxiliar, que resuelve la mayoría de los problemas:

function getNumber({ value, defaultValue }) {
  const num = parseInt(value, 10);
  return isNaN(num) ? defaultValue : num;
}

La función auxiliar dará los siguientes resultados:

getNumber({ value: "0", defaultValue: 20 }); // 0
getNumber({ value: "2", defaultValue: 20 }); // 2
getNumber({ value: "2.2", defaultValue: 20 }); // 2
getNumber({ value: "any string", defaultValue: 20 }); // 20
getNumber({ value: undefined, defaultValue: 20 }); // 20
getNumber({ value: null, defaultValue: 20 }); // 20
getNumber({ value: NaN, defaultValue: 20 }); // 20
getNumber({ value: false, defaultValue: 20 }); // 20
getNumber({ value: true, defaultValue: 20 }); // 20

¿El trabajo es mucho más limpio que analizar? En mi opinión, use el operador +

var s = '';
console.log(+s);

var s = '1024'
+s
1024

s = 0
+s
0

s = -1
+s
-1

s = 2.456
+s
2.456

s = ''
+s
0

s = 'wtf'
+s
NaN

var value = isNaN(parseInt(tbb)) ? 0 : parseInt(tbb);

Haga una comprobación por separado para una cadena vacía (ya que es un caso específico) y configúrela en cero en este caso.

Puede agregar "0" al inicio, pero luego debe agregar un prefijo para indicar que es un número decimal y no un número octal

¿Por qué no anular la función? En ese caso, siempre puede estar seguro de que vuelve 0en caso de NaN:

(function(original) {
    parseInt = function() {
        return original.apply(window, arguments) || 0;
    };
})(parseInt);

Ahora, en cualquier parte de su código:

parseInt('') === 0

Tuve un problema similar (firefox v34) con cadenas simples como:

var myInt = parseInt("b4");

Entonces se me ocurrió un truco rápido de:

var intVal = ("" + val).replace(/[^0-9]/gi, "");

Y luego se volvió todo estúpido complicado para lidiar con flotadores + int para cosas no simples:

var myval = "12.34";

function slowParseNumber(val, asInt){
    var ret = Number( ("" + val).replace(/[^0-9\.]/gi, "") );
    return asInt ? Math.floor(ret) : ret;
}
var floatVal = slowParseNumber(myval);

var intVal = slowParseNumber(myval, true);
console.log(floatVal, intVal);

Devolverá 0 para cosas como:

var intVal = slowParseNumber("b"); // yeilds 0

//////////////////////////////////////////////////////
function ToInt(x){x=parseInt(x);return isNaN(x)?0:x;}
//////////////////////////////////////////////////////
var x = ToInt('');   //->  x=0
    x = ToInt('abc') //->  x=0
    x = ToInt('0.1') //->  x=0
    x = ToInt('5.9') //->  x=5
    x = ToInt(5.9)   //->  x=5
    x = ToInt(5)     //->  x=5

Creé un prototipo 2 para manejar esto por mí, uno para un número y otro para una Cadena.

// This is a safety check to make sure the prototype is not already defined.
Function.prototype.method = function (name, func) {
    if (!this.prototype[name]) {
        this.prototype[name] = func;
        return this;
    }
};

// returns the int value or -1 by default if it fails
Number.method('tryParseInt', function (defaultValue) {
    return parseInt(this) == this ? parseInt(this) : (defaultValue === undefined ? -1 : defaultValue);
});

// returns the int value or -1 by default if it fails
String.method('tryParseInt', function (defaultValue) {
    return parseInt(this) == this ? parseInt(this) : (defaultValue === undefined ? -1 : defaultValue);
});

Si no desea utilizar el control de seguridad, use

String.prototype.tryParseInt = function(){
    /*Method body here*/
};
Number.prototype.tryParseInt = function(){
     /*Method body here*/
};

Ejemplo de uso:

var test = 1;
console.log(test.tryParseInt()); // returns 1

var test2 = '1';
console.log(test2.tryParseInt()); // returns 1

var test3 = '1a';
console.log(test3.tryParseInt()); // returns -1 as that is the default

var test4 = '1a';
console.log(test4.tryParseInt(0));// returns 0, the specified default value

// implicit cast
var value = parseInt(tbb*1); // see original question

Explicación, para aquellos que no lo encuentran trivial:

Multiplicando por uno, un método llamado "conversión implícita", intenta convertir el operando de tipo desconocido en el tipo primitivo 'número'. En particular, una cadena vacía se convertiría en el número 0, por lo que es un tipo elegible para parseInt () ...

PirateApp también dio un muy buen ejemplo anteriormente, quien sugirió anteponer el signo +, obligando a JavaScript a usar el número implícito.

También de esta manera, ¿por qué no escribir una función y llamarla donde sea necesario? Supongo que es la entrada en los campos del formulario para realizar cálculos.

var Nanprocessor = function (entry) {
    if(entry=="NaN") {
        return 0;
    } else {
        return entry;
    }
}

 outputfield.value = Nanprocessor(x); 

// where x is a value that is collected from a from field
// i.e say x =parseInt(formfield1.value); 

¿Qué pasa haciendo esto?

Aquí hay un método tryParseInt que estoy usando, este toma el valor predeterminado como segundo parámetro, por lo que puede ser cualquier cosa que necesite.

function tryParseInt(str, defaultValue) {
    return parseInt(str) == str ? parseInt(str) : defaultValue;
}

tryParseInt("", 0);//0 
tryParseInt("string", 0);//0 
tryParseInt("558", 0);//558

una función auxiliar que todavía permite usar la raíz

function parseIntWithFallback(s, fallback, radix) {
    var parsed = parseInt(s, radix);
    return isNaN(parsed) ? fallback : parsed;
}

Puede tener un código muy limpio, tuve problemas similares y lo resolví usando:

var a="bcd";
~~parseInt(a);

Para otras personas que buscan esta solución, simplemente use: ~~ sin parseInt, es el modo más limpio.

var a = 'hello';
var b = ~~a;

Si NaN, devolverá 0 en su lugar.

OBS Esta solución aplica solo para enteros