Cách thích hợp để so sánh nếu hai giá trị bằng nhau trong biểu thức boolean trong javascript là gì?

Trong bài viết này, chúng ta sẽ tìm hiểu thêm về các loại so sánh khác nhau, cách JavaScript tạo ra chúng, bao gồm các đặc điểm quan trọng

Cuối cùng, bạn sẽ tìm thấy một công thức hay để tránh các vấn đề liên quan đến “JavaScript quirks”

Tất cả các toán tử so sánh trả về một giá trị boolean

• alert[ 'Z' > 'A' ]; // true
  alert[ 'Glow' > 'Glee' ]; // true
  alert[ 'Bee' > 'Be' ]; // true

  2 – có nghĩa là “có”, “chính xác” hoặc “sự thật”

• alert[ 'Z' > 'A' ]; // true
  alert[ 'Glow' > 'Glee' ]; // true
  alert[ 'Bee' > 'Be' ]; // true

  3 – có nghĩa là “không”, “sai” hoặc “không phải sự thật”

Ví dụ

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

Một kết quả so sánh có thể được gán cho một biến, giống như bất kỳ giá trị nào

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

Để xem liệu một chuỗi có lớn hơn chuỗi khác hay không, JavaScript sử dụng cái gọi là thứ tự "từ điển" hoặc "từ điển"

Nói cách khác, các chuỗi được so sánh từng chữ cái

Ví dụ

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

Thuật toán so sánh hai chuỗi đơn giản

1. So sánh ký tự đầu tiên của cả hai chuỗi
2. Nếu ký tự đầu tiên từ chuỗi đầu tiên lớn hơn [hoặc nhỏ hơn] so với chuỗi khác, thì chuỗi đầu tiên lớn hơn [hoặc nhỏ hơn] chuỗi thứ hai. Đã được thực hiện
3. Mặt khác, nếu các ký tự đầu tiên của cả hai chuỗi giống nhau, hãy so sánh các ký tự thứ hai theo cùng một cách
4. Lặp lại cho đến khi kết thúc một trong hai chuỗi
5. Nếu cả hai chuỗi kết thúc ở cùng độ dài, thì chúng bằng nhau. Mặt khác, chuỗi dài hơn lớn hơn

Trong ví dụ đầu tiên ở trên, so sánh

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

4 có kết quả ở bước đầu tiên

Phép so sánh thứ hai

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

5 và

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

6 cần nhiều bước hơn vì các chuỗi được so sánh theo từng ký tự

1. alert[ 'Z' > 'A' ]; // true
   alert[ 'Glow' > 'Glee' ]; // true
   alert[ 'Bee' > 'Be' ]; // true

   7 cũng giống như

   alert[ 'Z' > 'A' ]; // true
   alert[ 'Glow' > 'Glee' ]; // true
   alert[ 'Bee' > 'Be' ]; // true

   7

2. alert[ 'Z' > 'A' ]; // true
   alert[ 'Glow' > 'Glee' ]; // true
   alert[ 'Bee' > 'Be' ]; // true

   9 cũng giống như

   alert[ 'Z' > 'A' ]; // true
   alert[ 'Glow' > 'Glee' ]; // true
   alert[ 'Bee' > 'Be' ]; // true

   9

3. alert[ 'Z' > 'A' ]; // true
   alert[ 'Glow' > 'Glee' ]; // true
   alert[ 'Bee' > 'Be' ]; // true

   21 lớn hơn

   alert[ 'Z' > 'A' ]; // true
   alert[ 'Glow' > 'Glee' ]; // true
   alert[ 'Bee' > 'Be' ]; // true

   22. Dừng ở đây. Chuỗi đầu tiên lớn hơn

Không phải là một từ điển thực sự, nhưng theo thứ tự Unicode

Thuật toán so sánh được đưa ra ở trên gần tương đương với thuật toán được sử dụng trong từ điển hoặc danh bạ điện thoại, nhưng nó không hoàn toàn giống nhau

Ví dụ, trường hợp quan trọng. Chữ hoa

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

23 không bằng chữ thường

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

24. Cái nào lớn hơn? . Tại sao? . Chúng ta sẽ quay lại chi tiết cụ thể và hậu quả của điều này trong chương Chuỗi

Khi so sánh các giá trị của các loại khác nhau, JavaScript sẽ chuyển đổi các giá trị thành số

Ví dụ

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

2

Đối với các giá trị boolean,

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

2 trở thành

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

27 và

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

3 trở thành

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

29

Ví dụ

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

2

Một hậu quả buồn cười

Có thể là cùng một lúc

• Hai giá trị bằng nhau
• Một trong số chúng là

  alert[ 'Z' > 'A' ]; // true
  alert[ 'Glow' > 'Glee' ]; // true
  alert[ 'Bee' > 'Be' ]; // true

  2 dưới dạng boolean và cái còn lại là

  alert[ 'Z' > 'A' ]; // true
  alert[ 'Glow' > 'Glee' ]; // true
  alert[ 'Bee' > 'Be' ]; // true

  3 dưới dạng boolean

Ví dụ

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

5

Từ quan điểm của JavaScript, kết quả này là khá bình thường. Kiểm tra đẳng thức chuyển đổi các giá trị bằng cách sử dụng chuyển đổi số [do đó,

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

22 trở thành

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

29], trong khi chuyển đổi rõ ràng

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

24 sử dụng một bộ quy tắc khác

Kiểm tra bình đẳng thường xuyên

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

8 có vấn đề. Nó không thể phân biệt

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

29 với

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

3

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

2

Điều tương tự cũng xảy ra với một chuỗi rỗng

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

3

Điều này xảy ra vì các toán hạng thuộc các loại khác nhau được chuyển đổi thành số bởi toán tử đẳng thức

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

8. Một chuỗi rỗng, giống như

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

3, trở thành số không

Phải làm gì nếu chúng tôi muốn phân biệt

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

29 với

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

3?

Toán tử đẳng thức nghiêm ngặt

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

52 kiểm tra đẳng thức mà không cần chuyển đổi kiểu

Nói cách khác, nếu

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

53 và

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

54 thuộc các loại khác nhau, thì

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

55 ngay lập tức trả về

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

3 mà không cần chuyển đổi chúng

Hãy thử nó

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

3

Ngoài ra còn có một toán tử "không bình đẳng nghiêm ngặt"

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

57 tương tự như

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

58

Toán tử đẳng thức nghiêm ngặt dài hơn một chút để viết, nhưng làm cho nó rõ ràng những gì đang xảy ra và để lại ít lỗi hơn

Có một hành vi không trực quan khi

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

59 hoặc

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

20 được so sánh với các giá trị khác

Để kiểm tra bình đẳng nghiêm ngặt

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

52

Các giá trị này khác nhau, bởi vì mỗi giá trị là một loại khác nhau

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

9

Để kiểm tra không nghiêm ngặt

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

8

Có một quy tắc đặc biệt. Hai người này là một “cặp đôi ngọt ngào”. chúng bằng nhau [theo nghĩa của

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

8], nhưng không phải bất kỳ giá trị nào khác

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

0

Đối với toán học và so sánh khác

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

24

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

25 được chuyển thành số.

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

59 trở thành

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

29, trong khi

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

20 trở thành

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

29

Bây giờ hãy xem một số điều thú vị xảy ra khi chúng ta áp dụng các quy tắc này. Và, điều quan trọng hơn, làm thế nào để không rơi vào bẫy của họ

Hãy so sánh

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

59 với số không

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

1

Về mặt toán học, điều đó thật kỳ lạ. Kết quả cuối cùng cho biết "

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

59 lớn hơn hoặc bằng 0", vì vậy một trong các so sánh ở trên phải là

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

2, nhưng cả hai đều sai

Lý do là kiểm tra đẳng thức

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

8 và so sánh

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

34 hoạt động khác nhau. Phép so sánh chuyển đổi

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

59 thành một số, coi nó là

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

29. Đó là lý do tại sao [3]

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

37 là đúng và [1]

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

38 là sai

Mặt khác, kiểm tra đẳng thức

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

8 cho

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

20 và

alert[ 2 > 1 ];  // true [correct]
alert[ 2 == 1 ]; // false [wrong]
alert[ 2 != 1 ]; // true [correct]

59 được xác định sao cho, không có bất kỳ chuyển đổi nào, chúng bằng nhau và không bằng bất kỳ thứ gì khác. Đó là lý do tại sao [2]

alert[ 'Z' > 'A' ]; // true
alert[ 'Glow' > 'Glee' ]; // true
alert[ 'Bee' > 'Be' ]; // true

32 là sai

Không nên so sánh giá trị

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

20 với các giá trị khác

let result = 5 > 4; // assign the result of the comparison
alert[ result ]; // true

2

Tại sao nó không thích số không nhiều như vậy?

Chúng tôi nhận được những kết quả này bởi vì

• So sánh

  alert[ 'Z' > 'A' ]; // true
  alert[ 'Glow' > 'Glee' ]; // true
  alert[ 'Bee' > 'Be' ]; // true

  34 và

  alert[ 'Z' > 'A' ]; // true
  alert[ 'Glow' > 'Glee' ]; // true
  alert[ 'Bee' > 'Be' ]; // true

  35 trả về

  alert[ 'Z' > 'A' ]; // true
  alert[ 'Glow' > 'Glee' ]; // true
  alert[ 'Bee' > 'Be' ]; // true

  3 vì

  let result = 5 > 4; // assign the result of the comparison
  alert[ result ]; // true

  20 được chuyển đổi thành

  let result = 5 > 4; // assign the result of the comparison
  alert[ result ]; // true

  29 và

  let result = 5 > 4; // assign the result of the comparison
  alert[ result ]; // true

  29 là một giá trị số đặc biệt trả về

  alert[ 'Z' > 'A' ]; // true
  alert[ 'Glow' > 'Glee' ]; // true
  alert[ 'Bee' > 'Be' ]; // true

  3 cho tất cả các phép so sánh
• Kiểm tra đẳng thức

  alert[ 'Z' > 'A' ]; // true
  alert[ 'Glow' > 'Glee' ]; // true
  alert[ 'Bee' > 'Be' ]; // true

  91 trả về

  alert[ 'Z' > 'A' ]; // true
  alert[ 'Glow' > 'Glee' ]; // true
  alert[ 'Bee' > 'Be' ]; // true

  3 vì

  let result = 5 > 4; // assign the result of the comparison
  alert[ result ]; // true

  20 chỉ bằng với

  alert[ 2 > 1 ];  // true [correct]
  alert[ 2 == 1 ]; // false [wrong]
  alert[ 2 != 1 ]; // true [correct]

  59,

  let result = 5 > 4; // assign the result of the comparison
  alert[ result ]; // true

  20 và không có giá trị nào khác

Tại sao chúng ta đi qua những ví dụ này? . Trên thực tế, những điều phức tạp này sẽ dần trở nên quen thuộc theo thời gian, nhưng có một cách chắc chắn để tránh các vấn đề với chúng

Cách thích hợp để so sánh nếu hai giá trị bằng nhau trong biểu thức Boolean là gì?

Cách thích hợp để so sánh nếu hai giá trị không bằng nhau trong biểu thức Boolean trong JavaScript là gì?

Cách thích hợp để so sánh nếu hai giá trị bằng nhau trong biểu thức Boolean trong Python là gì?

Làm cách nào để kiểm tra xem hai số có bằng nhau trong JavaScript không?