Vâng, không lan man quá nhiều, với một người mã JS là một thời gian nhưng đôi khi vẫn hay quên và phải lên mạng mò mã như mình thì sau đây là những trường hợp mình thấy hay gặp, hay dùng khi xử lý Array hoặc
1. Kiểm tra phần tử có tồn tại trong một mảng và đối tượng mảng
- Mảng
- đối tượng mảng
2. Tính SUM trong mảng và đối tượng mảng
- Mảng
- đối tượng mảng
3. Return về một mảng chứa tất cả các phần tử của mảng thứ nhất không trùng với mảng thứ 2
- Mảng
- đối tượng mảng
4. Quay lại một mảng chứa tất cả các phần tử không trùng lặp giữa hai mảng
- Mảng
- đối tượng mảng
5. Sắp xếp mảng và sắp xếp đối tượng mảng
- Mảng
- đối tượng mảng
Trên đây là một vài trường hợp mình hay gặp và những cách xử lý mình thấy khá hay nên muốn chia sẻ. Mọi người có ý kiến hoặc gặp những trường hợp nào nữa có thể comment. . ĐDDDD
Phương thức
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
7 sắp xếp các phần tử của một mảng tại chỗ và trả về tham chiếu cho cùng một mảng, hiện đã được sắp xếp. Thứ tự sắp xếp mặc định tăng dần, được xây dựng dựa trên việc chuyển đổi các phần tử thành chuỗi, sau đó so sánh các chuỗi giá trị đơn vị mã UTF-16 của chúngĐộ phức tạp về thời gian và không gian của sắp xếp không thể được đảm bảo vì nó phụ thuộc vào việc triển khai
Thử nó
cú pháp
// Functionless
sort[]
// Arrow function
sort[[a, b] => { /* … */ } ]
// Compare function
sort[compareFn]
// Inline compare function
sort[function compareFn[a, b] { /* … */ }]
Thông số
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
8 Tùy chọnChỉ định một hàm xác định thứ tự sắp xếp. Nếu bỏ qua, các phần tử mảng được chuyển đổi thành chuỗi, sau đó được sắp xếp theo giá trị điểm mã Unicode của từng ký tự
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
9Yếu tố so sánh đầu tiên
function compareNumbers[a, b] {
return a - b;
}
0Yếu tố thứ hai để so sánh
Giá trị trả về
Tham chiếu đến mảng ban đầu, hiện đã được sắp xếp. Lưu ý rằng mảng được sắp xếp tại chỗ và không có bản sao nào được thực hiện
Sự mô tả
Nếu
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
8 không được cung cấp, tất cả các phần tử mảng không phải function compareNumbers[a, b] {
return a - b;
}
2 được sắp xếp bằng cách chuyển đổi chúng thành chuỗi và so sánh các chuỗi theo thứ tự đơn vị mã UTF-16. Ví dụ: "chuối" đứng trước "anh đào". Trong sắp xếp số, 9 đứng trước 80, nhưng vì số được chuyển đổi thành chuỗi nên "80" đứng trước "9" theo thứ tự Unicode. Tất cả các phần tử của function compareNumbers[a, b] {
return a - b;
}
2 được sắp xếp đến cuối mảngPhương pháp
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
7 bảo tồn các vị trí trống. Nếu mảng nguồn thưa thớt, các vị trí trống sẽ được di chuyển đến cuối mảng và luôn xuất hiện sau tất cả các function compareNumbers[a, b] {
return a - b;
}
2Ghi chú. Trong UTF-16, các ký tự Unicode trên
function compareNumbers[a, b] {
return a - b;
}
6 được mã hóa thành hai đơn vị mã thay thế, thuộc phạm vi function compareNumbers[a, b] {
return a - b;
}
7 - function compareNumbers[a, b] {
return a - b;
}
8. Giá trị của từng đơn vị mã được tính riêng để so sánh. Do đó, ký tự được tạo bởi cặp thay thế function compareNumbers[a, b] {
return a - b;
}
9 sẽ được sắp xếp trước ký tự // Functionless
sort[]
// Arrow function
sort[[a, b] => { /* … */ } ]
// Compare function
sort[compareFn]
// Inline compare function
sort[function compareFn[a, b] { /* … */ }]
40Nếu cung cấp
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
8, tất cả các phần tử mảng không phải ____42 được sắp xếp theo giá trị trả về của hàm so sánh [tất cả các phần tử function compareNumbers[a, b] {
return a - b;
}
2 được sắp xếp đến cuối mảng, không có lệnh gọi đến function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
8]// Functionless
sort[]
// Arrow function
sort[[a, b] => { /* … */ } ]
// Compare function
sort[compareFn]
// Inline compare function
sort[function compareFn[a, b] { /* … */ }]
45 giá trị trả về thứ tự sắp xếp> 0sắp xếp function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
9 sau function compareNumbers[a, b] {
return a - b;
}
0< 0sắp xếp function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
9 trước function compareNumbers[a, b] {
return a - b;
}
0=== 0giữ nguyên thứ tự ban đầu của function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
9 và function compareNumbers[a, b] {
return a - b;
}
0Vì vậy, hàm so sánh có dạng sau
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
Chính thức hơn, bộ so sánh dự kiến sẽ có các thuộc tính sau, để đảm bảo hành vi sắp xếp phù hợp
- Thuần khiết. Bộ so sánh không làm biến đổi các đối tượng được so sánh hoặc bất kỳ trạng thái bên ngoài nào. [Điều này rất quan trọng vì không có gì đảm bảo bộ so sánh sẽ được gọi khi nào và như thế nào, vì vậy bất kỳ lệnh gọi cụ thể nào cũng không được tạo ra các hiệu ứng có thể nhìn thấy được ở bên ngoài. ]
- Ổn định. Bộ so sánh trả về cùng một kết quả với cùng một cặp đầu vào
- phản xạ.
72function compareFn[a, b] { if [a is less than b by some ordering criterion] { return -1; } if [a is greater than b by the ordering criterion] { return 1; } // a must be equal to b return 0; }
- chống đối xứng.
45 và// Functionless sort[] // Arrow function sort[[a, b] => { /* … */ } ] // Compare function sort[compareFn] // Inline compare function sort[function compareFn[a, b] { /* … */ }]
74 đều phải làfunction compareFn[a, b] { if [a is less than b by some ordering criterion] { return -1; } if [a is greater than b by the ordering criterion] { return 1; } // a must be equal to b return 0; }
75 hoặc có dấu hiệu trái ngược nhaufunction compareFn[a, b] { if [a is less than b by some ordering criterion] { return -1; } if [a is greater than b by the ordering criterion] { return 1; } // a must be equal to b return 0; }
- Bắc cầu. Nếu
45 và// Functionless sort[] // Arrow function sort[[a, b] => { /* … */ } ] // Compare function sort[compareFn] // Inline compare function sort[function compareFn[a, b] { /* … */ }]
77 đều dương, không hoặc âm, thìfunction compareFn[a, b] { if [a is less than b by some ordering criterion] { return -1; } if [a is greater than b by the ordering criterion] { return 1; } // a must be equal to b return 0; }
78 có cùng độ dương như hai phần trướcfunction compareFn[a, b] { if [a is less than b by some ordering criterion] { return -1; } if [a is greater than b by the ordering criterion] { return 1; } // a must be equal to b return 0; }
Một bộ so sánh phù hợp với các ràng buộc ở trên sẽ luôn có thể trả về tất cả
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
79, function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
75 và function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
61 hoặc trả về một cách nhất quán function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
75. Ví dụ: nếu một bộ so sánh chỉ trả về function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
79 và function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
75 hoặc chỉ trả về function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
75 và function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
61, thì nó sẽ không thể sắp xếp một cách đáng tin cậy vì tính đối xứng bị phá vỡ. Một bộ so sánh luôn trả về function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
75 sẽ khiến mảng hoàn toàn không bị thay đổi, nhưng vẫn đáng tin cậyBộ so sánh từ điển mặc định thỏa mãn tất cả các ràng buộc ở trên
Để so sánh các số thay vì chuỗi, hàm so sánh có thể trừ
function compareNumbers[a, b] {
return a - b;
}
0 khỏi function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
9. Hàm sau sẽ sắp xếp mảng theo thứ tự tăng dần [nếu nó không chứa function compareNumbers[a, b] {
return a - b;
}
50 và function compareNumbers[a, b] {
return a - b;
}
51]function compareNumbers[a, b] {
return a - b;
}
Phương pháp
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
7 là chung chung. Nó chỉ mong đợi giá trị function compareNumbers[a, b] {
return a - b;
}
53 có thuộc tính function compareNumbers[a, b] {
return a - b;
}
54 và các thuộc tính có khóa số nguyên. Mặc dù các chuỗi cũng giống như mảng, nhưng phương pháp này không phù hợp để áp dụng cho chúng, vì các chuỗi là bất biếnví dụ
Tạo, hiển thị và sắp xếp một mảng
Ví dụ sau tạo bốn mảng và hiển thị mảng ban đầu, sau đó là các mảng đã sắp xếp. Các mảng số được sắp xếp mà không có hàm so sánh, sau đó được sắp xếp bằng một
// Functionless
sort[]
// Arrow function
sort[[a, b] => { /* … */ } ]
// Compare function
sort[compareFn]
// Inline compare function
sort[function compareFn[a, b] { /* … */ }]
4Sắp xếp mảng đối tượng
Mảng đối tượng có thể được sắp xếp bằng cách so sánh giá trị của một trong các thuộc tính của chúng
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
7Sắp xếp các ký tự không phải ASCII
Để sắp xếp các chuỗi có ký tự không phải ASCII, tôi. e. các chuỗi có ký tự có dấu [e, é, è, a, ä, v.v. ], chuỗi từ các ngôn ngữ không phải tiếng Anh, sử dụng
function compareNumbers[a, b] {
return a - b;
}
55. Hàm này có thể so sánh các ký tự đó để chúng xuất hiện theo đúng thứ tựfunction compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
6Sắp xếp theo bản đồ
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
8 có thể được gọi nhiều lần cho mỗi phần tử trong mảng. Tùy thuộc vào bản chất của function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
8, điều này có thể mang lại chi phí cao. function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
8 càng làm nhiều việc và càng có nhiều yếu tố để sắp xếp, thì việc sử dụng function compareNumbers[a, b] {
return a - b;
}
59 để sắp xếp có thể hiệu quả hơn. Ý tưởng là duyệt qua mảng một lần để trích xuất các giá trị thực được sử dụng để sắp xếp thành một mảng tạm thời, sắp xếp mảng tạm thời, sau đó duyệt qua mảng tạm thời để đạt được thứ tự đúngfunction compareNumbers[a, b] {
return a - b;
}
5Có sẵn một thư viện mã nguồn mở được gọi là mapsort áp dụng phương pháp này
sort[] trả về tham chiếu đến cùng một mảng
Phương thức
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
7 trả về một tham chiếu đến mảng ban đầu, do đó, việc thay đổi mảng được trả về cũng sẽ thay đổi cả mảng ban đầufunction compareNumbers[a, b] {
return a - b;
}
1Trong trường hợp bạn muốn
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
7 không làm thay đổi mảng ban đầu mà trả về một mảng được sao chép nông giống như các phương thức mảng khác [e. g. function compareNumbers[a, b] {
return a - b;
}
59] làm, bạn có thể sao chép nông trước khi gọi function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
7, sử dụng cú pháp trải rộng hoặc function compareNumbers[a, b] {
return a - b;
}
14function compareNumbers[a, b] {
return a - b;
}
6Sắp xếp ổn định
Kể từ phiên bản 10 [hoặc ECMAScript 2019], thông số kỹ thuật chỉ ra rằng
function compareNumbers[a, b] {
return a - b;
}
15 ổn địnhVí dụ: giả sử bạn có danh sách học sinh cùng với điểm của họ. Lưu ý rằng danh sách sinh viên đã được sắp xếp sẵn theo tên theo thứ tự bảng chữ cái
function compareNumbers[a, b] {
return a - b;
}
8Sau khi sắp xếp mảng này theo thứ tự tăng dần của
function compareNumbers[a, b] {
return a - b;
}
16function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
0Biến
function compareNumbers[a, b] {
return a - b;
}
17 sau đó sẽ có giá trị như saufunction compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
1Điều quan trọng cần lưu ý là những học sinh có cùng điểm [ví dụ: Alex và Devlin], sẽ giữ nguyên thứ tự như trước khi gọi sắp xếp. Đây là điều mà thuật toán sắp xếp ổn định đảm bảo
Trước phiên bản 10 [hoặc ECMAScript 2019], tính ổn định sắp xếp không được đảm bảo, nghĩa là bạn có thể gặp phải những vấn đề sau
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
2Sắp xếp với bộ so sánh không được định dạng tốt
Nếu một chức năng so sánh không đáp ứng tất cả các quy tắc thuần túy, ổn định, phản xạ, phản đối xứng và bắc cầu, như được giải thích trong phần mô tả, thì hành vi của chương trình không được xác định rõ
Ví dụ, xem xét mã này
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
3Hàm
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
8 ở đây không được định dạng tốt vì nó không thỏa mãn phản đối xứng. nếu function compareNumbers[a, b] {
return a - b;
}
19, nó trả về function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
79; . Do đó, mảng kết quả sẽ khác nhau giữa các công cụ. Ví dụ: V8 [được sử dụng bởi Chrome, Node. js, v.v. ] và JavaScriptCore [được sử dụng bởi Safari] hoàn toàn không sắp xếp mảng và trả về function compareNumbers[a, b] {
return a - b;
}
64, trong khi SpiderMonkey [được sử dụng bởi Firefox] sẽ trả về mảng được sắp xếp tăng dần, như function compareNumbers[a, b] {
return a - b;
}
65Tuy nhiên, nếu hàm
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
8 bị thay đổi một chút để nó trả về function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
61 hoặc function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
75function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
4Sau đó, V8 và JavaScriptCore sắp xếp nó giảm dần, như
function compareNumbers[a, b] {
return a - b;
}
69, trong khi SpiderMonkey trả về nguyên trạng. function compareNumbers[a, b] {
return a - b;
}
64Do sự không nhất quán khi triển khai này, bạn luôn nên làm cho bộ so sánh của mình được định dạng tốt bằng cách tuân theo năm ràng buộc
Sử dụng sort[] trên các mảng thưa thớt
Các vị trí trống được di chuyển đến cuối mảng
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
5Gọi sort[] trên các đối tượng không phải mảng
Phương thức
function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
7 đọc thuộc tính function compareNumbers[a, b] {
return a - b;
}
54 của function compareNumbers[a, b] {
return a - b;
}
53. Sau đó, nó thu thập tất cả các thuộc tính khóa số nguyên hiện có trong phạm vi từ function compareFn[a, b] {
if [a is less than b by some ordering criterion] {
return -1;
}
if [a is greater than b by the ordering criterion] {
return 1;
}
// a must be equal to b
return 0;
}
75 đến function compareNumbers[a, b] {
return a - b;
}
85, sắp xếp chúng và ghi lại chúng. Nếu có các thuộc tính bị thiếu trong phạm vi, các thuộc tính theo sau tương ứng sẽ bị xóa, như thể các thuộc tính không tồn tại được sắp xếp về cuối