Chuỗi so sánh theo thứ tự bảng chữ cái javascript

Với sự kết hợp của toán tử double equal hoặc triple equal với các phương thức chuỗi, chúng ta có thể dễ dàng so sánh các chuỗi theo cách phân biệt chữ hoa và chữ thường. Tuy nhiên, điều này không tính đến các ký tự trong các chuỗi không phải tiếng Anh như tiếng Pháp hoặc tiếng Ý. Những ngôn ngữ này có bảng chữ cái có thể chứa dấu, thứ không được nhận dạng trong so sánh chuỗi thông thường

Để xử lý tình huống này, chúng ta có thể sử dụng đối tượng

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
3 để so sánh các chuỗi có dấu hoặc cho các ngôn ngữ khác nhau. Đối tượng
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
3 là một hàm tạo cho bộ đối chiếu, là đối tượng cho phép chúng ta so sánh các ký tự theo cách nhạy cảm với ngôn ngữ. Với Collators, chúng ta có thể so sánh thứ tự của các ký tự đơn theo ngôn ngữ được chỉ định

Cách sử dụng bộ đối chiếu cơ bản để so sánh đẳng thức chuỗi

Để sử dụng bộ đối chiếu, chúng ta có thể xây dựng một đối tượng Bộ đối chiếu và sau đó sử dụng phương thức

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
5 của nó. Phương thức
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
5 thực hiện so sánh thứ tự bảng chữ cái của toàn bộ chuỗi dựa trên ngôn ngữ. Ví dụ: nếu chúng ta muốn so sánh hai chuỗi trong tiếng Đức theo thứ tự bảng chữ cái của nó, chúng ta có thể viết đoạn mã sau

const collator = new Intl.Collator('de');
const order = collator.compare('Ü', 'ß');
console.log(order);

Chúng tôi đã tạo đối tượng Collator bằng cách viết

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
7 để xác định rằng chúng tôi đang so sánh các chuỗi trong bảng chữ cái tiếng Đức. Sau đó, chúng ta sử dụng phương thức
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
5 đã tạo, phương thức này nhận 2 tham số là 2 chuỗi mà bạn muốn so sánh ở dạng chuỗi

Sau đó, một số được trả về từ hàm

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
5.
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
0 được trả về nếu chuỗi trong tham số đầu tiên xuất hiện sau tham số thứ hai theo thứ tự bảng chữ cái,
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
1 nếu cả hai chuỗi giống nhau và
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
2 được trả về nếu chuỗi trong tham số đầu tiên xuất hiện trước chuỗi thứ hai theo thứ tự bảng chữ cái

Vì vậy, nếu chúng ta đảo ngược thứ tự của các chuỗi như trong đoạn mã dưới đây

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);

Sau đó, kết quả đầu ra

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
3 -1

Nếu chúng giống nhau, giống như trong đoạn mã sau

________số 8_______

Sau đó, chúng tôi nhận được 0 trả lại cho

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
4

Để tóm tắt. Nếu các chuỗi bằng nhau, hàm trả về

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
1. Nếu chúng không bằng nhau, hàm trả về
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
0 hoặc
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
2 cũng cho biết thứ tự bảng chữ cái của các chuỗi

Sử dụng nâng cao

Bộ sắp xếp hữu ích vì chúng ta có thể đặt nó trong phương thức

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
8 như một hàm gọi lại để sắp xếp nhiều chuỗi trong mảng. Ví dụ: nếu chúng ta có nhiều chuỗi tiếng Đức trong một mảng, như trong mã bên dưới

const collator = new Intl.Collator('de');
const sortedLetters = ['Z', 'Ä', 'Ö', 'Ü', 'ß'].sort(collator.compare);
console.log(sortedLetters);

Sau đó, chúng tôi nhận được

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
9

Hàm tạo có một số tùy chọn có tính đến các tính năng của bảng chữ cái của các ngôn ngữ khác nhau. Như chúng ta có thể thấy ở trên, tham số đầu tiên trong hàm tạo là ngôn ngữ, là thẻ ngôn ngữ BCP-47 hoặc một mảng các thẻ như vậy. Đây là một tham số tùy chọn. Một danh sách rút gọn các thẻ ngôn ngữ BCP-47 bao gồm

  • ar — tiếng Ả Rập
  • bg — tiếng Bulgari
  • ca — tiếng Catalunya
  • zh-Hans — Tiếng Trung, Hán (Biến thể giản thể)
  • cs — tiếng Séc
  • da — Đan Mạch
  • de - tiếng Đức
  • el — Tiếng Hy Lạp hiện đại (1453 trở về sau)
  • vi — tiếng Anh
  • es — tiếng Tây Ban Nha
  • fi — tiếng Phần Lan
  • fr — tiếng Pháp
  • anh ấy - tiếng Do Thái
  • hu — tiếng Hungary
  • là - tiếng Iceland
  • nó - Ý
  • ja — tiếng Nhật
  • ko — Hàn Quốc
  • nl — tiếng Hà Lan
  • không — tiếng Na Uy
  • pl — tiếng Ba Lan
  • pt — tiếng Bồ Đào Nha
  • rm — Romansh
  • ro — tiếng Rumani
  • ru - tiếng Nga
  • giờ — tiếng Croatia
  • sk — tiếng Slovak
  • sq — Tiếng Albania
  • sv — Thụy Điển
  • thứ — tiếng Thái
  • tr — Thổ Nhĩ Kỳ
  • bạn — tiếng Urdu
  • id — Indonesia
  • Anh — Ukraina
  • là — người Bêlarut
  • sl — tiếng Slovenia
  • et — tiếng Estonia
  • lv — Tiếng Latvia
  • lt — tiếng Litva
  • tg — Tajik
  • fa — Persian
  • vi — Tiếng Việt
  • hy — tiếng Armenia
  • az — tiếng Azerbaijan
  • eu — xứ Basque
  • hsb — Thượng Sorbia
  • mk — Tiếng Macedonia
  • tn — Tswana
  • xh — Xhosa
  • zu — Zulu
  • af — tiếng Nam Phi
  • ka — tiếng Gruzia
  • cho — tiếng Faroe
  • xin chào - tiếng Hindi
  • mt — Tiếng Malta
  • se — Bắc Sami
  • ga — Irish
  • ms — tiếng Mã Lai (ngôn ngữ vĩ mô)
  • kk — tiếng Kazakhstan
  • Ky — Kyrgyzstan
  • sw — Tiếng Swahili (ngôn ngữ vĩ mô)
  • tk — Turkmen
  • uz — tiếng Uzbek
  • tt — Tatar
  • bn — Tiếng Bengal
  • pa — Panjabi
  • gu — Gujarati
  • hoặc — Oriya
  • ta — Tamil
  • te — Telugu
  • kn — Kannada
  • ml — Tiếng Mã Lai
  • như — tiếng Assam
  • ông — Marathi
  • sa — tiếng Phạn
  • mn — tiếng Mông Cổ
  • bo — Tây Tạng
  • cy — tiếng xứ Wales
  • km — Trung Khmer
  • lo — tiếng Lào
  • gl — tiếng Galicia
  • kok — Konkani (ngôn ngữ vĩ mô)
  • syr — tiếng Syriac
  • si — Sinhala
  • iu — Inuktitut
  • sáng - tiếng Amharic
  • tzm — Central Atlas Tamazight
  • ne — tiếng Nepal
  • fy — Tây Frisian
  • ps — Pushto
  • phim — tiếng Philipin
  • dv — Dhivehi
  • ha — Hausa
  • yo — Yoruba
  • quz — Cusco Quechua
  • nso — Pedi
  • ba — Bashkir
  • lb — Tiếng Luxembourg
  • kl — Kalaallisut
  • ig — Tiếng Igbo
  • ii — Sichuan Yi
  • arn — Mapudungun
  • moh — Mohawk
  • Anh — Breton
  • ug — Duy Ngô Nhĩ
  • mi — Maori
  • oc — Occitan (sau 1500)
  • đồng — Corsican
  • gsw — Tiếng Đức Thụy Sĩ
  • sah — Yakut
  • qut — Goa-tê-ma-la
  • rw — Tiếng Kinyarwanda
  • wo — chó sói
  • prs — Dari
  • gd — Tiếng Gael Scotland

Ví dụ:

const collator = new Intl.Collator('de');
const sortedLetters = ['Z', 'Ä', 'Ö', 'Ü', 'ß'].sort(collator.compare);
console.log(sortedLetters);
0 dành cho tiếng Đức hoặc
const collator = new Intl.Collator('de');
const sortedLetters = ['Z', 'Ä', 'Ö', 'Ü', 'ß'].sort(collator.compare);
console.log(sortedLetters);
1 dành cho tiếng Pháp của Canada. Vì vậy, chúng ta có thể sắp xếp các chuỗi tiếng Pháp của Canada bằng cách chạy đoạn mã sau

const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);

Hàm tạo của Collator cũng có thể lấy một mảng chuỗi để so sánh nhiều ngôn ngữ —

const collator = new Intl.Collator('de');
const sortedLetters = ['Z', 'Ä', 'Ö', 'Ü', 'ß'].sort(collator.compare);
console.log(sortedLetters);
2. Đối số mảng cho phép chúng tôi sắp xếp các chuỗi từ nhiều ngôn ngữ. Ví dụ: chúng ta có thể sắp xếp cả bảng chữ cái tiếng Pháp của Canada và bảng chữ cái tiếng Đức cùng một lúc

const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);

Sau đó, chúng tôi nhận được

const collator = new Intl.Collator('de');
const sortedLetters = ['Z', 'Ä', 'Ö', 'Ü', 'ß'].sort(collator.compare);
console.log(sortedLetters);
3 từ câu lệnh
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
3

Ảnh của Macau Photo Agency trên BaptTùy chọn bổ sung

Các phím mở rộng Unicode bao gồm

const collator = new Intl.Collator('de');
const sortedLetters = ['Z', 'Ä', 'Ö', 'Ü', 'ß'].sort(collator.compare);
console.log(sortedLetters);
5,
const collator = new Intl.Collator('de');
const sortedLetters = ['Z', 'Ä', 'Ö', 'Ü', 'ß'].sort(collator.compare);
console.log(sortedLetters);
6,
const collator = new Intl.Collator('de');
const sortedLetters = ['Z', 'Ä', 'Ö', 'Ü', 'ß'].sort(collator.compare);
console.log(sortedLetters);
7,
const collator = new Intl.Collator('de');
const sortedLetters = ['Z', 'Ä', 'Ö', 'Ü', 'ß'].sort(collator.compare);
console.log(sortedLetters);
8,
const collator = new Intl.Collator('de');
const sortedLetters = ['Z', 'Ä', 'Ö', 'Ü', 'ß'].sort(collator.compare);
console.log(sortedLetters);
9,
const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
0,
const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
1,
const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
2,
const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
3,
const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
4,
const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
5,
const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
6,
const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
7 cũng được cho phép trong các chuỗi ngôn ngữ của chúng tôi. Chúng chỉ định các đối chiếu mà chúng tôi muốn so sánh các chuỗi với. Tuy nhiên, khi có các trường trong các tùy chọn trong đối số thứ hai trùng lặp với trường này, thì các tùy chọn trong đối số sẽ ghi đè các khóa mở rộng Unicode được chỉ định trong đối số đầu tiên

Các đối chiếu số có thể được chỉ định bằng cách thêm

const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
8 vào chuỗi ngôn ngữ của bạn trong đối số đầu tiên của bạn. Ví dụ: nếu chúng ta muốn so sánh các chuỗi số, thì chúng ta có thể viết

const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);

Sau đó, chúng tôi nhận được

const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
9 vì chúng tôi đã chỉ định
const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
8 trong chuỗi ngôn ngữ trong hàm tạo để bộ đối chiếu so sánh các số

Ngoài ra, chúng ta có thể chỉ định chữ hoa hay chữ thường nên được sắp xếp trước bằng khóa mở rộng

const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);
1. Các tùy chọn khả thi là
const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);
2,
const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);
3 hoặc
const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);
4.
const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);
4 có nghĩa là mặc định của ngôn ngữ sẽ là tùy chọn. Tùy chọn này có thể được đặt trong chuỗi ngôn ngữ bằng cách thêm dưới dạng khóa mở rộng Unicode và nếu cả hai đều được cung cấp thì thuộc tính
const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);
6 sẽ được ưu tiên. Ví dụ, để làm cho chữ hoa được ưu tiên hơn chữ thường, chúng ta có thể viết

const collator = new Intl.Collator('en-ca-u-kf-upper');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);

Điều này sắp xếp cùng một từ với chữ in hoa đầu tiên. Khi chúng tôi chạy

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
3, chúng tôi nhận được
const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);
8 vì chúng tôi có chữ hoa 'A' trong 'Able' và chữ thường 'a' cho 'có thể'. Mặt khác, nếu thay vào đó chúng ta chuyển vào
const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);
9 trong hàm tạo như trong mã bên dưới

const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);

Sau đó, sau

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
3, chúng tôi nhận được
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
1 vì
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
2 có nghĩa là chúng tôi sắp xếp cùng một từ với các chữ cái viết thường trước những từ có chữ hoa

Đối số thứ hai của hàm tạo lấy một đối tượng có thể có nhiều thuộc tính. Các thuộc tính mà đối tượng chấp nhận là

const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
3,
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
4,
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
5,
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
6,
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
7 và
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
8.
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
7 giống với tùy chọn
const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
8 trong khóa mở rộng Unicode trong chuỗi ngôn ngữ và
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
8 giống với tùy chọn
const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);
1 trong khóa mở rộng Unicode trong chuỗi ngôn ngữ. Tùy chọn
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
3 chỉ định thuật toán so khớp ngôn ngữ sẽ sử dụng. Các giá trị có thể là
const collator = new Intl.Collator('en-ca-u-kf-upper');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
4 và
const collator = new Intl.Collator('en-ca-u-kf-upper');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5. Thuật toán tra cứu tìm kiếm ngôn ngữ cho đến khi nó tìm thấy ngôn ngữ phù hợp với bộ ký tự của các chuỗi đang được so sánh.
const collator = new Intl.Collator('en-ca-u-kf-upper');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 tìm ngôn ngữ ít nhất nhưng có thể phù hợp hơn với thuật toán
const collator = new Intl.Collator('en-ca-u-kf-upper');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
4

Tùy chọn

const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
4 chỉ định xem Bộ sắp xếp được sử dụng để sắp xếp hoặc tìm kiếm chuỗi. Tùy chọn mặc định là
const collator = new Intl.Collator('en-ca-u-kf-upper');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
9

Tùy chọn độ nhạy chỉ định cách so sánh các chuỗi. Các tùy chọn khả thi là

const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
0,
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
1,
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
2 và
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
3

const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
0 so sánh cơ sở của chữ cái, bỏ qua trọng âm. Ví dụ:
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 không giống với
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
6, nhưng
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 giống với
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
8,
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 giống như
const collator = new Intl.Collator('en-ca', {
ignorePunctuation: false,
sensitivity: "base",
usage: 'sort'
});
console.log(collator.compare('Able', 'able'));
0

const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
1 xác định rằng một chuỗi chỉ khác nếu có một chữ cái cơ sở hoặc trọng âm của chúng không bằng nhau thì chúng không bằng nhau, bỏ qua trường hợp. Vì vậy,
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 không giống như
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
6, nhưng
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 giống như
const collator = new Intl.Collator('en-ca', {
ignorePunctuation: false,
sensitivity: "base",
usage: 'sort'
});
console.log(collator.compare('Able', 'able'));
5.
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 không giống như
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
8

Tùy chọn

const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
2 chỉ định rằng các chuỗi khác nhau về chữ cái hoặc cách viết hoa thường được coi là không bằng nhau, vì vậy
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 sẽ không giống với
const collator = new Intl.Collator('en-ca', {
ignorePunctuation: false,
sensitivity: "base",
usage: 'sort'
});
console.log(collator.compare('Able', 'able'));
5 và
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 sẽ không giống với
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
02, nhưng
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 giống với
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
8

const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
3 có nghĩa là các chuỗi khác nhau về chữ cái cơ sở, trọng âm, các dấu khác hoặc cách viết hoa được coi là không bằng nhau. Ví dụ:
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 sẽ không giống với
const collator = new Intl.Collator('en-ca', {
ignorePunctuation: false,
sensitivity: "base",
usage: 'sort'
});
console.log(collator.compare('Able', 'able'));
5 và
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 sẽ không giống với
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
02. Nhưng
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
5 cũng sẽ không giống như
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
8

const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
6 chỉ định có nên bỏ qua dấu chấm câu khi sắp xếp chuỗi hay không. Đó là thuộc tính boolean và giá trị mặc định là
const collator = new Intl.Collator(['fr-ca', 'de']);
const sortedLetters = [
'Ü', 'ß', 'ç', 'à', 'c'
].sort(collator.compare);
console.log(sortedLetters);
4

Chúng ta có thể sử dụng hàm tạo Collator với đối số thứ hai theo cách sau

const collator = new Intl.Collator('en-ca', {
ignorePunctuation: false,
sensitivity: "base",
usage: 'sort'
});
console.log(collator.compare('Able', 'able'));

Trong đoạn mã trên, chúng tôi sắp xếp bằng cách kiểm tra dấu câu và chỉ xem xét các chữ cái khác nhau nếu chữ cái cơ sở khác và chúng tôi giữ mặc định rằng các chữ cái viết hoa được sắp xếp trước, vì vậy chúng tôi nhận được

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
14 trong
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
3

Chúng ta có thể tìm kiếm các chuỗi như sau

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
0

Chúng tôi đặt tùy chọn

const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
4 thành
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
17 để sử dụng Bộ đối chiếu để tìm kiếm chuỗi và khi phương thức
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
5 trả về
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
1, thì chúng tôi biết rằng chúng tôi có cùng một chuỗi. Vì vậy, chúng tôi nhận được
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
20 được ghi lại khi chúng tôi chạy
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
21

Chúng tôi có thể điều chỉnh các tùy chọn để so sánh chữ cái, vì vậy nếu chúng tôi có

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
1

Sau đó, chúng tôi nhận được

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
22 trong
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'ß');
console.log(order);
3 của mình vì chúng tôi đã chỉ định
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
5 là
const collator = new Intl.Collator('en-ca-u-kf-lower');
const sorted = ['Able', 'able'].sort(collator.compare);
console.log(sorted);
0, điều đó có nghĩa là chúng tôi coi các chữ cái có cùng trọng âm cơ bản là giống nhau

Ngoài ra, chúng ta có thể chỉ định tùy chọn số để sắp xếp số. Ví dụ, nếu chúng ta có

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
2

Sau đó, chúng tôi nhận được

const collator = new Intl.Collator('fr-ca');
const sortedLetters = ['ç', 'à', 'c'].sort(collator.compare);
console.log(sortedLetters);
9 vì thuộc tính
const collator = new Intl.Collator(['en-u-kn-true']);
const sortedNums = ['10', '2'].sort(collator.compare);
console.log(sortedNums);
7 trong đối tượng trong đối số thứ hai sẽ ghi đè lên
const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
28 trong đối số thứ nhất

Phần kết luận

JavaScript cung cấp nhiều tùy chọn so sánh chuỗi để so sánh các chuỗi không phải bằng tiếng Anh. Hàm tạo Collator trong

const collator = new Intl.Collator('de');
const order = collator.compare('ß', 'Ü');
console.log(order);
29 cung cấp nhiều tùy chọn để cho phép chúng tôi tìm kiếm hoặc sắp xếp các chuỗi theo những cách không thể thực hiện được với các toán tử so sánh thông thường như gấp đôi hoặc gấp ba bằng. Nó cho phép chúng tôi sắp xếp các số và xem xét các trường hợp, trọng âm, dấu chấm câu hoặc sự kết hợp của các tính năng đó trong mỗi ký tự để so sánh các chuỗi. Ngoài ra, nó chấp nhận các chuỗi ngôn ngữ có phần mở rộng chính để so sánh

Tất cả các tùy chọn này cùng nhau làm cho hàm tạo Collator của JavaScript trở thành một lựa chọn tuyệt vời để so sánh các chuỗi quốc tế

Làm cách nào để so sánh hai chuỗi theo thứ tự abc trong js?

Cách so sánh chuỗi Sử dụng localeCompare . địa phươngSo sánh lợi nhuận. 1 nếu chuỗi1 lớn hơn (cao hơn theo thứ tự bảng chữ cái) so với chuỗi2. -1 nếu chuỗi1 nhỏ hơn (xếp theo thứ tự bảng chữ cái) so với chuỗi2.

Làm cách nào để so sánh thứ tự bảng chữ cái trong js?

Để so sánh các chuỗi theo thứ tự bảng chữ cái, hãy sử dụng localeCompare() . Điều này trả về một giá trị âm nếu chuỗi tham chiếu theo thứ tự từ điển (theo bảng chữ cái) trước chuỗi được so sánh (tham số), một giá trị dương nếu nó đến sau và giá trị 0 nếu chúng bằng nhau.

Làm cách nào để sắp xếp chuỗi theo thứ tự bảng chữ cái trong JavaScript?

Ví dụ. Sắp xếp các từ theo thứ tự bảng chữ cái . Các phần tử của mảng được sắp xếp bằng phương thức sort(). Phương thức sort() sắp xếp các chuỗi theo thứ tự bảng chữ cái và tăng dần .

So sánh có sắp xếp theo thứ tự bảng chữ cái không?

Sử dụng giao diện Comparable và phương thức compareTo(), chúng ta có thể sắp xếp theo thứ tự bảng chữ cái , độ dài chuỗi, đảo ngược thứ tự bảng chữ cái hoặc số.