빈 문자열에 대해 NaN을 parseInt에서 0으로 바꾸는 방법은 무엇입니까?

NaNJavaScript에서 값을 구문 분석 할 때 대신 어떻게 든 0을 반환 할 수 있습니까?

빈 문자열의 parseInt경우을 반환합니다 NaN.

JavaScript로 확인하여 확인할 수 NaN있습니까?

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

아니면 비슷한 기능을 수행하는 다른 함수 또는 jQuery 플러그인이 있습니까?

var s = '';

var num = parseInt(s) || 0;

부울 값과 함께 사용하지 않으면 논리 OR ( ||) 연산자는 첫 번째 표현식 ( parseInt(s))을 true로 평가할 수 있으면 리턴하고 그렇지 않으면 두 번째 표현식 (0)을 리턴합니다. 의 반환 값 parseInt('')은 NaN입니다. NaN은 false로 평가되므로 num0으로 설정됩니다.

이 isNaN()기능을 사용할 수도 있습니다 :

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

나는 누군가가을 사용하는 것을 언급하지 않은 것에 놀랐다 Number(). 제공된 경우 10 진수를 구문 분석하므로, 다르게 작동 parseInt()하지만 이미 10을 가정하고 ""또는 ""를 0으로 바꿉니다.

로 제한되지 않은 사람들의 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)

문제

다른 답변 0은 허위 인 것을 고려하지 않으므로 0 대신 20이됩니다.

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

해결책

나는 대부분의 문제를 해결하는 도우미 기능을 제안합니다.

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

도우미 기능은 다음과 같은 결과를 제공합니다.

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

내 의견으로는 파싱보다 훨씬 깨끗한 작업을 수행합니까?

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

빈 문자열 (별도의 경우)을 별도로 확인하고이 경우 0으로 설정하십시오.

시작 부분에 "0"을 적용 할 수 있지만 10 진수가 아니라 10 진수임을 나타내는 접두사를 추가해야합니다.

왜 함수를 무시하지 않습니까? 이 경우 당신은 항상 반환 확신 할 수 0의 경우 NaN:

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

이제 코드의 어느 곳에서나 :

parseInt('') === 0

비슷한 문자열 (firefox v34)과 비슷한 문제가 발생했습니다.

var myInt = parseInt("b4");

그래서 나는 빠른 해킹을 생각해 냈습니다.

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

그리고 단순하지 않은 것들에 대한 floats + int를 다루기 위해 모든 바보가 복잡해졌습니다.

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

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

나는 이것을 처리하기 위해 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

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

사소한 것을 찾지 못한 사람들을위한 설명 :

"암시 적 캐스트"라는 방법에 1을 곱하면 알 수없는 유형 피연산자를 기본 유형 '숫자'로 바꾸려고 시도합니다. 특히 빈 문자열은 숫자 0이되어 parseInt ()에 적합한 유형이됩니다.

PirateApp은 위와 같이 아주 좋은 예를 제시했습니다. PirateApp은 + 부호를 붙여서 JavaScript가 Number 암시 적 캐스트를 사용하도록 강요했습니다.

또한이 방법으로 함수를 작성하고 필요한 곳에서 호출하십시오. 계산을 수행하기 위해 양식 필드에 들어가는 것으로 가정합니다.

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

이게 뭐가 문제 야?

여기에 내가 사용하고있는 tryParseInt 메소드가 있습니다. 이것은 기본값을 두 번째 매개 변수로 사용하므로 필요한 모든 것이 될 수 있습니다.

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

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

여전히 기수를 사용할 수있는 도우미 기능

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

매우 깨끗한 코드를 가질 수 있습니다. 비슷한 문제가 있었고 다음을 사용하여 해결했습니다.

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

이 솔루션을 찾는 다른 사람들을 위해 다음을 사용하십시오. ~~ parseInt없이 가장 깨끗한 모드입니다.

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

NaN이면 대신 0을 반환합니다.

OBS. 이 솔루션은 정수에만 적용됩니다