Sự khác biệt giữa (NaN! = NaN) và (NaN! == NaN) là gì?

Trước hết tôi muốn đề cập rằng tôi biết làm thế nào isNaN()và Number.isNaN()làm việc. Tôi đang đọc Hướng dẫn xác định của David Flanagan và ông đưa ra một ví dụ về cách kiểm tra xem giá trị có phải là NaN:

x !== x

Điều này sẽ dẫn đến kết quả truenếu và chỉ khi xcó NaN.

Nhưng bây giờ tôi có một câu hỏi: tại sao anh ta sử dụng so sánh nghiêm ngặt? Bởi vì dường như

x != x

cư xử theo cùng một cách. Là nó an toàn để sử dụng cả hai phiên bản, hay tôi thiếu một số giá trị (s) trong JavaScript rằng sẽ trở lại truecho x !== xvà falsecho x != x?

Đầu tiên, hãy để tôi chỉ ra rằng NaN là một giá trị rất đặc biệt: Theo định nghĩa, nó không bằng chính nó. Điều đó xuất phát từ tiêu chuẩn IEEE-754 mà số JavaScript rút ra. Giá trị "không phải là số" không bao giờ bằng chính nó, ngay cả khi các bit là khớp chính xác. (Điều mà chúng không nhất thiết phải có trong IEEE-754, nó cho phép nhiều giá trị "không phải là số" khác nhau.) Đó là lý do tại sao điều này thậm chí xuất hiện; tất cả các giá trị khác trong JavaScript đều bằng chính chúng, NaNchỉ là đặc biệt.

... Tôi có thiếu một số giá trị trong JavaScript sẽ trả về true cho x! == x và false cho x! = x?

Không, bạn không phải. Sự khác biệt duy nhất giữa !==và !=là cái sau sẽ thực hiện cưỡng chế kiểu nếu cần thiết để có được các loại toán hạng giống nhau. Trong x != x, các loại toán hạng là như nhau, và do đó, nó chính xác giống như x !== x.

Điều này rõ ràng từ đầu định nghĩa của Hoạt động bình đẳng trừu tượng :

1. Trả về IfAbrupt (x).
2. Trả về IfAbrupt (y).

3. Nếu Loại (x) giống với Loại (y), thì

   Trả về kết quả thực hiện So sánh bình đẳng nghiêm ngặt x === y.

4. ...

Hai bước đầu tiên là hệ thống ống nước cơ bản. Vì vậy, trong thực tế, bước đầu tiên ==là xem các loại có giống nhau không và nếu có thì phải làm gì ===. !=và !==chỉ là phiên bản phủ định của điều đó.

Vì vậy, nếu Flanagan đúng mà chỉ NaNđúng x !== x, chúng ta có thể chắc chắn rằng điều đó cũng đúng mà chỉ NaNđúngx != x .

Nhiều lập trình viên JavaScript mặc định sử dụng ===và !==để tránh một số cạm bẫy xung quanh kiểu ép buộc mà các nhà khai thác lỏng lẻo làm, nhưng không có gì để đọc về việc Flanagan sử dụng toán tử nghiêm ngặt so với lỏng trong trường hợp này.

Đối với mục đích của NaN, !=và !==làm điều tương tự.

Tuy nhiên, nhiều lập trình viên tránh ==hoặc !=bằng JavaScript. Ví dụ: Douglas Crockford coi chúng là một trong những " phần xấu " của ngôn ngữ JavaScript vì chúng hành xử theo những cách bất ngờ và khó hiểu:

JavaScript có hai bộ toán tử đẳng thức: ===và !==, cặp song sinh xấu xa của chúng ==và !=. Những người tốt làm việc theo cách bạn mong đợi.

... Lời khuyên của tôi là đừng bao giờ sử dụng cặp song sinh độc ác. Thay vào đó, luôn luôn sử dụng ===và !==.

Để cho vui, hãy để tôi chỉ cho bạn một ví dụ nhân tạo xkhông có NaNnhưng các toán tử cư xử khác đi. Xác định đầu tiên:

Object.defineProperty(
  self,
  'x',
  { get: function() { return self.y = self.y ? 0 : '0'; } }
);

Sau đó chúng tôi có

x != x // false

nhưng

x !== x // true

Tôi chỉ muốn chỉ ra NaNkhông phải là thứ duy nhất tạo ra x !== xmà không sử dụng đối tượng toàn cầu. Có rất nhiều cách thông minh để kích hoạt hành vi này. Đây là một cách sử dụng getters:

var i = 0, obj = { get x() { return i++; }};
with(obj) // force dynamic context, this is evil. 
console.log(x === x); // false

Như các câu trả lời khác chỉ ra, ==thực hiện coersion loại, nhưng như trong các ngôn ngữ khác và ngang bằng với tiêu chuẩn - NaN chỉ ra lỗi tính toán và vì lý do chính đáng không bằng chính nó.

Vì một số lý do ngoài tôi, mọi người cho rằng đây là một vấn đề với JS, nhưng hầu hết các ngôn ngữ có gấp đôi (cụ thể là C, Java, C ++, C #, Python và các ngôn ngữ khác) thể hiện hành vi chính xác này và mọi người đều ổn với nó.

Đôi khi, hình ảnh tốt hơn từ ngữ, hãy kiểm tra bảng này (đó là lý do để tôi đưa ra câu trả lời thay vì nhận xét là vì nó có khả năng hiển thị tốt hơn).

Ở đó bạn có thể thấy rằng so sánh bình đẳng nghiêm ngặt (===) chỉ trả về đúng nếu loại và nội dung khớp, vì vậy

var f = "-1" === -1; //false

Trong khi so sánh đẳng thức trừu tượng (==) chỉ kiểm tra nội dung * bằng cách chuyển đổi các loại và sau đó so sánh nghiêm ngặt chúng:

var t = "-1" == -1; //true

Mặc dù không rõ ràng, nhưng không tham khảo ECMA , những gì JavaScript xem xét khi so sánh, theo cách mà mã dưới đây đánh giá là đúng.

 var howAmISupposedToKnowThat = [] == false; //true