Hướng dẫn why does javascript use === instead of ==? - tại sao javascript sử dụng === thay vì ==?

Toán tử bình đẳng nghiêm ngặt (

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Tham khảo: Hướng dẫn JavaScript: Các toán tử so sánh

Toán tử

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Để trích dẫn JavaScript xuất sắc của Douglas Crockford: Những phần tốt,

JavaScript có hai bộ toán tử bình đẳng:

true === 1; //false
"2" === 2;  //false

4 và

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

1, và cặp song sinh độc ác của họ

true === 1; //false
"2" === 2;  //false

5 và

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

3. Những người tốt làm việc theo cách bạn mong đợi. Nếu hai toán hạng có cùng loại và có cùng một giá trị, thì

true === 1; //false
"2" === 2;  //false

4 sẽ tạo ra

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

5 và

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

1 tạo ra

true === 1; //false
"2" === 2;  //false

9. Cặp song sinh độc ác làm điều đúng đắn khi các vở kịch cùng loại, nhưng nếu chúng thuộc các loại khác nhau, họ cố gắng ép buộc các giá trị. Các quy tắc mà họ làm là phức tạp và không đáng tin cậy. Đây là một số trường hợp thú vị:

'' == '0'           // false
0 == ''             // true
0 == '0'            // true

false == 'false'    // false
false == '0'        // true

false == undefined  // false
false == null       // false
null == undefined   // true

' \t\r\n ' == 0     // true

Việc thiếu sự chuyển tiếp là đáng báo động. Lời khuyên của tôi là đừng bao giờ sử dụng cặp song sinh tà ác. Thay vào đó, luôn luôn sử dụng

true === 1; //false
"2" === 2;  //false

4 và

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

1. Tất cả các so sánh chỉ hiển thị sản xuất

true === 1; //false
"2" === 2;  //false

9 với toán tử

true === 1; //false
"2" === 2;  //false

4.

Update:

Một điểm tốt đã được đưa ra bởi @CaseBash trong các bình luận và trong câu trả lời của @phillipe Laybaert liên quan đến các đối tượng. Đối với các đối tượng,

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Trường hợp đặc biệt là khi bạn so sánh nguyên thủy với một đối tượng đánh giá theo cùng một nguyên thủy, do phương pháp

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Ở đây, toán tử

true === 1; //false
"2" === 2;  //false

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Tài liệu tham khảo http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

Đã trả lời ngày 11 tháng 12 năm 2008 lúc 14:25Dec 11, 2008 at 14:25

Bill the Lizardbill the LizardBill the Lizard

391K207 Huy hiệu vàng558 Huy hiệu bạc867 Huy hiệu đồng207 gold badges558 silver badges867 bronze badges

6

Sử dụng toán tử

true === 1; //false
"2" === 2;  //false

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Sử dụng toán tử

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Điều này là do toán tử bình đẳng

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Mặt khác, toán tử nhận dạng

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

1

Đây là một hình ảnh thú vị về sự so sánh bình đẳng giữa

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Nguồn: https://github.com/dorey/javaScript-equality-Table (bản demo, bản demo thống nhất) (demo, unified demo)

var a = { }; var b = { }; var c = a; var ab_eq = (a === b); // false (even though a and b are the same type) var ac_eq = (a === c); // true 8

Khi sử dụng

true === 1; //false
"2" === 2;  //false

var a = "12" + "3"; var b = "123"; alert(a === b); // returns true, because strings behave like value types 0

Khi sử dụng

true === 1; //false
"2" === 2;  //false

Tóm tắt sự bình đẳng trong JavaScript

Sự kết luận:

Luôn luôn sử dụng

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Mateen Ulhaq

22.2K16 Huy hiệu vàng86 Huy hiệu bạc127 Huy hiệu đồng16 gold badges86 silver badges127 bronze badges

Đã trả lời ngày 5 tháng 5 năm 2014 lúc 5:21May 5, 2014 at 5:21

SnagsnagSNag

17.1k10 Huy hiệu vàng50 Huy hiệu bạc65 Huy hiệu Đồng10 gold badges50 silver badges65 bronze badges

8

Trong câu trả lời ở đây, tôi đã không đọc bất cứ điều gì về ý nghĩa của bình đẳng. Một số người sẽ nói rằng

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Vì vậy, hãy lấy mã sau:

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Tương tự ở đây:

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Hoặc thậm chí:

var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Hành vi này không phải lúc nào cũng rõ ràng. Có nhiều câu chuyện hơn là bình đẳng và cùng loại.

Quy tắc là:

Đối với các loại giá trị (số):

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

Đối với các loại tham chiếu:

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

Đối với các chuỗi:

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

Chuỗi: Trường hợp đặc biệt ...

Chuỗi không phải là loại giá trị, nhưng trong JavaScript, chúng hoạt động như các loại giá trị, vì vậy chúng sẽ "bằng nhau" khi các ký tự trong chuỗi giống nhau và khi chúng có cùng độ dài (như được giải thích trong quy tắc thứ ba)

Bây giờ nó trở nên thú vị:

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

Nhưng còn điều này thì sao?:

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

Tôi nghĩ rằng các chuỗi hoạt động như các loại giá trị? Chà, nó phụ thuộc vào người bạn hỏi ... trong trường hợp này A và B không giống nhau.

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

Đã trả lời ngày 5 tháng 6 năm 2009 lúc 19:11Jun 5, 2009 at 19:11

Philippe Leybaertphilippe LeybaertPhilippe Leybaert

165K31 Huy hiệu vàng210 Huy hiệu bạc222 Huy hiệu đồng31 gold badges210 silver badges222 bronze badges

0

Hãy để tôi thêm lời khuyên này:

Nếu nghi ngờ, hãy đọc đặc điểm kỹ thuật!

ECMA-262 là đặc điểm kỹ thuật cho ngôn ngữ kịch bản trong đó JavaScript là một phương ngữ. Tất nhiên trong thực tế, vấn đề quan trọng hơn là cách các trình duyệt quan trọng nhất hoạt động hơn là một định nghĩa bí truyền về cách xử lý một cái gì đó được cho là. Nhưng thật hữu ích khi hiểu tại sao chuỗi mới ("A")! == "A".new String("a") !== "a".

Xin vui lòng cho tôi giải thích cách đọc thông số kỹ thuật để làm rõ câu hỏi này. Tôi thấy rằng trong chủ đề rất cũ này, không ai có câu trả lời cho hiệu ứng rất kỳ lạ. Vì vậy, nếu bạn có thể đọc một đặc điểm kỹ thuật, điều này sẽ giúp bạn trong nghề nghiệp của bạn rất nhiều. Đó là một kỹ năng có được. Vì vậy, hãy tiếp tục.

Tìm kiếm tệp PDF cho === đưa tôi đến trang 56 của thông số kỹ thuật: 11.9.4. Các toán tử tương đương với toán tử (===) và sau khi lội qua thông số kỹ thuật mà tôi tìm thấy:11.9.4. The Strict Equals Operator ( === ), and after wading through the specificationalese I find:

11.9.6 Thuật toán so sánh bình đẳng nghiêm ngặt Các so sánh x === y, trong đó x và y là các giá trị, tạo ra đúng hoặc sai. Một so sánh như vậy được thực hiện như sau: & nbsp; & nbsp; 1. Nếu loại (x) khác với loại (y), trả về false. & nbsp; & nbsp; 2. Nếu loại (x) không được xác định, hãy trả về đúng. & nbsp; & nbsp; 3. Nếu loại (x) là null, trả về true. & nbsp; & nbsp; 4. Nếu loại (x) không phải là số, hãy chuyển sang bước 11. & nbsp; & nbsp; 5. Nếu x là nan, hãy trả lại sai. & nbsp; & nbsp; 6. Nếu y là nan, hãy trả lại sai. & nbsp; & nbsp; 7. Nếu x là giá trị số giống như y, hãy trả về true. & nbsp; & nbsp; 8. Nếu x là +0 và y là −0, hãy trả về đúng. & nbsp; & nbsp; 9. Nếu x là −0 và y là +0, hãy trả về đúng. & nbsp; & nbsp; 10. Trả lại sai. & nbsp; & nbsp; 11. Nếu loại (x) là chuỗi, thì hãy trả về true nếu x và y chính xác là cùng một chuỗi các ký tự (cùng độ dài và cùng một ký tự trong các vị trí tương ứng); Nếu không, trả lại sai. & nbsp; & nbsp; 12. Nếu loại (x) là boolean, hãy trả về true nếu x và y đều đúng hoặc cả hai sai; Nếu không, trả lại sai. & nbsp; & nbsp; 13. Trả về true nếu x và y đề cập đến cùng một đối tượng hoặc nếu chúng đề cập đến các đối tượng được nối với nhau (xem 13.1.2). Nếu không, trả lại sai.
The comparison x === y, where x and y are values, produces true or false. Such a comparison is performed as follows:
  1. If Type(x) is different from Type(y), return false.
  2. If Type(x) is Undefined, return true.
  3. If Type(x) is Null, return true.
  4. If Type(x) is not Number, go to step 11.
  5. If x is NaN, return false.
  6. If y is NaN, return false.
  7. If x is the same number value as y, return true.
  8. If x is +0 and y is −0, return true.
  9. If x is −0 and y is +0, return true.
  10. Return false.
  11. If Type(x) is String, then return true if x and y are exactly the same sequence of characters (same length and same characters in corresponding positions); otherwise, return false.
  12. If Type(x) is Boolean, return true if x and y are both true or both false; otherwise, return false.
  13. Return true if x and y refer to the same object or if they refer to objects joined to each other (see 13.1.2). Otherwise, return false.

Thú vị là bước 11. Có, chuỗi được coi là loại giá trị. Nhưng điều này không giải thích tại sao chuỗi mới ("A")! == "A". Chúng ta có trình duyệt không phù hợp với ECMA-262 không?new String("a") !== "a". Do we have a browser not conforming to ECMA-262?

Không quá nhanh!

Hãy kiểm tra các loại của toán hạng. Hãy thử nó cho chính mình bằng cách gói chúng trong typeof (). Tôi thấy rằng chuỗi mới ("A") là một đối tượng và bước 1 được sử dụng: trả về sai nếu các loại khác nhau.typeof(). I find that new String("a") is an object, and step 1 is used: return false if the types are different.

Nếu bạn tự hỏi tại sao chuỗi mới ("A") không trả lại một chuỗi, làm thế nào về một số bài tập đọc một đặc điểm kỹ thuật? Chúc vui vẻ!new String("a") does not return a string, how about some exercise reading a specification? Have fun!

Aidiakapi đã viết điều này trong một bình luận dưới đây:

Từ đặc điểm kỹ thuật

11.2.2 Toán tử mới::

Nếu loại (trình xây dựng) không phải là đối tượng, hãy ném một ngoại lệ kiểu.

Với các từ khác, nếu chuỗi không thuộc loại đối tượng thì nó không thể được sử dụng với toán tử mới.

Mới luôn trả về một đối tượng, ngay cả đối với các bộ xây dựng chuỗi, quá. Và than ôi! Các ngữ nghĩa giá trị cho các chuỗi (xem Bước 11) bị mất. always returns an Object, even for String constructors, too. And alas! The value semantics for strings (see step 11) is lost.

Và điều này cuối cùng có nghĩa là: Chuỗi mới ("A")! == "A".new String("a") !== "a".

Đã trả lời ngày 28 tháng 11 năm 2009 lúc 18:18Nov 28, 2009 at 18:18

nalplynalplynalply

24.8K12 Huy hiệu vàng79 Huy hiệu bạc96 Huy hiệu Đồng12 gold badges79 silver badges96 bronze badges

Tôi đã thử nghiệm điều này trong Firefox với Firebug bằng mã như thế này:

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

và

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Kết quả của tôi (được thử nghiệm năm lần mỗi lần và tính trung bình):

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Vì vậy, tôi muốn nói rằng sự khác biệt nhỏ (đây là hơn 100000 lần lặp, hãy nhớ) là không đáng kể. Hiệu suất không phải là lý do để làm

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Kabirbaidhya

3.0643 Huy hiệu vàng33 Huy hiệu bạc53 Huy hiệu Đồng3 gold badges33 silver badges53 bronze badges

Đã trả lời ngày 25 tháng 12 năm 2008 lúc 11:17Dec 25, 2008 at 11:17

Khăn quàng cổ SimonSimon Scarfe

9.1404 Huy hiệu vàng27 Huy hiệu bạc32 Huy hiệu Đồng4 gold badges27 silver badges32 bronze badges

3

Trong PHP và JavaScript, nó là một toán tử bình đẳng nghiêm ngặt. Có nghĩa là, nó sẽ so sánh cả loại và giá trị.

Đã trả lời ngày 12 tháng 5 năm 2010 lúc 12:58May 12, 2010 at 12:58

ShikishikiShiki

16.6K7 Huy hiệu vàng31 Huy hiệu bạc33 Huy hiệu đồng7 gold badges31 silver badges33 bronze badges

Trong JavaScript, nó có nghĩa là cùng một giá trị và loại.

Ví dụ,

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

nhưng

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Đã trả lời ngày 12 tháng 5 năm 2010 lúc 12:58May 12, 2010 at 12:58

ShikishikiDimitar

16.6K7 Huy hiệu vàng31 Huy hiệu bạc33 Huy hiệu đồng2 gold badges19 silver badges28 bronze badges

0

Trong JavaScript, nó có nghĩa là cùng một giá trị và loại.

Ví dụ,

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Đúng, điều đó đúng theo

true === 1; //false
"2" === 2;  //false

Và nó không kết thúc ở đó, đây là một cái khác:

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Mọi thứ trở nên thực sự kỳ lạ với các mảng.

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Sau đó, Weirder với String

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Nó trở nên tồi tệ hơn:

Khi nào không bằng nhau?

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Hãy để tôi nói rằng một lần nữa:

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Và đây chỉ là những thứ điên rồ mà bạn có được với những người nguyên thủy.

Đó là một cấp độ hoàn toàn mới điên rồ khi bạn sử dụng

true === 1; //false
"2" === 2;  //false

Tại thời điểm này, bạn có thể tự hỏi ...

Lý do tại sao điều này xảy ra?

Vâng, vì không giống như "Triple Equals" (

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Nó có xử lý đặc biệt cho các chức năng, xử lý đặc biệt cho null, không xác định, chuỗi, bạn đặt tên cho nó.

Nó trở nên khá lập dị.

Trên thực tế, nếu bạn đã cố gắng viết một hàm thực hiện những gì

true === 1; //false
"2" === 2;  //false

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Vì vậy, điều này có nghĩa là gì?

Nó có nghĩa là

true === 1; //false
"2" === 2;  //false

Bởi vì nó phức tạp, thật khó để biết điều gì sẽ xảy ra khi bạn sử dụng nó.

Điều đó có nghĩa là bạn có thể kết thúc với lỗi.

Vì vậy, đạo đức của câu chuyện là ...

Làm cho cuộc sống của bạn bớt phức tạp hơn.

Sử dụng

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Kết thúc.

Đã trả lời ngày 9 tháng 8 năm 2016 lúc 16:50Aug 9, 2016 at 16:50

Luis Perezluis PerezLuis Perez

27.1k10 Huy hiệu vàng78 Huy hiệu bạc80 Huy hiệu đồng10 gold badges78 silver badges80 bronze badges

1

Toán tử === được gọi là toán tử so sánh nghiêm ngặt, nó khác với toán tử ==.=== operator is called a strict comparison operator, it does differ from the == operator.

Hãy lấy 2 vars a và b.

Đối với "A == B" để đánh giá thành True A và B cần phải là cùng một giá trị."a == b" to evaluate to true a and b need to be the same value.

Trong trường hợp của "A === B" A và B phải là cùng một giá trị và cũng cùng loại để đánh giá đúng."a === b" a and b must be the same value and also the same type for it to evaluate to true.

Lấy ví dụ sau

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Tóm tắt; Sử dụng toán tử == có thể đánh giá thành true trong các tình huống mà bạn không muốn nó sử dụng toán tử === sẽ an toàn hơn.; using the == operator might evaluate to true in situations where you do not want it to so using the === operator would be safer.

Trong kịch bản sử dụng 90%, bạn sẽ không quan trọng cái nào bạn sử dụng, nhưng thật tiện dụng khi biết sự khác biệt khi bạn có một số hành vi bất ngờ một ngày.

Đã trả lời ngày 11 tháng 12 năm 2008 lúc 14:58Dec 11, 2008 at 14:58

Bác sĩ Jonesdoctor JonesDoctor Jones

20.7K12 Huy hiệu vàng75 Huy hiệu bạc98 Huy hiệu đồng12 gold badges75 silver badges98 bronze badges

0

true === 1; //false "2" === 2; //false 4 Kiểm tra cùng các cạnh bằng loại cũng như giá trị.

Example:

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Ví dụ chung:

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Một ví dụ phổ biến khác:

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Nhiều lần một kiểm tra chưa được xác định sẽ tiện dụng vì bạn không quan tâm nếu giá trị là

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Đã trả lời ngày 12 tháng 5 năm 2010 lúc 12:58May 12, 2010 at 12:58

vsyncvsyncvsync

108K54 Huy hiệu vàng286 Huy hiệu bạc371 Huy hiệu Đồng54 gold badges286 silver badges371 bronze badges

0

Sơ đồ luồng thực thi JavaScript cho bình đẳng / so sánh nghiêm ngặt '==='

Sơ đồ luồng thực thi JavaScript cho bình đẳng / so sánh không nghiêm ngặt '=='

Đã trả lời ngày 5 tháng 9 năm 2015 lúc 13:53Sep 5, 2015 at 13:53

Samar Pandasamar PandaSamar Panda

3.9963 huy hiệu vàng24 Huy hiệu bạc32 Huy hiệu đồng3 gold badges24 silver badges32 bronze badges

0

JavaScript

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Đã trả lời ngày 3 tháng 7 năm 2013 lúc 4:08Jul 3, 2013 at 4:08

0

Nó có nghĩa là bình đẳng mà không có loại ép buộc loại ép buộc có nghĩa là javascript không tự động chuyển đổi bất kỳ loại dữ liệu nào khác thành các loại dữ liệu chuỗiequality without type coercion type coercion means JavaScript do not automatically convert any other data types to string data types

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Đã trả lời ngày 12 tháng 5 năm 2010 lúc 12:59May 12, 2010 at 12:59

Pop Catalinpop CatalinPop Catalin

60.3k22 Huy hiệu vàng88 Huy hiệu bạc113 Huy hiệu đồng22 gold badges88 silver badges113 bronze badges

0

Trong một kịch bản điển hình sẽ không có sự khác biệt về hiệu suất. Quan trọng hơn có thể là thực tế là hàng ngàn "===" là 1 & nbsp; KB nặng hơn hàng nghìn "==" :) Các trình cấu hình javascript có thể cho bạn biết nếu có sự khác biệt về hiệu suất trong trường hợp của bạn.

Nhưng cá nhân tôi sẽ làm những gì jslint gợi ý. Khuyến nghị này không có vì các vấn đề về hiệu suất, mà bởi vì sự ép buộc loại có nghĩa là

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Đã trả lời ngày 16 tháng 12 năm 2008 lúc 14:29Dec 16, 2008 at 14:29

ConstantinconstantinConstantin

26.9k10 Huy hiệu vàng59 Huy hiệu bạc79 Huy hiệu đồng10 gold badges59 silver badges79 bronze badges

0

Toán tử so sánh bằng nhau == là khó hiểu và nên tránh.

Nếu bạn phải sống với nó, thì hãy nhớ 3 điều sau:HAVE TO live with it, then remember the following 3 things:

1. Nó không chuyển tiếp: (a == b) và (b == c) không dẫn đến (a == c)
2. Nó loại trừ lẫn nhau với sự phủ định của nó: (a == b) và (a! = B) luôn giữ các giá trị boolean đối diện, với tất cả a và b.
3. Trong trường hợp nghi ngờ, hãy học theo trái tim Bảng sự thật sau:

Bảng sự thật của toán tử bằng nhau trong JavaScript

• Mỗi hàng trong bảng là một tập hợp 3 giá trị "bằng" lẫn nhau, có nghĩa là bất kỳ 2 giá trị nào trong số chúng bằng nhau bằng cách sử dụng dấu hiệu bằng nhau ==*

** lạ: Lưu ý rằng bất kỳ hai giá trị nào trên cột đầu tiên không bằng nhau theo nghĩa đó. **

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Đã trả lời ngày 16 tháng 9 năm 2011 lúc 14:25Sep 16, 2011 at 14:25

CuonghuytocuonghuytoCuongHuyTo

1.28313 Huy hiệu bạc19 Huy hiệu đồng13 silver badges19 bronze badges

0

Không có khả năng có bất kỳ sự khác biệt hiệu suất giữa hai hoạt động trong việc sử dụng của bạn. Không có chuyển đổi loại nào được thực hiện vì cả hai tham số đã cùng loại. Cả hai hoạt động sẽ có một so sánh loại theo sau là so sánh giá trị.

Đã trả lời ngày 11 tháng 12 năm 2008 lúc 14:44Dec 11, 2008 at 14:44

SeanseanSean

2.2251 Huy hiệu vàng24 Huy hiệu bạc31 Huy hiệu đồng1 gold badge24 silver badges31 bronze badges

0

Đúng! Nó không thành vấn đề. It does matter.

Toán tử

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Bạn có thể dễ dàng kiểm tra nó. Dán mã sau vào tệp HTML và mở nó trong trình duyệt

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Bạn sẽ nhận được 'sai' trong cảnh báo. Bây giờ sửa đổi phương thức

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Đã trả lời ngày 14 tháng 11 năm 2014 lúc 6:02Nov 14, 2014 at 6:02

Aniket Thakuraniket ThakurAniket Thakur

64.6K37 Huy hiệu vàng270 Huy hiệu bạc284 Huy hiệu đồng37 gold badges270 silver badges284 bronze badges

0

Đơn giản

true === 1; //false
"2" === 2;  //false

và

true === 1; //false
"2" === 2;  //false

Loại cưỡng chế trong JavaScript có nghĩa là tự động chuyển đổi các loại dữ liệu sang các loại dữ liệu khác.

Ví dụ:

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Đã trả lời ngày 20 tháng 3 năm 2015 lúc 5:05Mar 20, 2015 at 5:05

AmitamitAmit

7979 Huy hiệu bạc15 Huy hiệu Đồng9 silver badges15 bronze badges

Theo nguyên tắc thông thường, tôi thường sẽ sử dụng

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Lý do được giải thích trong các câu trả lời ở trên và Douglas Crockford khá rõ ràng về nó (JavaScript: phần tốt).

Tuy nhiên, có một ngoại lệ duy nhất:

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Ví dụ, JQuery 1.9.1 sử dụng mẫu này 43 lần và trình kiểm tra cú pháp JSHINT thậm chí còn cung cấp tùy chọn thư giãn

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Từ hướng dẫn phong cách jQuery:

Kiểm tra bình đẳng nghiêm ngặt (===) nên được sử dụng có lợi cho ==. Ngoại lệ duy nhất là khi kiểm tra không xác định và null bằng null.

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Chỉnh sửa 2021-03:

Ngày nay, hầu hết các trình duyệt đều hỗ trợ toán tử kết hợp Nullish (

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

có thể được viết như bất kỳ hình thức nào trong số này

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Đã trả lời ngày 27 tháng 4 năm 2013 lúc 14:15Apr 27, 2013 at 14:15

mar10mar10mar10

13.6K5 Huy hiệu vàng38 Huy hiệu bạc63 Huy hiệu Đồng5 gold badges38 silver badges63 bronze badges

1

Đó là một bài kiểm tra kiểm tra nghiêm ngặt.

Đó là một điều tốt, đặc biệt là nếu bạn đang kiểm tra giữa 0 và false và null.

Ví dụ: nếu bạn có:

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Then:

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Tất cả trả lại đúng và bạn có thể không muốn điều này. Chúng ta hãy giả sử bạn có một chức năng có thể trả về chỉ số 0 của một mảng hoặc sai khi thất bại. Nếu bạn kiểm tra với "==" Sai, bạn có thể nhận được kết quả khó hiểu.

Vì vậy, với điều tương tự như trên, nhưng một bài kiểm tra nghiêm ngặt:

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Đã trả lời ngày 12 tháng 5 năm 2010 lúc 13:19May 12, 2010 at 13:19

DanieldanielDaniel

8806 Huy hiệu bạc5 Huy hiệu Đồng6 silver badges5 bronze badges

1

Toán tử

true === 1; //false
"2" === 2;  //false

Toán tử

true === 1; //false
"2" === 2;  //false

Alex Weitz

3.0124 Huy hiệu vàng32 Huy hiệu bạc 50 Huy hiệu Đồng4 gold badges32 silver badges50 bronze badges

Đã trả lời ngày 12 tháng 5 năm 2010 lúc 13:03May 12, 2010 at 13:03

JSLINT đôi khi cung cấp cho bạn những lý do không thực tế để sửa đổi công cụ.

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Nó chỉ nhanh hơn khi các loại không giống nhau, trong trường hợp đó nó không cố gắng chuyển đổi các loại nhưng trực tiếp trả lại sai.

Vì vậy, IMHO, JSLINT có thể được sử dụng để viết mã mới, nhưng nên tránh quá mức quá mức bằng mọi giá.

Có nghĩa là, không có lý do gì để thay đổi

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Sửa đổi rất nhiều mã đó để lãng phí thời gian của các nhà phát triển và không đạt được.

Alex Weitz

3.0124 Huy hiệu vàng32 Huy hiệu bạc 50 Huy hiệu Đồng4 gold badges32 silver badges50 bronze badges

Đã trả lời ngày 12 tháng 5 năm 2010 lúc 13:03Jun 5, 2012 at 7:53

JSLINT đôi khi cung cấp cho bạn những lý do không thực tế để sửa đổi công cụ.

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Nó chỉ nhanh hơn khi các loại không giống nhau, trong trường hợp đó nó không cố gắng chuyển đổi các loại nhưng trực tiếp trả lại sai.1 gold badge6 silver badges9 bronze badges

1

Vì vậy, IMHO, JSLINT có thể được sử dụng để viết mã mới, nhưng nên tránh quá mức quá mức bằng mọi giá.

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Có nghĩa là, không có lý do gì để thay đổi

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Sửa đổi rất nhiều mã đó để lãng phí thời gian của các nhà phát triển và không đạt được.Vikas

Đã trả lời ngày 5 tháng 6 năm 2012 lúc 7:531 gold badge33 silver badges39 bronze badges

Tro tàn

6111 Huy hiệu vàng6 Huy hiệu bạc9 Huy hiệu đồng

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Một ví dụ đơn giản là

Đã trả lời ngày 14 tháng 5 năm 2015 lúc 14:45

VikasvikasSep 9, 2013 at 8:31

4.1931 Huy hiệu vàng33 Huy hiệu bạc39 Huy hiệu đồngHarry He

2 câu trả lời hàng đầu được đề cập == có nghĩa là bình đẳng và === có nghĩa là danh tính. Thật không may, tuyên bố này là không chính xác.16 silver badges12 bronze badges

Nếu cả hai toán hạng của == là đối tượng, thì chúng được so sánh để xem chúng có phải là cùng một đối tượng không. Nếu cả hai toán tử chỉ vào cùng một đối tượng, thì toán tử bằng nhau sẽ trả về true. Nếu không, cả hai không bằng nhau.

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Trong mã ở trên, cả hai == và === Nhận sai vì A và B không phải là cùng một đối tượng.

true === 1; //false
"2" === 2;  //false

Điều nào rõ ràng trong thời gian chạy thực hiện những điều không xác định ...

Google để chuyển đổi ngầm trong C ++ và STL để có được một số đối số chống lại nó ...

Đã trả lời ngày 29 tháng 12 năm 2008 lúc 11:54Dec 29, 2008 at 11:54

Thomas Hansenthomas HansenThomas Hansen

5.5231 Huy hiệu vàng22 Huy hiệu bạc28 Huy hiệu đồng1 gold badge22 silver badges28 bronze badges

1

Từ tham chiếu JavaScript cốt lõi

true === 1; //false
"2" === 2;  //false

4 Trả về

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

5 Nếu các toán hạng hoàn toàn bằng (xem ở trên) không có chuyển đổi loại.

Đã trả lời ngày 12 tháng 5 năm 2010 lúc 12:59May 12, 2010 at 12:59

Paul Butcherpaul ButcherPaul Butcher

6.82427 Huy hiệu bạc39 Huy hiệu đồng27 silver badges39 bronze badges

So sánh bình đẳng:

Nhà điều hành

true === 1; //false
"2" === 2;  //false

Trả về đúng, khi cả hai toán hạng đều bằng nhau. Các toán hạng được chuyển đổi thành cùng loại trước khi được so sánh.

true === 1; //false
"2" === 2;  //false

Bình đẳng và so sánh loại:

Nhà điều hành

true === 1; //false
"2" === 2;  //false

Trả về true nếu cả hai toán hạng đều bằng nhau và cùng loại. Nói chung sẽ tốt hơn và an toàn hơn nếu bạn so sánh theo cách này, bởi vì không có chuyển đổi kiểu hậu trường.

true === 1; //false
"2" === 2;  //false

Đã trả lời ngày 2 tháng 10 năm 2013 lúc 21:54Oct 2, 2013 at 21:54

user2601995user2601995user2601995

6.0958 Huy hiệu vàng36 Huy hiệu bạc41 Huy hiệu đồng8 gold badges36 silver badges41 bronze badges

Dưới đây là một bảng so sánh tiện dụng cho thấy các chuyển đổi xảy ra và sự khác biệt giữa

true === 1; //false
"2" === 2;  //false

true === 1; //false
"2" === 2;  //false

Như kết luận nêu rõ:

"Sử dụng ba bằng trừ khi bạn hoàn toàn hiểu các chuyển đổi diễn ra cho hai bình đẳng."

http://dorey.github.io/JavaScript-Equality-Table/

Bonifacio2

3.0684 Huy hiệu vàng33 Huy hiệu bạc49 Huy hiệu đồng4 gold badges33 silver badges49 bronze badges

Đã trả lời ngày 27 tháng 3 năm 2014 lúc 0:18Mar 27, 2014 at 0:18

null và không xác định là hư vô, nghĩa là,

true === 1; //false
"2" === 2;  //false

Ở đây

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

Vì vậy, 0, sai và '' cùng nhau tạo thành một nhóm phụ. Và mặt khác, Null & không xác định tạo thành nhóm phụ thứ hai. Kiểm tra các so sánh trong hình ảnh dưới đây. null và không xác định sẽ bằng nhau. Ba người kia sẽ bằng nhau. Nhưng, tất cả đều được coi là điều kiện giả trong JavaScript.

Điều này giống như bất kỳ đối tượng nào (như {}, mảng, v.v.), chuỗi không trống & boolean true là tất cả các điều kiện sự thật. Nhưng, tất cả họ không bình đẳng.

Tại sao chúng ta sử dụng === thay vì ==?

Tại sao chúng ta sử dụng == và === trong JavaScript?

Bạn nên sử dụng === hoặc ==?

Tại sao JavaScript sử dụng 3 dấu hiệu bằng nhau?