Sử dụng phương thức compareTo()
1) So sánh chuỗi bằng phương thức equals()
Phương thức equals() được sử dụng để so sánh nội dung của 2 chuỗi. Lớp String cung cấp 2 phương thức equals():
- public boolean equals(Object another): so sánh 2 chuỗi có phân biệt chữ hoa, chữ thường.
- public boolean equalsIgnoreCase(String another): so sánh 2 chuỗi không phân biệt chữ hoa, chữ thường.
Ví dụ 1:
public class Teststringcomparison1 {
public static void main(String args[]) {
String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");
String s4 = "Hallo";
System.out.println(s1.equals(s2));//true
System.out.println(s1.equals(s3));//true
System.out.println(s1.equals(s4));//false
}
}
Output:
Ví dụ 2:
public class Teststringcomparison2 {
public static void main(String args[]) {
String s1 = "Hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));//false
System.out.println(s1.equalsIgnoreCase(s2));//true
}
}
Output:
2) So sánh chuỗi bằng toán tử ==
Toán tử == được sử dụng để so sánh tham chiếu (không phải giá trị) của 2 chuỗi.
Ví dụ 3:
public class Teststringcomparison3 {
public static void main(String args[]) {
String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");
System.out.println(s1 == s2);//true (vì cả 2 cùng tham chiếu instance giống nhau)
System.out.println(s1 == s3);//false(vì s3 tham chiếu instance mà không ở trong Pool)
}
}
Output:
3) So sánh chuỗi bằng phương thức compareTo()
Phương thức compareTo () so sánh các giá trị theo thứ tự từ điển và trả về một giá trị số nguyên mô tả nếu chuỗi đầu tiên nhỏ hơn, bằng hoặc lớn hơn chuỗi thứ hai.
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.
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
alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true
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:
- So sánh ký tự đầu tiên của cả hai chuỗi.
- 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.
- 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.
- Lặp lại cho đến khi kết thúc một trong hai chuỗi.
- 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ự:
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
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
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
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
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ì:
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.
