Làm cách nào để biến NaN từ parseInt thành 0 cho một chuỗi rỗng?

Có thể bằng cách nào đó trả về 0 thay vì NaNkhi phân tích giá trị trong JavaScript?

Trong trường hợp chuỗi rỗng parseInttrả về NaN.

Có thể làm một cái gì đó như thế trong JavaScript để kiểm tra NaNkhông?

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

Hoặc có thể có một chức năng hoặc plugin jQuery khác có thể làm điều gì đó tương tự?

var s = '';

var num = parseInt(s) || 0;

Khi không được sử dụng với các giá trị boolean, ||toán tử OR ( ) logic trả về biểu thức đầu tiên ( parseInt(s)) nếu nó có thể được ước tính là true, nếu không, nó trả về biểu thức thứ hai (0). Giá trị trả về của parseInt('')là NaN. NaN ước tính là sai, vì vậy numkết thúc được đặt thành 0.

Bạn cũng có thể sử dụng isNaN()chức năng:

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

Tôi ngạc nhiên khi không thấy ai nhắc đến việc sử dụng Number(). Được cấp, nó sẽ phân tích số thập phân nếu được cung cấp, do đó sẽ hành động khác với parseInt(), tuy nhiên, nó đã giả sử cơ sở 10 và sẽ biến "" hoặc thậm chí "" thành 0.

Đối với những người không bị hạn chế parseInt, bạn có thể sử dụng toán tử bitwise OR (gọi ngầm ToInt32cho toán hạng của nó).

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

Lưu ý: ToInt32khác với parseInt. (tức là parseInt('33Ab') === 33)

Vấn đề

Các câu trả lời khác không tính đến sai 0lệch, và do đó, sau đây sẽ là 20 thay vì 0:

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

Giải pháp

Tôi đề xuất một hàm trợ giúp, giải quyết hầu hết các vấn đề:

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

Hàm trợ giúp sẽ cho kết quả như sau:

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

Theo tôi, công việc có sạch sẽ hơn parseInt không, sử dụng toán tử +

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

Thực hiện kiểm tra riêng cho một chuỗi trống (vì đây là một trường hợp cụ thể) và đặt nó thành 0 trong trường hợp này.

Bạn có thể xuất hiện "0" khi bắt đầu, nhưng sau đó bạn cần thêm tiền tố để chỉ ra rằng đó là số thập phân chứ không phải số bát phân

Tại sao không ghi đè chức năng? Trong trường hợp đó, bạn luôn có thể chắc chắn rằng nó trả về 0trong trường hợp NaN:

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

Bây giờ, bất cứ nơi nào trong mã của bạn:

parseInt('') === 0

Tôi gặp vấn đề tương tự (firefox v34) với các chuỗi đơn giản như:

var myInt = parseInt("b4");

Vì vậy, tôi đã đưa ra một bản hack nhanh chóng:

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

Và sau đó có tất cả sự phức tạp ngu ngốc để đối phó với float + ints cho những thứ không đơn giản:

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

Nó sẽ trả về 0 cho những thứ như:

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

Tôi đã tạo một nguyên mẫu 2 để xử lý cái này cho tôi, một cho một số và một cho một Chuỗi.

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

Nếu bạn không muốn sử dụng kiểm tra an toàn, hãy sử dụng

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

Ví dụ sử dụng:

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

Giải thích, cho những người không thấy nó tầm thường:

Nhân với một, một phương thức gọi là "diễn viên ngầm", cố gắng biến toán hạng loại không xác định thành kiểu nguyên thủy 'số'. Cụ thể, một chuỗi rỗng sẽ trở thành số 0, biến nó thành một loại đủ điều kiện cho parseInt () ...

Một ví dụ rất hay cũng được đưa ra ở trên bởi PirateApp, người đã đề xuất trả trước dấu +, buộc JavaScript phải sử dụng biểu thức ẩn số.

Cũng theo cách này, tại sao không viết một hàm và gọi nó ở bất cứ nơi nào cần thiết. Tôi giả sử đó là mục nhập vào các trường mẫu để thực hiện tính toán.

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

Có gì sai khi làm điều này?

Đây là một phương thức tryPudeInt mà tôi đang sử dụng, cái này lấy giá trị mặc định làm tham số thứ hai để nó có thể là bất cứ thứ gì bạn yêu cầu.

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

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

một hàm trợ giúp vẫn cho phép sử dụng cơ số

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

Bạn có thể có mã rất sạch, tôi đã gặp vấn đề tương tự và tôi đã giải quyết nó bằng cách sử dụng:

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

Đối với những người khác đang tìm kiếm giải pháp này, chỉ cần sử dụng: ~ ~ không có parseInt, đó là chế độ sạch nhất.

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

Nếu NaN, nó sẽ trả về 0 thay thế.

OBS. Giải pháp này chỉ áp dụng cho số nguyên