Sự khác biệt giữa parseInt () và Number () là gì?

Làm thế nào để làm parseInt()và Number()hành xử khác nhau khi chuyển đổi chuỗi thành số?

Chà, chúng khác nhau về mặt ngữ nghĩa , hàm Numbertạo được gọi là hàm thực hiện chuyển đổi kiểu và parseIntthực hiện phân tích cú pháp , ví dụ:

// parsing:
parseInt("20px");       // 20
parseInt("10100", 2);   // 20
parseInt("2e1");        // 2

// type conversion
Number("20px");       // NaN
Number("2e1");        // 20, exponential notation

Hãy nhớ rằng nếu parseIntphát hiện số 0 đứng đầu trong chuỗi, nó sẽ phân tích số trong cơ sở bát phân, điều này đã thay đổi trên ECMAScript 5, phiên bản mới của tiêu chuẩn, nhưng sẽ mất nhiều thời gian để triển khai trình duyệt (nó không tương thích với ECMAScript 3), cũng parseIntsẽ bỏ qua các ký tự dấu không tương ứng với bất kỳ chữ số nào của cơ sở hiện đang sử dụng.

Hàm Numbertạo không phát hiện các quãng tám:

Number("010");         // 10
parseInt("010");       // 8, implicit octal
parseInt("010", 10);   // 10, decimal radix used

Nhưng nó có thể xử lý các số theo ký hiệu thập lục phân, giống như parseInt:

Number("0xF");   // 15
parseInt("0xF"); //15

Ngoài ra, một cấu trúc được sử dụng rộng rãi để thực hiện chuyển đổi loại Số, là Toán tử Unary +(trang 72) , nó tương đương với việc sử dụng hàm Numbertạo như một hàm:

+"2e1";   // 20
+"0xF";   // 15
+"010";   // 10

typeof parseInt("123") => number
typeof Number("123") => number
typeof new Number("123") => object (Number primitive wrapper object)

hai cái đầu tiên sẽ cung cấp cho bạn hiệu suất tốt hơn vì nó trả về một nguyên thủy thay vì một đối tượng.

Nếu bạn đang tìm kiếm hiệu suất thì có lẽ kết quả tốt nhất bạn sẽ nhận được với sự thay đổi đúng theo từng bit "10">>0. Cũng nhân ( "10" * 1) hoặc không không ( ~~"10"). Tất cả trong số họ là nhanh hơn nhiều của Numbervà parseInt. Họ thậm chí có "tính năng" trả về 0 cho đối số không. Dưới đây là các bài kiểm tra hiệu suất .

Tôi tìm thấy hai liên kết hiệu suất so sánh giữa một số cách chuyển đổi stringsang int.

parseInt(str,10)    
parseFloat(str)
str << 0
+str
str*1 
str-0
Number(str)

http://jsben.ch/#/zGJHM

http://phrogz.net/js/opes_to_number.html

Một khác biệt nhỏ là những gì họ chuyển đổi undefinedhoặc null,

Number() Or Number(null) // returns 0

trong khi

parseInt() Or parseInt(null) // returns NaN

Tóm lược:

parseInt():

• Lấy một chuỗi làm đối số thứ nhất, cơ số (Một số nguyên là cơ sở của hệ thống số, ví dụ thập phân 10 hoặc nhị phân 2) làm đối số thứ hai
• Hàm trả về một số nguyên, nếu ký tự đầu tiên không thể được chuyển đổi thành một số NaN sẽ được trả về.
• Nếu parseInt() hàm gặp một giá trị không phải là số, nó sẽ cắt phần còn lại của chuỗi đầu vào và chỉ phân tích phần cho đến khi giá trị không phải là số.
• Nếu cơ số là undefined0, thì JS sẽ giả sử như sau:
  • Nếu chuỗi đầu vào bắt đầu bằng "0x" hoặc "0X", cơ số là 16 (thập lục phân), phần còn lại của chuỗi được phân tách thành một số.
  • Nếu giá trị đầu vào bắt đầu bằng 0, cơ số có thể là 8 (bát phân) hoặc 10 (thập phân). Cơ số nào được chọn là tùy thuộc vào việc triển khai công cụ JS. ES5xác định rằng 10 nên được sử dụng sau đó. Tuy nhiên, điều này không được tất cả các trình duyệt hỗ trợ, do đó luôn chỉ định cơ số nếu số của bạn có thể bắt đầu bằng 0.
  • Nếu giá trị đầu vào bắt đầu bằng bất kỳ số nào, cơ số sẽ là 10

Number():

• Hàm Number()tạo có thể chuyển đổi bất kỳ đầu vào đối số thành một số. Nếu hàm Number()tạo không thể chuyển đổi đầu vào thành một số, NaNsẽ được trả về.
• Hàm Number()tạo cũng có thể xử lý số thập lục phân, chúng phải bắt đầu bằng 0x.

Thí dụ:

console.log(parseInt('0xF', 16));  // 15

// z is no number, it will only evaluate 0xF, therefore 15 is logged
console.log(parseInt('0xFz123', 16));

// because the radix is 10, A is considered a letter not a number (like in Hexadecimal)
// Therefore, A will be cut off the string and 10 is logged
console.log(parseInt('10A', 10));  // 10

// first character isnot a number, therefore parseInt will return NaN
console.log(parseInt('a1213', 10));


console.log('\n');


// start with 0X, therefore Number will interpret it as a hexadecimal value
console.log(Number('0x11'));

// Cannot be converted to a number, NaN will be returned, notice that
// the number constructor will not cut off a non number part like parseInt does
console.log(Number('123A'));

// scientific notation is allowed
console.log(Number('152e-1'));  // 15.21

Tôi luôn luôn sử dụng parseInt, nhưng hãy cẩn thận với các số 0 hàng đầu sẽ buộc nó vào chế độ bát phân .

parseInt() -> Phân tích một số thành redix được chỉ định.

Number()-> Chuyển đổi giá trị được chỉ định thành tương đương số hoặc NaN nếu không thực hiện được.

Do đó để chuyển đổi một số giá trị không phải là số thành số, chúng ta nên luôn luôn sử dụng hàm Number ().

ví dụ.

Number("")//0
parseInt("")//NaN

Number("123")//123
parseInt("123")//123

Number("123ac") //NaN,as it is a non numeric string
parsInt("123ac") //123,it parse decimal number outof string

Number(true)//1
parseInt(true) //NaN

Có nhiều trường hợp góc khác nhau cho các parseInt()hàm vì nó thực hiện chuyển đổi, do đó chúng ta nên tránh sử dụng hàm parseInt () cho mục đích coersion.

Bây giờ, để kiểm tra thời tiết giá trị được cung cấp có phải là Số hay không, chúng ta nên sử dụng isNaN()hàm riêng

parseInt chuyển đổi thành một số nguyên, nghĩa là, nó tước các số thập phân. Số không chuyển đổi thành số nguyên.

Đó là một ý tưởng tốt để tránh xa parseInt và sử dụng Number và Math.round trừ khi bạn cần hex hoặc bát phân. Cả hai đều có thể sử dụng chuỗi. Tại sao phải tránh xa nó?

parseInt(0.001, 10)
0

parseInt(-0.0000000001, 10)
-1

parseInt(0.0000000001, 10)
1

parseInt(4000000000000000000000, 10)
4

Nó hoàn toàn tàn sát số lượng thực sự lớn hoặc thực sự nhỏ. Thật kỳ lạ, nó hoạt động bình thường nếu các đầu vào này là một chuỗi.

parseInt("-0.0000000001", 10)
0

parseInt("0.0000000001", 10)
0

parseInt("4000000000000000000000", 10)
4e+21

Thay vì mạo hiểm để tìm lỗi với điều này và các vấn đề khác mà mọi người đã đề cập, tôi sẽ chỉ tránh parseInt trừ khi bạn cần phân tích một cái gì đó ngoài cơ sở 10. Number, Math.round, Math.foor và .toFixed (0) làm những điều tương tự parseInt có thể được sử dụng mà không có các loại lỗi này.

Nếu bạn thực sự muốn hoặc cần sử dụng parseInt cho một số phẩm chất khác của nó, đừng bao giờ sử dụng nó để chuyển đổi float thành ints.