JavaScript cung cấp ba hoạt động so sánh giá trị khác nhau: Hoạt động nào bạn chọn phụ thuộc vào loại so sánh bạn đang tìm kiếm để thực hiện. Tóm tắt: Chúng tương ứng với ba trong số bốn thuật toán bình đẳng trong JavaScript: Lưu ý rằng sự khác biệt giữa tất cả những điều này phải làm với việc xử lý các nguyên thủy của họ; Không ai trong số họ so sánh liệu các tham số có giống nhau về mặt cấu trúc hay không. Đối với bất kỳ đối tượng không nguyên thủy nào ===
- Bình đẳng nghiêm ngặt [ba bằng]==
- Bình đẳng lỏng lẻo [bằng kép]Object.is[]
==
] sẽ thực hiện chuyển đổi loại khi so sánh hai điều và sẽ xử lý
1, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 và console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
3 đặc biệt để phù hợp với IEEE 754 [vì vậy console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
4 và console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
5];console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
===
] sẽ thực hiện so sánh tương tự như bằng kép [bao gồm cả việc xử lý đặc biệt cho
1, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 và console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
3] nhưng không chuyển đổi loại; Nếu các loại khác nhau, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
0 được trả lại.const num = 0;
const big = 0n;
const str = "0";
const obj = new String["0"];
console.log[num == str]; // true
console.log[big == num]; // true
console.log[str == big]; // true
console.log[num == obj]; // true
console.log[big == obj]; // true
console.log[str == obj]; // true
Object.is[]
không chuyển đổi loại và không xử lý đặc biệt cho
1, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 và console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
3 [cho nó hành vi tương tự như console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
===
ngoại trừ trên các giá trị số đặc biệt đó].==
===
Object.is[]
9 và const num = 0;
const big = 0n;
const str = "0";
const obj = new String["0"];
console.log[num == str]; // true
console.log[big == num]; // true
console.log[str == big]; // true
console.log[num == obj]; // true
console.log[big == obj]; // true
console.log[str == obj]; // true
0 có cùng cấu trúc nhưng là các đối tượng riêng biệt, tất cả các hình thức trên sẽ đánh giá thành // Add an immutable NEGATIVE_ZERO property to the Number constructor.
Object.defineProperty[Number, "NEGATIVE_ZERO", {
value: -0,
writable: false,
configurable: false,
enumerable: false,
}];
function attemptMutation[v] {
Object.defineProperty[Number, "NEGATIVE_ZERO", { value: v }];
}
0.const num = 0;
const big = 0n;
const str = "0";
const obj = new String["0"];
console.log[num == str]; // true
console.log[big == num]; // true
console.log[str == big]; // true
console.log[num == obj]; // true
console.log[big == obj]; // true
console.log[str == obj]; // true
Bình đẳng nghiêm ngặt bằng cách sử dụng ===
Bình đẳng nghiêm ngặt so sánh hai giá trị cho sự bình đẳng. Không giá trị nào được chuyển đổi hoàn toàn thành một số giá trị khác trước khi được so sánh. Nếu các giá trị có các loại khác nhau, các giá trị được coi là không đồng đều. Nếu các giá trị có cùng loại, không phải là số và có cùng một giá trị, chúng được coi là bằng nhau. Cuối cùng, nếu cả hai giá trị là số, chúng được coi là bằng nhau nếu cả hai đều không
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1 và là cùng một giá trị, hoặc nếu một là console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
3 và một là console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2.const num = 0;
const obj = new String["0"];
const str = "0";
console.log[num === num]; // true
console.log[obj === obj]; // true
console.log[str === str]; // true
console.log[num === obj]; // false
console.log[num === str]; // false
console.log[obj === str]; // false
console.log[null === undefined]; // false
console.log[obj === null]; // false
console.log[obj === undefined]; // false
Bình đẳng nghiêm ngặt hầu như luôn luôn là hoạt động so sánh chính xác để sử dụng. Đối với tất cả các giá trị ngoại trừ các số, nó sử dụng ngữ nghĩa rõ ràng: một giá trị chỉ bằng với chính nó. Đối với các con số, nó sử dụng ngữ nghĩa hơi khác nhau để đánh bóng qua hai trường hợp cạnh khác nhau. Đầu tiên là điểm nổi bằng 0 là có dấu tích cực hoặc tiêu cực. Điều này rất hữu ích trong việc thể hiện các giải pháp toán học nhất định, nhưng vì hầu hết các tình huống không quan tâm đến sự khác biệt giữa
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
3 và console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2, sự bình đẳng nghiêm ngặt coi chúng là cùng một giá trị. Thứ hai là điểm nổi bao gồm khái niệm về giá trị không phải là một số, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1, để thể hiện giải pháp cho một số vấn đề toán học không xác định: vô cực tiêu cực được thêm vào vô cùng dương tính. Bình đẳng nghiêm ngặt đối xử với console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1 là không đồng đều với mọi giá trị khác - bao gồm cả chính nó. [Trường hợp duy nhất trong đó // Add an immutable NEGATIVE_ZERO property to the Number constructor.
Object.defineProperty[Number, "NEGATIVE_ZERO", {
value: -0,
writable: false,
configurable: false,
enumerable: false,
}];
function attemptMutation[v] {
Object.defineProperty[Number, "NEGATIVE_ZERO", { value: v }];
}
9 là function sameValueZero[x, y] {
if [typeof x === "number" && typeof y === "number"] {
// x and y are equal [may be -0 and 0] or they are both NaN
return x === y || [x !== x && y !== y];
}
return x === y;
}
0 là khi const num = 0;
const big = 0n;
const str = "0";
const obj = new String["0"];
console.log[num == str]; // true
console.log[big == num]; // true
console.log[str == big]; // true
console.log[num == obj]; // true
console.log[big == obj]; // true
console.log[str == obj]; // true
9 là console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1.]Bên cạnh ===
, sự bình đẳng nghiêm ngặt cũng được sử dụng bởi các phương pháp tìm chỉ số mảng bao gồm
function sameValueZero[x, y] {
if [typeof x === "number" && typeof y === "number"] {
// x and y are equal [may be -0 and 0] or they are both NaN
return x === y || [x !== x && y !== y];
}
return x === y;
}
4, function sameValueZero[x, y] {
if [typeof x === "number" && typeof y === "number"] {
// x and y are equal [may be -0 and 0] or they are both NaN
return x === y || [x !== x && y !== y];
}
return x === y;
}
5, function sameValueZero[x, y] {
if [typeof x === "number" && typeof y === "number"] {
// x and y are equal [may be -0 and 0] or they are both NaN
return x === y || [x !== x && y !== y];
}
return x === y;
}
6, function sameValueZero[x, y] {
if [typeof x === "number" && typeof y === "number"] {
// x and y are equal [may be -0 and 0] or they are both NaN
return x === y || [x !== x && y !== y];
}
return x === y;
}
7 và ________ 48 phù hợp. Điều này có nghĩa là bạn không thể sử dụng function sameValueZero[x, y] {
if [typeof x === "number" && typeof y === "number"] {
// x and y are equal [may be -0 and 0] or they are both NaN
return x === y || [x !== x && y !== y];
}
return x === y;
}
9 để tìm chỉ số của giá trị console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1 trong một mảng hoặc sử dụng console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1 làm giá trị function sameValueZero[x, y] {
if [typeof x === "number" && typeof y === "number"] {
// x and y are equal [may be -0 and 0] or they are both NaN
return x === y || [x !== x && y !== y];
}
return x === y;
}
8 trong câu lệnh const stoppingForce = obj.mass * -obj.velocity;
3 và làm cho nó phù hợp với bất cứ điều gì.console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
Bình đẳng lỏng lẻo bằng cách sử dụng ==
Bình đẳng lỏng lẻo là đối xứng:
const stoppingForce = obj.mass * -obj.velocity;
4 luôn có ngữ nghĩa giống hệt nhau với const stoppingForce = obj.mass * -obj.velocity;
5 cho bất kỳ giá trị nào của const stoppingForce = obj.mass * -obj.velocity;
6 và const stoppingForce = obj.mass * -obj.velocity;
7 [ngoại trừ thứ tự chuyển đổi ứng dụng]. Hành vi để thực hiện bình đẳng lỏng lẻo bằng cách sử dụng ==
như sau:- Nếu các toán hạng có cùng loại, chúng được so sánh như sau:
- Đối tượng: Trả về
0 chỉ khi cả hai toán hạng tham chiếu cùng một đối tượng.function sameValueZero[x, y] { if [typeof x === "number" && typeof y === "number"] { // x and y are equal [may be -0 and 0] or they are both NaN return x === y || [x !== x && y !== y]; } return x === y; }
- Chuỗi: Trả về
0 chỉ khi cả hai toán hạng có cùng ký tự theo cùng một thứ tự.function sameValueZero[x, y] { if [typeof x === "number" && typeof y === "number"] { // x and y are equal [may be -0 and 0] or they are both NaN return x === y || [x !== x && y !== y]; } return x === y; }
- Số: Trả về
0 chỉ khi cả hai toán hạng có cùng giá trị.function sameValueZero[x, y] { if [typeof x === "number" && typeof y === "number"] { // x and y are equal [may be -0 and 0] or they are both NaN return x === y || [x !== x && y !== y]; } return x === y; }
3 vàconsole.log[[NaN].indexOf[NaN]]; // -1 switch [NaN] { case NaN: console.log["Surprise"]; // Nothing is logged }
2 được coi là cùng một giá trị. Nếu một trong hai toán hạng làconsole.log[[NaN].indexOf[NaN]]; // -1 switch [NaN] { case NaN: console.log["Surprise"]; // Nothing is logged }
1, hãy trả lạiconsole.log[[NaN].indexOf[NaN]]; // -1 switch [NaN] { case NaN: console.log["Surprise"]; // Nothing is logged }
0; Vì vậy,const num = 0; const big = 0n; const str = "0"; const obj = new String["0"]; console.log[num == str]; // true console.log[big == num]; // true console.log[str == big]; // true console.log[num == obj]; // true console.log[big == obj]; // true console.log[str == obj]; // true
1 không bao giờ bằngconsole.log[[NaN].indexOf[NaN]]; // -1 switch [NaN] { case NaN: console.log["Surprise"]; // Nothing is logged }
1.console.log[[NaN].indexOf[NaN]]; // -1 switch [NaN] { case NaN: console.log["Surprise"]; // Nothing is logged }
- Boolean: Trả về
0 chỉ khi toán hạng làfunction sameValueZero[x, y] { if [typeof x === "number" && typeof y === "number"] { // x and y are equal [may be -0 and 0] or they are both NaN return x === y || [x !== x && y !== y]; } return x === y; }
0 hoặc cảfunction sameValueZero[x, y] { if [typeof x === "number" && typeof y === "number"] { // x and y are equal [may be -0 and 0] or they are both NaN return x === y || [x !== x && y !== y]; } return x === y; }
0.const num = 0; const big = 0n; const str = "0"; const obj = new String["0"]; console.log[num == str]; // true console.log[big == num]; // true console.log[str == big]; // true console.log[num == obj]; // true console.log[big == obj]; // true console.log[str == obj]; // true
- BIGINT: Trả về
0 chỉ khi cả hai toán hạng có cùng giá trị.function sameValueZero[x, y] { if [typeof x === "number" && typeof y === "number"] { // x and y are equal [may be -0 and 0] or they are both NaN return x === y || [x !== x && y !== y]; } return x === y; }
- Biểu tượng: Trả về
0 chỉ khi cả hai toán hạng tham chiếu cùng một ký hiệu.function sameValueZero[x, y] { if [typeof x === "number" && typeof y === "number"] { // x and y are equal [may be -0 and 0] or they are both NaN return x === y || [x !== x && y !== y]; } return x === y; }
- Đối tượng: Trả về
- Nếu một trong các toán hạng là
===
3 hoặc===
4, thì cái còn lại cũng phải là===
3 hoặc===
4 để trả lại
0. Nếu không, hãy trả lạifunction sameValueZero[x, y] { if [typeof x === "number" && typeof y === "number"] { // x and y are equal [may be -0 and 0] or they are both NaN return x === y || [x !== x && y !== y]; } return x === y; }
0.const num = 0; const big = 0n; const str = "0"; const obj = new String["0"]; console.log[num == str]; // true console.log[big == num]; // true console.log[str == big]; // true console.log[num == obj]; // true console.log[big == obj]; // true console.log[str == obj]; // true
- Nếu một trong các toán hạng là một đối tượng và người kia là nguyên thủy, hãy chuyển đổi đối tượng thành nguyên thủy.
- Ở bước này, cả hai toán hạng được chuyển đổi thành nguyên thủy [một chuỗi, số, boolean, biểu tượng và bigint]. Phần còn lại của chuyển đổi được thực hiện từng trường hợp.
- Nếu chúng cùng loại, hãy so sánh chúng bằng cách sử dụng bước 1.
- Nếu một trong các toán hạng là một biểu tượng nhưng bản kia thì không, hãy trả lại
0.const num = 0; const big = 0n; const str = "0"; const obj = new String["0"]; console.log[num == str]; // true console.log[big == num]; // true console.log[str == big]; // true console.log[num == obj]; // true console.log[big == obj]; // true console.log[str == obj]; // true
- Nếu một trong các toán hạng là boolean nhưng cái còn lại thì không, hãy chuyển đổi boolean thành một số:
0 được chuyển đổi thành 1 vàfunction sameValueZero[x, y] { if [typeof x === "number" && typeof y === "number"] { // x and y are equal [may be -0 and 0] or they are both NaN return x === y || [x !== x && y !== y]; } return x === y; }
0 được chuyển đổi thành 0. sau đó so sánh hai toán hạng một lần nữa.const num = 0; const big = 0n; const str = "0"; const obj = new String["0"]; console.log[num == str]; // true console.log[big == num]; // true console.log[str == big]; // true console.log[num == obj]; // true console.log[big == obj]; // true console.log[str == obj]; // true
- Số thành chuỗi: Chuyển đổi chuỗi thành một số. Lỗi chuyển đổi dẫn đến
1, sẽ đảm bảo sự bình đẳng làconsole.log[[NaN].indexOf[NaN]]; // -1 switch [NaN] { case NaN: console.log["Surprise"]; // Nothing is logged }
0.const num = 0; const big = 0n; const str = "0"; const obj = new String["0"]; console.log[num == str]; // true console.log[big == num]; // true console.log[str == big]; // true console.log[num == obj]; // true console.log[big == obj]; // true console.log[str == obj]; // true
- Số với Bigint: So sánh bằng giá trị số của chúng. Nếu số là ± vô cực hoặc
1, hãy trả lạiconsole.log[[NaN].indexOf[NaN]]; // -1 switch [NaN] { case NaN: console.log["Surprise"]; // Nothing is logged }
0.const num = 0; const big = 0n; const str = "0"; const obj = new String["0"]; console.log[num == str]; // true console.log[big == num]; // true console.log[str == big]; // true console.log[num == obj]; // true console.log[big == obj]; // true console.log[str == obj]; // true
- Chuỗi thành Bigint: Chuyển đổi chuỗi thành Bigint bằng cách sử dụng cùng một thuật toán với hàm tạo
==
6. Nếu chuyển đổi thất bại, trả lại
0.const num = 0; const big = 0n; const str = "0"; const obj = new String["0"]; console.log[num == str]; // true console.log[big == num]; // true console.log[str == big]; // true console.log[num == obj]; // true console.log[big == obj]; // true console.log[str == obj]; // true
Theo truyền thống, và theo Ecmascript, tất cả các nguyên thủy và đối tượng đều không đồng đều với ===
4 và ===
3. Nhưng hầu hết các trình duyệt cho phép một lớp đối tượng rất hẹp [cụ thể là đối tượng Object.is[]
0 cho bất kỳ trang nào], trong một số bối cảnh, hành động như thể chúng mô phỏng giá trị ===
4. Bình đẳng lỏng lẻo là một trong những bối cảnh như vậy: Object.is[]
2 và Object.is[]
3 đánh giá đúng nếu, và chỉ khi, A là một đối tượng mô phỏng ===
4. Trong tất cả các trường hợp khác, một đối tượng không bao giờ lỏng lẻo bằng ===
4 hoặc ===
3.
Trong hầu hết các trường hợp, sử dụng bình đẳng lỏng lẻo là không được khuyến khích. Kết quả của việc so sánh sử dụng bình đẳng nghiêm ngặt dễ dự đoán hơn và có thể đánh giá nhanh hơn do thiếu sự ép buộc loại.
Ví dụ sau đây cho thấy các so sánh bình đẳng lỏng lẻo liên quan đến số lượng nguyên thủy Object.is[]
7, Object.is[]
8 nguyên thủy, chuỗi nguyên thủy Object.is[]
9 và một đối tượng có giá trị
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
00 là Object.is[]
9.const num = 0;
const big = 0n;
const str = "0";
const obj = new String["0"];
console.log[num == str]; // true
console.log[big == num]; // true
console.log[str == big]; // true
console.log[num == obj]; // true
console.log[big == obj]; // true
console.log[str == obj]; // true
Bình đẳng lỏng lẻo chỉ được sử dụng bởi toán tử ==
.
Bình đẳng có giá trị bằng cách sử dụng Object.is []
Bình đẳng cùng giá trị xác định xem hai giá trị có giống hệt nhau về mặt chức năng trong tất cả các bối cảnh hay không. [Trường hợp sử dụng này thể hiện một ví dụ về nguyên tắc thay thế Liskov.]
// Add an immutable NEGATIVE_ZERO property to the Number constructor.
Object.defineProperty[Number, "NEGATIVE_ZERO", {
value: -0,
writable: false,
configurable: false,
enumerable: false,
}];
function attemptMutation[v] {
Object.defineProperty[Number, "NEGATIVE_ZERO", { value: v }];
}
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
03 sẽ ném một ngoại lệ khi cố gắng thay đổi một tài sản bất biến, nhưng nó không làm gì nếu không có thay đổi thực tế được yêu cầu. Nếu console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
04 là console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2, không có thay đổi nào được yêu cầu và sẽ không có lỗi nào. Trong nội bộ, khi một thuộc tính bất biến được xác định lại, giá trị mới được chỉ định được so sánh với giá trị hiện tại sử dụng bình đẳng có giá trị.Bình đẳng cùng giá trị được cung cấp theo phương pháp
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
06. Nó được sử dụng hầu hết mọi nơi trong ngôn ngữ nơi dự kiến giá trị của bản sắc tương đương.Bình đẳng cùng giá trị
Tương tự như bình đẳng có giá trị, nhưng +0 và -0 được coi là bằng nhau.
Bình đẳng cùng giá trị không được phơi bày dưới dạng API JavaScript, nhưng có thể được triển khai bằng mã tùy chỉnh:
function sameValueZero[x, y] {
if [typeof x === "number" && typeof y === "number"] {
// x and y are equal [may be -0 and 0] or they are both NaN
return x === y || [x !== x && y !== y];
}
return x === y;
}
Cùng một giá trị-Zero chỉ khác với sự bình đẳng nghiêm ngặt bằng cách coi
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1 là tương đương và chỉ khác với bình đẳng có giá trị bằng cách coi console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 là tương đương với Object.is[]
7. Điều này làm cho nó thường có hành vi hợp lý nhất trong khi tìm kiếm, đặc biệt là khi làm việc với console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1. Nó được sử dụng bởi console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
11, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
12, cũng như các phương pháp console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
13 và console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
14 để so sánh bình đẳng chính.So sánh các phương pháp bình đẳng
Mọi người thường so sánh bằng kép và ba bằng cách nói một là phiên bản "nâng cao" của phiên bản kia. Ví dụ, Double Equals có thể được nói như là một phiên bản mở rộng của Triple Equals, bởi vì cái trước làm mọi thứ mà sau này làm, nhưng với chuyển đổi loại trên các toán hạng của nó - ví dụ,
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
15. Ngoài ra, có thể tuyên bố rằng Double Equals là đường cơ sở và Triple Equals là phiên bản nâng cao, bởi vì nó đòi hỏi hai toán hạng phải là cùng một loại, do đó, nó thêm một ràng buộc bổ sung.Tuy nhiên, cách suy nghĩ này ngụ ý rằng các so sánh bình đẳng tạo thành một "quang phổ" một chiều trong đó "hoàn toàn nghiêm ngặt" nằm ở một đầu và "hoàn toàn lỏng lẻo" nằm ở đầu kia. Mô hình này bị thiếu với
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
06, bởi vì nó không "lỏng hơn" so với bằng kép hoặc "nghiêm ngặt" so với ba bằng, cũng không phù hợp ở đâu đó ở giữa [tức là, cả hai chặt chẽ hơn gấp đôi, nhưng lỏng hơn ba bằng nhau]. Chúng ta có thể thấy từ bảng so sánh giống nhau bên dưới rằng điều này là do cách mà ____106 xử lý console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1. Lưu ý rằng nếu console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
19 được đánh giá là const num = 0;
const big = 0n;
const str = "0";
const obj = new String["0"];
console.log[num == str]; // true
console.log[big == num]; // true
console.log[str == big]; // true
console.log[num == obj]; // true
console.log[big == obj]; // true
console.log[str == obj]; // true
0, chúng ta có thể nói rằng nó phù hợp với phổ lỏng lẻo/nghiêm ngặt như một dạng ba thậm chí chặt chẽ hơn bằng nhau, một dạng phân biệt giữa console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 và console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
3. Tuy nhiên, việc xử lý console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1 có nghĩa là điều này là không đúng sự thật. Thật không may, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
06 phải được suy nghĩ về các đặc điểm cụ thể của nó, thay vì sự lỏng lẻo hoặc nghiêm ngặt của nó liên quan đến các nhà khai thác bình đẳng.Khi nào nên sử dụng Object.is [] so với ba bằng
Nói chung, lần duy nhất hành vi đặc biệt của ____ 106 đối với Zeros có thể sẽ được quan tâm là theo đuổi các chương trình lập trình meta nhất định, đặc biệt là về mô tả tài sản, khi công việc của bạn mong muốn phản ánh một số đặc điểm của
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
03. Nếu trường hợp sử dụng của bạn không yêu cầu điều này, nên tránh console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
06 và sử dụng ===
thay thế. Ngay cả khi các yêu cầu của bạn liên quan đến việc so sánh giữa hai giá trị console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1 được đánh giá là function sameValueZero[x, y] {
if [typeof x === "number" && typeof y === "number"] {
// x and y are equal [may be -0 and 0] or they are both NaN
return x === y || [x !== x && y !== y];
}
return x === y;
}
0, thì việc kiểm tra console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1 [sử dụng phương pháp console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
32 có sẵn từ các phiên bản trước của ECMAscript trước đây là cách sử dụng các phiên bản trước có thể ảnh hưởng đến Dấu hiệu của bất kỳ số không bạn gặp phải trong so sánh của bạn.Dưới đây là một danh sách các phương thức và nhà khai thác tích hợp có thể gây ra sự khác biệt giữa
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 và console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
3 để biểu hiện trong mã của bạn:console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
35 [phủ định không]Xem xét ví dụ sau:
const stoppingForce = obj.mass * -obj.velocity;
Nếu
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
36 là Object.is[]
7 [hoặc tính toán thành Object.is[]
7], một console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 được giới thiệu tại nơi đó và truyền ra vào console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
40.console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
41, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
42, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
43, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
44Trong một số trường hợp,
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 có thể được đưa vào biểu thức dưới dạng giá trị trả về của các phương thức này ngay cả khi không có console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 tồn tại dưới dạng một trong các tham số. Ví dụ, sử dụng console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
43 để nâng console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
48 lên sức mạnh của bất kỳ số mũ tiêu cực, số lẻ đánh giá thành console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2. Tham khảo tài liệu cho các phương pháp riêng lẻ.console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
50, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
51, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
52, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
53, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
54, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
55Có thể nhận được giá trị trả về
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 trong số các phương thức này trong một số trường hợp console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 tồn tại dưới dạng một trong các tham số. Ví dụ: console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
58 đánh giá thành console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2. Tham khảo tài liệu cho các phương pháp riêng lẻ.console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
60, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
61, console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
62Mỗi toán tử này sử dụng thuật toán TOINT32 bên trong. Vì chỉ có một đại diện cho 0 trong loại số nguyên 32 bit bên trong,
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 sẽ không tồn tại một chuyến đi khứ hồi sau khi hoạt động nghịch đảo. Ví dụ: cả console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
64 và console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
65 đánh giá thành const num = 0;
const big = 0n;
const str = "0";
const obj = new String["0"];
console.log[num == str]; // true
console.log[big == num]; // true
console.log[str == big]; // true
console.log[num == obj]; // true
console.log[big == obj]; // true
console.log[str == obj]; // true
0.Dựa vào
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
06 khi tính ký của số không được tính đến có thể gây nguy hiểm. Tất nhiên, khi ý định là phân biệt giữa console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
2 và console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
3, nó sẽ thực hiện chính xác những gì mong muốn.Hãy cẩn thận: Object.is [] và Nan
Đặc tả
console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
06 coi tất cả các trường hợp của console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1 là cùng một đối tượng. Tuy nhiên, vì các mảng được đánh máy có sẵn, chúng ta có thể có các biểu diễn điểm nổi riêng biệt của console.log[[NaN].indexOf[NaN]]; // -1
switch [NaN] {
case NaN: console.log["Surprise"]; // Nothing is logged
}
1 không hoạt động giống hệt nhau trong tất cả các bối cảnh. Ví dụ:const f2b = [x] => new Uint8Array[new Float64Array[[x]].buffer];
const b2f = [x] => new Float64Array[x.buffer][0];
// Get a byte representation of NaN
const n = f2b[NaN];
// Change the first bit, which is the sign bit and doesn't matter for NaN
n[0] = 1;
const nan2 = b2f[n];
console.log[nan2]; // NaN
console.log[Object.is[nan2, NaN]]; // true
console.log[f2b[NaN]]; // Uint8Array[8] [0, 0, 0, 0, 0, 0, 248, 127]
console.log[f2b[nan2]]; // Uint8Array[8] [1, 0, 0, 0, 0, 0, 248, 127]