如何将NaN从parseInt变成0为一个空字符串?

在JavaScript中解析值时，是否可能以某种方式返回0而不是NaN ?

如果是空字符串，parseInt返回NaN。

是否有可能在JavaScript中做这样的事情来检查NaN?

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

或者可能有另一个函数或jQuery插件可以做类似的事情?

306001 次浏览
小开

对空字符串进行单独检查(因为这是一个特定的情况)，在这种情况下将其设置为0。

您可以在开头添加“0”，但随后需要添加一个前缀，以表明它是小数而不是八进制数

小开
最佳答案 
var s = '';
var num = parseInt(s) || 0;

当不与布尔值一起使用时，逻辑或||运算符如果可以求出true，则返回第一个表达式parseInt(s)，否则返回第二个表达式0。parseInt('')的返回值是NaN。NaN求值为false，因此num最终被设置为0。

小开

为什么不重写这个函数呢?在这种情况下，你总是可以确保它在NaN的情况下返回0:

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

现在，在代码中的任何地方:

parseInt('') === 0
小开

你也可以使用isNaN()函数:

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

同样地，为什么不编写一个函数并在任何需要的地方调用它呢?我假设它是表单字段执行计算的入口。

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

这样做有什么不对?

小开

我很惊讶没有看到任何人提到使用Number()。假设它将解析小数，因此将不同于parseInt()，但它已经假设以10为底，并将“”甚至“”变成0。

小开

我有一个类似的问题(firefox v34)简单的字符串，如:

var myInt = parseInt("b4");

所以我想出了一个简单的方法:

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

然后用浮点数+整数来处理不简单的东西:

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

对于以下情况，它将返回0:

var intVal = slowParseNumber("b"); // yeilds 0
小开 
var value = isNaN(parseInt(tbb)) ? 0 : parseInt(tbb);
小开

这个问题

其他答案没有考虑到0是假的，因此以下将是20而不是0:

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

解决方案

我建议使用一个helper函数，它可以解决大部分问题:

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

helper函数将给出以下结果:

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
小开

对于不局限于parseInt的人，可以使用按位的OR操作符(它隐式地调用ToInt32到其操作数)。

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

注意:ToInt32不同于parseInt。(例如parseInt('33Ab') === 33)

小开 
//////////////////////////////////////////////////////
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
小开

这是一个tryParseInt方法，我正在使用，这将默认值作为第二个参数，所以它可以是任何你需要的。

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


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

我创建了一个2原型来为我处理这个，一个用于数字，一个用于字符串。

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

如果你不想使用安全检查，使用

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

使用示例:

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
小开

一个仍然允许使用基数的辅助函数

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

在我看来，这项工作比parseInt干净得多，使用+操作符

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
小开 
// implicit cast
var value = parseInt(tbb*1); // see original question

解释一下，给那些不觉得它微不足道的人:

一种叫做“隐式强制转换”的方法将未知类型操作数乘以1，试图将未知类型操作数转换为基本类型“number”。特别地，空字符串将变成数字0，使其成为parseInt()的合格类型…

上面的PirateApp也给出了一个很好的例子，他建议在+号前面加上+号，迫使JavaScript使用数字隐式强制转换。

8月20日更新:parseInt("0"+expr);给出了更好的结果，特别是对于parseInt("0"+'str');

小开

你可以有非常干净的代码，我有类似的问题，我解决它使用:

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

对于其他寻找此解决方案的人，只需使用:～~而不使用parseInt，这是最干净的模式。

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

如果是NaN，它将返回0。

奥林匹克广播服务公司。此解决方案仅适用于整数


提交答案