JavaScript: Toán tử so sánh bằng (Equality Operators)

Có bốn cách so sánh bằng trong JavaScript. Bài viết nói về các toán tử độc đáo xác định bằng, type coercion là gì, và một vài đặc thú khi đánh giá giá trị truthy/falsy trong JavaScript.

So sánh bằng nghiêm ngặt (Strict Equality ===)

Toán tử so sánh bằng nghiêm ngặt dùng ba dấu bằng (===). Mục đích so sánh không chỉ giá trị mà cả kiểu (type).

const strictComparison = (a, b) => { 
  console.log(typeof a); 
  console.log(typeof b); 
  return a === b; 
} 
strictComparison(8, '8'); // false

Hàm strictComparison nhận hai giá trị trả về có bằng nghiêm ngặt không. Nhìn đầu tiên giá trị giống nhau (cùng 8). Tuy nhiên, === cũng xem kiểu. typeof a trả về 'number', typeof b trả về 'string'. Vì kiểu khác, trả về false.

So sánh bất thường với ===

Có so sánh bất thường với ===. Dưới đây hay gặp phỏng vấn:

Lưu ý: không so sánh được cấu trúc dữ liệu (array/object). Cần câu lệnh phức tạp hơn.

Đa số evaluate vì kiểu khớp/không khớp. Ngoại lệ NaN – evaluate false vì NaN lý thuyết có thể là bất cứ gì – không chỉ ra có bằng nhau không, nên false.

So sánh không bằng nghiêm ngặt (Strict Inequality !==)

Toán tử !== dùng dấu chấm than và hai dấu bằng (!==). Đánh giá hai giá trị KHÔNG bằng về giá trị VÀ kiểu.

const strictInequalityComparison = (a, b) => { 
  console.log(typeof a); 
  console.log(typeof b); 
  return a !== b; 
} 
strictInequalityComparison("8", 8); // true

Hàm trả về hai giá trị không bằng nghiêm ngặt. Nhìn đầu tiên giá trị bằng (cùng 8). Nhưng !== cũng xem kiểu. typeof a 'string', typeof b 'number'. Kiểu khác nên trả về true.

So sánh bất thường với !==

Giống ===, không so sánh object/array.

Một điều nữa...

Trong hầu hết tình huống dev JavaScript, hai toán tử === và !== sẽ dùng cho logic điều kiện.

So sánh bằng lỏng lẻo (Loose Equality ==)

Toán tử == dùng hai dấu bằng (==). Mục đích ép (coerce) hai giá trị về kiểu chung trước khi so sánh. Đây gọi là type coercion hoặc type conversion.

const looseComparison = (a, b) => { 
  console.log(typeof a); 
  console.log(typeof b); 
  return a == b; 
} 
strictComparison(8, '8'); // true

Hàm looseComparison trả về hai giá trị bằng lỏng lẻo. Nhìn đầu tiên khác (number vs string). Nhưng == không xem kiểu. Câu lệnh ép kiểu cùng nhau trước so sánh giá trị – ví dụ trả về true vì operand 2 chuyển thành number rồi so sánh.

So sánh bất thường với ==

Đa số evaluate giống strict equality. Ngoại lệ nổi bật: null và undefined so sánh lỏng cho true.

So sánh không bằng lỏng lẻo (Loose Inequality !=)

Toán tử != dùng dấu chấm than và một dấu bằng (!=). Đánh giá hai giá trị KHÔNG bằng chỉ về giá trị. Ép cả hai đối số về cùng kiểu.

const looseInequalityComparison = (a, b) => { 
  console.log(typeof a); 
  console.log(typeof b); 
  return a != b; 
} 
looseInequalityComparison("8", 8); // false

Hàm trả về hai giá trị không bằng lỏng. Nhìn đầu tiên bằng (cùng giá trị). Nhưng != ép kiểu cùng nhau trước so sánh. Vì giá trị sau ép giống nhau, trả về false.

So sánh bất thường với !=

Giống ===, không so sánh object/array. Đa số evaluate giống strict inequality. Ngoại lệ: null và undefined so sánh lỏng cho false.

Kết luận

Bài viết xem 4 cách so sánh bằng trong JavaScript. Điều chính nhớ: === và == KHÔNG cùng toán tử. Một đánh giá nghiêm ngặt kiểu và giá trị, cái kia chỉ giá trị sau ép kiểu.