Come trasformare NaN da parseInt in 0 per una stringa vuota?

È possibile in qualche modo restituire 0 anziché NaNquando si analizzano valori in JavaScript?

Nel caso della stringa vuota parseIntritorna NaN.

È possibile fare qualcosa del genere in JavaScript per verificare NaN?

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

O forse c'è un'altra funzione o plugin jQuery che può fare qualcosa di simile?

var s = '';

var num = parseInt(s) || 0;

Se non utilizzato con valori booleani, l' ||operatore logico OR ( ) restituisce la prima espressione ( parseInt(s)) se può essere valutata su true, altrimenti restituisce la seconda espressione (0). Il valore di ritorno di parseInt('')è NaN. NaN viene valutato come falso, quindi numfinisce per essere impostato su 0.

Puoi anche usare la isNaN()funzione:

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

Sono stato sorpreso di non vedere nessuno menzionare l'utilizzo Number(). Concesso che analizzerà i decimali se forniti, quindi agirà in modo diverso da parseInt(), tuttavia presuppone già la base 10 e trasformerà "" o addirittura "" su 0.

Per le persone a cui non è limitato parseInt, è possibile utilizzare l'operatore OR bit a bit (che chiama implicitamente i ToInt32suoi operandi).

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: ToInt32è diverso da parseInt. (ie parseInt('33Ab') === 33)

Il problema

Altre risposte non tengono conto del fatto che 0è falso e quindi le seguenti saranno 20 anziché 0:

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

La soluzione

Propongo una funzione di aiuto, che risolve la maggior parte dei problemi:

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

La funzione helper darà i seguenti risultati:

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

A mio avviso, il lavoro è molto più pulito rispetto all'analisi. Utilizza l'operatore +

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

Esegui un controllo separato per una stringa vuota (poiché si tratta di un caso specifico) e impostala su zero in questo caso.

È possibile inserire "0" all'inizio, ma è necessario aggiungere un prefisso per indicare che è un numero decimale e non un numero ottale

Perché non sovrascrivere la funzione? In tal caso puoi sempre essere sicuro che ritorni 0in caso di NaN:

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

Ora, ovunque nel tuo codice:

parseInt('') === 0

Ho avuto un problema simile (firefox v34) con stringhe semplici come:

var myInt = parseInt("b4");

Quindi ho pensato a una rapida modifica di:

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

E poi è diventato tutto stupido complicato da gestire float + ints per cose non semplici:

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

Restituirà 0 per cose come:

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

Ho creato un prototipo 2 per gestirlo, uno per un numero e uno per una stringa.

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

Se non si desidera utilizzare il controllo di sicurezza, utilizzare

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

Esempio di utilizzo:

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

Spiegazione, per coloro che non lo trovano banale:

Moltiplicando per uno, un metodo chiamato "cast implicito", tenta di trasformare l'operando di tipo sconosciuto nel tipo 'numero' primitivo. In particolare, una stringa vuota diventerebbe il numero 0, rendendolo un tipo idoneo per parseInt () ...

Un ottimo esempio è stato anche citato in precedenza da PirateApp, che ha suggerito di anteporre il segno +, costringendo JavaScript a utilizzare il cast implicito di Number.

Anche in questo modo, perché non scrivere una funzione e chiamarla dove mai richiesto. Suppongo sia l'ingresso nei campi del modulo per eseguire calcoli.

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

cosa c'è che non va?

Ecco un metodo tryParseInt che sto usando, questo prende il valore predefinito come secondo parametro in modo che possa essere tutto ciò di cui hai bisogno.

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

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

una funzione di supporto che consente ancora di utilizzare il radix

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

Puoi avere un codice molto pulito, ho avuto problemi simili e l'ho risolto usando:

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

Per le altre persone in cerca di questa soluzione, basta usare: ~~ senza analisi, è la modalità più pulita.

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

Se NaN, restituirà invece 0.

OBS. Questa soluzione si applica solo per numeri interi