blocks|key|3513136|text|var+s+=+'';

var+num+=+parseInt(s)+%7C%7C+0;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3513137|当不与布尔值一起使用时，逻辑OR+(%7C%7C)运算符返回第一个表达式(parseInt(s))+(如果可以计算为true+)，否则返回第二个表达式(0)。parseInt('')返回值为NaN。NaN的计算结果为false，因此num最终被设置为0。|unstyled|offset|length|style|CODE|3513138|entityMap^0|0|I|2|X|B|23|C|34|3|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]|$G|S|H|T|I|J]|$G|U|H|V|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|W|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>var s = '';

var num = parseInt(s) || 0;
</code></pre>

When not used with boolean values, the logical OR (<code>||</code>) operator returns the first expression (<code>parseInt(s)</code>) if it can be evaluated to true, otherwise it returns the second expression (0). The return value of <code>parseInt('')</code> is NaN. NaN evaluates to false, so <code>num</code> ends up being set to 0.

blocks|key|1613343|text|您还可以使用isNaN()函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1613344|var+s+=+''
var+num+=+isNaN(parseInt(s))+?+0+:+parseInt(s)|code-block|syntax|javascript|1613345|entityMap^0|6|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You can also use the <code>isNaN()</code> function:

<pre><code>var s = ''
var num = isNaN(parseInt(s)) ? 0 : parseInt(s)
</code></pre>

blocks|key|3513231|text|我很惊讶没有看到任何人提到使用Number()。假设它可以解析十进制数(如果提供)，那么它的行为将与parseInt()不同，但是它已经假定基数为10，并将"“甚至”“转换为0。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3513232|entityMap^0|F|8|1E|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

I was surprised to not see anyone mention using <code>Number()</code>. Granted it will parse decimals if provided, so will act differently than <code>parseInt()</code>, however it already assumes base 10 and will turn "" or even " " in to 0.

blocks|key|3513267|text|The+problem|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3513268|其他答案没有考虑到0是错误的，因此下面的答案将是20而不是0：|CODE|3513269|const+myNumber+=+parseInt('0')+%7C%7C+20;+//+20|code-block|syntax|javascript|3513270|解决方案|3513271|我提出了一个helper函数，它解决了大多数问题：|3513272|function+getNumber({+value,+defaultValue+})+{
++const+num+=+parseInt(value,+10);
++return+isNaN(num)+?+defaultValue+:+num;
}|3513273|helper函数将产生以下结果：|3513274|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|3513275|entityMap^0|0|B|0|9|1|0|0|0|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|H]]|D|@]|E|$]]|$1|I|3|J|5|K|7|15|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|19|8|@]|D|@]|E|$]]|$1|R|3|S|5|K|7|1A|8|@]|D|@]|E|$L|M]]|$1|T|3|U|5|6|7|1B|8|@]|D|@]|E|$]]|$1|V|3|W|5|K|7|1C|8|@]|D|@]|E|$L|M]]|$1|X|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|Y|$]]

The problem

Other answers don't take into account that <code>0</code> is falsy, and thus the following will be 20 instead of 0:

<pre><code>const myNumber = parseInt('0') || 20; // 20
</code></pre>

The solution

I propose a helper function, that solves most of the issues:

<pre><code>function getNumber({ value, defaultValue }) {
 const num = parseInt(value, 10);
 return isNaN(num) ? defaultValue : num;
}
</code></pre>

The helper function will give the following results:

<pre><code>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
</code></pre>

blocks|key|3228592|text|对于不受parseInt限制的人，可以使用按位OR运算符(它隐式地调用ToInt32作为其操作数)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3228593|var+value+=+s+%7C+0;

//+NaN+%7C+0+++++==>>+0
//+''++%7C+0+++++==>>+0
//+'5'+%7C+0+++++==>>+5
//+'33Ab'+%7C+0++==>>+0
//+'0x23'+%7C+0++==>>+35
//+113+%7C+0+++++==>>+113
//+-12+%7C+0+++++==>>+-12
//+3.9+%7C+0+++++==>>+3|code-block|syntax|javascript|3228594|注意：ToInt32不同于parseInt。(即parseInt('33Ab')+===+33)|3228595|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ecma-international.org/ecma-262/6.0/index.html#sec-toint32^0|4|8|Z|7|Z|7|0|0|0|3|7|D|8|O|N|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

For people who are not restricted to <code>parseInt</code>, you can use the bitwise OR operator (which implicitly calls <a href="http://www.ecma-international.org/ecma-262/6.0/index.html#sec-toint32" rel="noreferrer"><code>ToInt32</code></a> to its operands).

<pre><code>var value = s | 0;

// NaN | 0 ==&gt;&gt; 0
// '' | 0 ==&gt;&gt; 0
// '5' | 0 ==&gt;&gt; 5
// '33Ab' | 0 ==&gt;&gt; 0
// '0x23' | 0 ==&gt;&gt; 35
// 113 | 0 ==&gt;&gt; 113
// -12 | 0 ==&gt;&gt; -12
// 3.9 | 0 ==&gt;&gt; 3
</code></pre>

Note: <code>ToInt32</code> is different from <code>parseInt</code>. (i.e. <code>parseInt('33Ab') === 33</code>)

blocks|key|3513381|text|在我看来，使用%2B运算符的工作比parseInt干净得多吗|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3513382|var+s+=+'';
console.log(%2Bs);

var+s+=+'1024'
%2Bs
1024

s+=+0
%2Bs
0

s+=+-1
%2Bs
-1

s+=+2.456
%2Bs
2.456

s+=+''
%2Bs
0

s+=+'wtf'
%2Bs
NaN|code-block|syntax|javascript|3513383|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Does the job a lot cleaner than parseInt in my opinion, Use the +operator

<pre><code>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
</code></pre>

blocks|key|38638|text|为什么不覆盖这个函数呢？在这种情况下，如果是NaN，则始终可以确保返回0|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|38639|(function(original)+{
++++parseInt+=+function()+{
++++++++return+original.apply(window,+arguments)+%7C%7C+0;
++++};
})(parseInt);|code-block|syntax|javascript|38640|现在，在代码中的任何位置：|38641|parseInt('')+===+0|38642|entityMap^0|M|3|Z|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

Why not override the function? In that case you can always be sure it returns <code>0</code> in case of <code>NaN</code>:

<pre><code>(function(original) {
 parseInt = function() {
 return original.apply(window, arguments) || 0;
 };
})(parseInt);
</code></pre>

Now, anywhere in your code:

<pre><code>parseInt('') === 0
</code></pre>

blocks|key|38674|text|var+value+=+isNaN(parseInt(tbb))+?+0+:+parseInt(tbb);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|38675|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var value = isNaN(parseInt(tbb)) ? 0 : parseInt(tbb);
</code></pre>

blocks|key|3513293|text|//////////////////////////////////////////////////////
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|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3513294|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

blocks|key|3513127|text|对空字符串进行单独的检查(因为它是一个特定的情况)，并在本例中将其设置为零。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3513128|您可以在开头加上"0“，但随后需要添加一个前缀，以指示它是十进制数而不是八进制数|3513129|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Do a separate check for an empty string ( as it is one specific case ) and set it to zero in this case.

You could appeand "0" to the start, but then you need to add a prefix to indicate that it is a decimal and not an octal number

blocks|key|38996|text|我也遇到过类似的问题(火狐v34)，简单的字符串如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|38997|var+myInt+=+parseInt("b4");|code-block|syntax|javascript|38998|因此，我想出了一个快速的技巧：|38999|var+intVal+=+(""+%2B+val).replace(/[%5E0-9]/gi,+"");|39000|然后让所有愚蠢的复杂处理浮点数%2B整型的非简单的东西：|39001|var+myval+=+"12.34";

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

var+intVal+=+slowParseNumber(myval,+true);
console.log(floatVal,+intVal);|39002|对于以下内容，它将返回0：|39003|var+intVal+=+slowParseNumber("b");+//+yeilds+0|39004|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I had a similar problem (firefox v34) with simple strings like:

<pre><code>var myInt = parseInt("b4");
</code></pre>

So I came up with a quick hack of:

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

And then got all stupid complicated to deal with floats + ints for non-simple stuff:

<pre><code>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);
</code></pre>

It will return 0 for things like:

<pre><code>var intVal = slowParseNumber("b"); // yeilds 0
</code></pre>

blocks|key|3228665|text|我创建了一个2原型来为我处理这个问题，一个用于数字，另一个用于字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3228666|//+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);
});|code-block|syntax|javascript|3228667|如果您不想使用安全检查，请使用|3228668|String.prototype.tryParseInt+=+function(){
++++/*Method+body+here*/
};
Number.prototype.tryParseInt+=+function(){
+++++/*Method+body+here*/
};|3228669|示例用法：|3228670|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|3228671|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I created a 2 prototype to handle this for me, one for a number, and one for a String. 

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

If you dont want to use the safety check, use

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

Example usage:

<pre><code>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
</code></pre>

blocks|key|38734|text|//+implicit+cast
var+value+=+parseInt(tbb*1);+//+see+original+question|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|38735|对于那些觉得这不是微不足道的人，请解释一下：|unstyled|38736|一个称为“隐式转换”的方法乘以1，试图将未知类型的操作数转换为原始类型“number”。特别是，空字符串将变为数字0，使其成为parseInt()的合格类型...|38737|上面PirateApp也给出了一个很好的例子，他建议在前面加上%2B号，迫使JavaScript使用数字隐式转换。|38738|8月20日更新：parseInt("0"%2Bexpr);提供了更好的结果，特别是对于parseInt("0"%2B'str');|offset|length|style|CODE|38739|entityMap^0|0|0|0|0|8|J|15|K|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|F|7|11|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>// implicit cast
var value = parseInt(tbb*1); // see original question
</code></pre>
Explanation, for those who don't find it trivial:
Multiplying by one, a method called &quot;implicit cast&quot;, attempts to turn the unknown type operand into the primitive type 'number'. In particular, an empty string would become number 0, making it an eligible type for parseInt()...
A very good example was also given above by PirateApp, who suggested to prepend the + sign, forcing JavaScript to use the Number implicit cast.
Aug. 20 update: <code>parseInt(&quot;0&quot;+expr);</code> gives better results, in particular for <code>parseInt(&quot;0&quot;+'str');</code>

blocks|key|1613552|text|对于其他正在寻找此解决方案的人，只需使用：~~不带parseInt的，这是最干净的模式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1613553|var+a+=+'hello';
var+b+=+~~a;|code-block|syntax|javascript|1613554|如果为NaN，则返回0。|1613555|1613556|+OBS。此解决方案仅适用于整数|blockquote|1613557|1613558|entityMap^0|L|D|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|W|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|X|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|Z|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|10|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|S|$]]

For other people looking for this solution, just use: ~~ without parseInt, it is the cleanest mode.

<pre><code>var a = 'hello';
var b = ~~a;
</code></pre>

If NaN, it will return 0 instead.

<blockquote>
 OBS. This solution apply only for integers
</blockquote>

blocks|key|3228507|text|这样，为什么不写一个函数，并在需要的地方调用它。我假设它是用于执行计算的表单字段中的条目。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3228508|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);+|code-block|syntax|javascript|3228509|这么做有什么不对吗？|3228510|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Also this way, why not write a function and call it where ever required . I'm assuming it's the entry into the form fields to perform calculations.

<pre><code>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); 
</code></pre>

what's wrong doing this?

blocks|key|39050|text|这是我正在使用的tryParseInt方法，它接受默认值作为第二个参数，所以它可以是您需要的任何东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|39051|function+tryParseInt(str,+defaultValue)+{
++++return+parseInt(str)+==+str+?+parseInt(str)+:+defaultValue;
}

tryParseInt("",+0);//0+
tryParseInt("string",+0);//0+
tryParseInt("558",+0);//558|code-block|syntax|javascript|39052|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a tryParseInt method that I am using, this takes the default value as second parameter so it can be anything you require.

<pre><code>function tryParseInt(str, defaultValue) {
 return parseInt(str) == str ? parseInt(str) : defaultValue;
}

tryParseInt("", 0);//0 
tryParseInt("string", 0);//0 
tryParseInt("558", 0);//558
</code></pre>

blocks|key|1613518|text|一个辅助函数，它仍然允许使用基数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1613519|function+parseIntWithFallback(s,+fallback,+radix)+{
++++var+parsed+=+parseInt(s,+radix);
++++return+isNaN(parsed)+?+fallback+:+parsed;
}|code-block|syntax|javascript|1613520|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

an helper function which still allow to use the radix

<pre><code>function parseIntWithFallback(s, fallback, radix) {
 var parsed = parseInt(s, radix);
 return isNaN(parsed) ? fallback : parsed;
}
</code></pre>

blocks|key|3513396|text|你可以有非常干净的代码，我有类似的问题，我通过使用以下命令解决了它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3513397|var+a="bcd";
~~parseInt(a);|code-block|syntax|javascript|3513398|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can have very clean code, i had similar problems and i solved it by using :

<pre><code>var a="bcd";
~~parseInt(a);
</code></pre>

Is it possible somehow to return 0 instead of <code>NaN</code> when parsing values in JavaScript?

In case of the empty string <code>parseInt</code> returns <code>NaN</code>.

Is it possible to do something like that in JavaScript to check for <code>NaN</code>?

<pre><code>var value = parseInt(tbb) == NaN ? 0 : parseInt(tbb)
</code></pre>

Or maybe there is another function or jQuery plugin which may do something similar?

How to turn NaN from parseInt into 0 for an empty string?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

有没有可能在解析JavaScript中的值时返回0而不是NaN？如果是空字符串，则parseInt返回NaN。是否可以在JavaScript中执行类似的操作来检查NaNvar value = parseInt(tbb) == NaN ? 0 : parseInt(tbb)或者可能有其他函数或jQuery插件可以做类似的事情？

问如何将空字符串的NaN从parseInt转换为0？
EN

回答 18

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将空字符串的NaN从parseInt转换为0？EN

回答 18

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将空字符串的NaN从parseInt转换为0？
EN