Video học lập trình mỗi ngày

Object.is() có nhiệm vụ so sánh hai đối tượng có bằng nhau hay không? Trước đây thì có toán tử == và ===, hầu hết lập trình viện thời nay đều quen thuộc với toán tử ===, nhưng họ khôn biết rằng vẫn có một số trường hợp sai khi sử dụng toán tử đó. 

Trước tiên chúng ta tìm hiểu một chút về Object.is() thì cũng nên tìm hiểu sự vì sao khi so sánh chúng ta phải sử dụng toán tử ===. Để làm gì, để chúng ta có cái nhìn lịch sử phát triển của một toán tử như thế nào trong ngôn ngữ lập trình javascript. Ngoài ra khi đến với nghề lập trình thì cần phải hiểu và đầu tư nhiều nhất về Objects và Arrays. Vì sao, chính là vì những lý do "Để trở thành một lập trình viên tốt".

Tài liệu tham khảo

Nên sử dụng toán tử === khi so sánh trong javascript

Để trở thành một lập trình viên tốt nên phân biệt những điều sau đây.
Giải thích object.js() của Mozilla

isNaN là gì?

Toán tử ==

Chúng ta đều biết rằng trong ngôn ngữ JavasSript khi chúng ta sử dụng == để so sánh, trong một số trường hợp do chuyển đổi kiểu hoặc so sánh thì sẽ có những kết quả không mong muốn. Ví dụ như dưới đây.

// 0 == ' '           //true
// null == undefined  //true
// [1] == true        //true

console.log('0 == " "', 0 == ' '); // true
console.log('null == undefined', null == undefined); // true
console.log('[1] == true', [1] == true); // true

Toán tử ===

Do đó, JavaScript cung cấp cho chúng ta toán tử ===, toán tử này nghiêm ngặt hơn toán tử đề cập ở trên và không trải qua quá trình chuyển đổi kiểu. Nhưng sử dụng === để so sánh không phải là giải pháp tốt nhất. Bạn có thể nhận được:

 // NaN === NaN //false
 console.log('NaN === NaN', NaN === NaN); // false

À quên nếu nói đến NaN là gì? Thì bạn cũng phải cần nên biết thêm về isNaN() cho nó được mở rộng thêm.

Object.is()

Tin tốt là ES6 cung cấp một phương thức Object.is () mới, nhìn chung là giống một số đặc điểm của ===, những thật sự là tốt hơn và chính xác hơn. Nó hoạt động tốt trong một số trường hợp đặc biệt:

// Object.is(0 , ' '); //false
// Object.is(null, undefined); //false
// Object.is([1], true); //false
// Object.is(NaN, NaN); //true

console.log('Object.is(0 , " ")', Object.is(0, ' ')); // false
console.log('Object.is(null , undefined)', Object.is(null, undefined)); // false
console.log('Object.is([1] , true)', Object.is([1], true)); // false
console.log('Object.is(NaN , NaN)', Object.is(NaN, NaN)); // true

// Case 2: Signed zero
Object.is(0, -0);                 // false
Object.is(+0, -0);                // false
Object.is(-0, -0);                // true
const n = 15;
Object.is(0n, -0n);               // true

// Case 3: NaN
Object.is(NaN, 0/0);              // true
Object.is(NaN, Number.NaN)        // true

Team Mozilla không cho rằng Object.is "nghiêm ngặt" hơn ===. Họ nói rằng điều chúng ta nên xem xét là cách phương pháp này xử lý NaN, -0 và +0. Nhưng nói chung, tôi nghĩ rằng đó là một thực hành tốt trong các ứng dụng thực tế.