So sánh một nhóm ký tự javascript năm 2024

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 thù quan trọng.

Nội dung chính

1. Boolean là kết quả trả về khi so sánh

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ó – đúng

• alert( 'Z' > 'A' ); // true alert( 'Glow' > 'Glee' ); // true alert( 'Bee' > 'Be' ); // true

  3 – có nghĩa là không có sự khác biệt, không đúng sự thật.

Ví dụ:

/*
Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
@author cafedevn
Contact: [email protected]
Fanpage: https://www.facebook.com/cafedevn
Instagram: https://instagram.com/cafedevn
Twitter: https://twitter.com/CafedeVn
Linkedin: https://www.linkedin.com/in/cafe-dev-407054199/
*/
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

2. So sánh chuỗi

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

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 rất đơ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 thứ nhất lớn hơn (hoặc ít hơn) so với chuỗi khác, thì chuỗi đầu tiên lớn hơn (hoặc ít hơn) so với chuỗi thứ hai.
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 một độ dài, thì chúng bằng nhau. Nếu không, chuỗi dài hơn là lớn hơn.

Trong các ví dụ ở trên, việc so sánh

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

4đạt được kết quả ở bước đầu tiên trong khi các chuỗi

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

5và

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

6được so sánh theo từng ký tự:

1. alert( 'Z' > 'A' ); // true alert( 'Glow' > 'Glee' ); // true alert( 'Bee' > 'Be' ); // true

   7cũ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

   9cũng giống như

   alert( 'Z' > 'A' ); // true alert( 'Glow' > 'Glee' ); // true alert( 'Bee' > 'Be' ); // true

   9.

3. alert( '2' > 1 ); // true, string '2' becomes a number 2 alert( '01' == 1 ); // true, string '01' becomes a number 1

   1lớn hơn

   alert( '2' > 1 ); // true, string '2' becomes a number 2 alert( '01' == 1 ); // true, string '01' becomes a number 1

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

Nó không phải là một từ điển thực sự, nhưng nó theo thứ tự của 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. Một chữ in hoa

alert( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

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

alert( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

4. Cái nào lớn hơn? Chữ thường

alert( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

4. Tại sao? Bởi vì ký tự chữ thường có chỉ mục lớn hơn trong bảng mã hóa nội bộ mà JavaScript sử dụng (Unicode). 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.

3. So sánh các kiểu khác nhau

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

Ví dụ:

alert( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

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

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

2trở thành

alert( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

7và

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

3trở thành

alert( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

9.

Ví dụ:

alert( true == 1 ); // true
alert( false == 0 ); // true

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ố đó là

  alert( 'Z' > 'A' ); // true alert( 'Glow' > 'Glee' ); // true alert( 'Bee' > 'Be' ); // true

  2 và một trong số đó là

  alert( 'Z' > 'A' ); // true alert( 'Glow' > 'Glee' ); // true alert( 'Bee' > 'Be' ); // true

  3.

Ví dụ:

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

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( true == 1 ); // true
alert( false == 0 ); // true

2trở thành

alert( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

9), trong khi

alert( true == 1 ); // true
alert( false == 0 ); // true

4chuyển đổi rõ ràng sử dụng một bộ quy tắc khác.

Một kiểm tra bình đẳng

let result = 5 > 4; // assign the result of the comparison
alert( result ); // true

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

alert( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

9với

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

3:

alert( 0 == false ); // true

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

alert( '' == false ); // true

Điều này xảy ra bởi vì toán hạng của các kiểu 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( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

9từ

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

3?

Một toán tử đẳng thức nghiêm ngặt

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

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

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

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

3và

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

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

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

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

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

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

Hãy thử nó:

alert( 0 === false ); // false, because the types are different

Ngoài ra còn có một toán tử khắt khe không bình đẳng,

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

7tương tự

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

8.

Toán tử so sánh bằng 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.

5. So sánh với null và không xác định

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

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

9hoặc

alert( 0 == false ); // true

0được so sánh với các giá trị khác. Đối với một kiểm tra so sánh bình đẳng nghiêm ngặt

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

2

Các giá trị này là khác nhau, bởi vì mỗi trong số chúng là một kiểu khác nhau.

alert( null === undefined ); // false

Đối với một 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: họ ngang nhau (theo nghĩa

let result = 5 > 4; // assign the result of the comparison
alert( result ); // true

8).

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

alert( 0 == false ); // true

4

alert( 0 == false ); // true

5được chuyển đổi thành số:

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

9trở thành

alert( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

9, trong khi

alert( 0 == false ); // true

0trở thành

alert( 0 == false ); // true

9.

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 với chúng.

5.1 Kết quả kỳ lạ: null vs 0

Hãy so sánh

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

9với số 0:

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 lạ. Kết quả cuối cùng nói rằng

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

9lớn hơn hoặc bằng 0, do đó, trong một trong những so sánh ở trên thì phải

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

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

Lý do là một kiểm tra bằng

let result = 5 > 4; // assign the result of the comparison
alert( result ); // true

8và so sánh

alert( '' == false ); // true

4hoạt động khác nhau. So sánh chuyển đổi

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

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

alert( '2' > 1 ); // true, string '2' becomes a number 2
alert( '01' == 1 ); // true, string '01' becomes a number 1

9. Đó là lý do tại sao dòng (3)

alert( '' == false ); // true

7là đúng và dòng (1)

alert( '' == false ); // true

8là sai.

Mặt khác, việc kiểm tra bình đẳng

let result = 5 > 4; // assign the result of the comparison
alert( result ); // true

8cho

alert( 0 == false ); // true

0và

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

9được định nghĩa như vậy mà, mà không cần bất kỳ chuyển đổi, họ tương đương với nhau và làm bất cứ điều gì không bằng. Đó là lý do tại sao (2)

alert( 0 === false ); // false, because the types are different

2là sai.

5.2 Không thể so sánh với không xác định

Giá trị

alert( 0 == false ); // true

0không nên được so sánh 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ố 0 nhiều như vậy? Luôn luôn sai!

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

• So sánh

  alert( 0 === false ); // false, because the types are different

  4và

  alert( 0 === false ); // false, because the types are different

  5trả về

  alert( 'Z' > 'A' ); // true alert( 'Glow' > 'Glee' ); // true alert( 'Bee' > 'Be' ); // true

  3vì

  alert( 0 == false ); // true

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

  alert( 0 == false ); // true

  9và

  alert( 0 == false ); // true

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

  alert( 'Z' > 'A' ); // true alert( 'Glow' > 'Glee' ); // true alert( 'Bee' > 'Be' ); // true

  3cho tất cả các so sánh.

• alert( null === undefined ); // false

  1 thành

  alert( 'Z' > 'A' ); // true alert( 'Glow' > 'Glee' ); // true alert( 'Bee' > 'Be' ); // true

  3bởi vì

  alert( 0 == false ); // true

  0chỉ bằng

  let a = 0; alert( Boolean(a) ); // false let b = "0"; alert( Boolean(b) ); // true alert(a == b); // true!

  9,

  alert( 0 == false ); // true

  0và 0 có giá trị khác.

5.3 Trốn tránh vấn đề

Tại sao chúng ta đi qua những ví dụ này? Chúng ta có nên nhớ những đặc thù này mọi lúc không? Vâng, không thực sự. Trên thực tế, những điều khó khăn này sẽ dần trở nên quen thuộc theo thời gian, nhưng có một cách vững chắc để trốn tránh các vấn đề với chúng:

Chỉ cần đối xử với bất kỳ so sánh với

alert( null === undefined ); // false

6ngoại trừ sự bình đẳng nghiêm ngặt

let a = 0;
alert( Boolean(a) ); // false
let b = "0";
alert( Boolean(b) ); // true
alert(a == b); // true!

2.

Đừng sử dụng so sánh

alert( null === undefined ); // false

8với một biến có thể

alert( 0 == false ); // true

5, trừ khi bạn thực sự chắc chắn về những gì bạn đang làm. Nếu một biến có thể có các giá trị này, hãy kiểm tra chúng một cách riêng biệt.