Nó phụ thuộc vào kích thước mảng đầu vào. Tôi đã thực hiện một số bài kiểm tra hiệu suất với các móc hiệu suất của Node.js và phát hiện ra rằng đối với các mảng thực sự nhỏ [1.000 đến 10.000 mục] có thể nhanh hơn. Nhưng nếu mảng của bạn lớn hơn [như 100.000 phần tử] đối tượng đơn giản [i. E. Băm] sẽ nhanh hơn. Đây là mã để bạn có thể tự mình thử:might be faster. But if your array is bigger [like 100,000 elements] plain Object [i. e. hash] solution becomes faster. Here's the code so you can try it out for yourself:
const { performance } = require['perf_hooks'];
function objectSolution[nums] {
let testObj = {};
for [var i = 0; i < nums.length; i++] {
let aNum = nums[i];
if [testObj[aNum]] {
return true;
} else {
testObj[aNum] = true;
}
}
return false;
}
function setSolution[nums] {
let testSet = new Set[nums];
return testSet.size !== nums.length;
}
function sortSomeSolution[nums] {
return nums
.sort[]
.some[function [item, i, items] {
return item === items[i + 1]
}]
}
function runTest[testFunction, testArray] {
console.log[' Running test:', testFunction.name];
let start = performance.now[];
let result = testFunction[testArray];
let end = performance.now[];
console.log[' Duration:', end - start, 'ms'];
}
let arr = [];
let setSize = 100000;
for [var i = 0; i < setSize; i++] {
arr.push[i];
}
console.log['Set size:', setSize];
runTest[objectSolution, arr];
runTest[setSolution, arr];
runTest[sortSomeSolution, arr];
Trên Lenovo IdeaPad của tôi với i3-8130u node.js v. 16.6.2 cho tôi kết quả sau đây cho mảng 1.000:
Kết quả cho mảng 100.000:
Có nhiều phương thức có sẵn để kiểm tra xem một mảng có chứa các giá trị trùng lặp trong JavaScript không. Bạn có thể sử dụng phương thức indexOf[], đối tượng
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
Đối tượng const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
0
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
Set là một cấu trúc dữ liệu đặc biệt được giới thiệu trong ES6 lưu trữ một tập hợp các giá trị duy nhất. Vì mỗi giá trị trong
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
Phương thức mảng.from [], chúng tôi đã sử dụng ở trên, chuyển đổi
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
const unique = [...new Set[numbers]];
Để kiểm tra xem có các mục trùng lặp trong mảng ban đầu không, chỉ cần so sánh độ dài của cả hai mảng:check if there were duplicate items in the original array, just compare the length of both arrays:
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
if[numbers.length === unique.length] {
console.log[`Array doesn't contain duplicates.`];
} else {
console.log[`Array contains duplicates.`];
}
// Output: Array contains duplicates.
Để tìm hiểu chính xác các yếu tố nào là trùng lặp, bạn có thể sử dụng mảng
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const set = new Set[numbers];
const duplicates = numbers.filter[item => {
if [set.has[item]] {
set.delete[item];
} else {
return item;
}
}];
console.log[duplicates];
// [ 2, 5 ]
Phương pháp indexOf[]
Trong phương pháp này, chúng tôi so sánh chỉ số của lần xuất hiện đầu tiên của một phần tử với tất cả các phần tử trong một mảng. Nếu chúng không khớp, nó ngụ ý rằng phần tử là một bản sao:
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const duplicates = numbers.filter[[item, index] => index !== numbers.indexOf[item]];
console.log[duplicates];
// [ 2, 5 ]
Giải pháp trên hoạt động hoàn hảo miễn là bạn chỉ muốn kiểm tra xem mảng có chứa các mục lặp lại không. Tuy nhiên, mảng đầu ra có thể chứa các mục trùng lặp nếu các mục đó xảy ra nhiều hơn hai lần trong mảng:
const numbers = [1, 2, 3, 2, 2, 4, 5, 5, 6];
const duplicates = numbers.filter[[item, index] => index !== numbers.indexOf[item]];
console.log[duplicates];
// [ 2, 2, 5 ]
Phương pháp const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
7
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
Trong JavaScript, phương thức
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
Giống như phương pháp
const unique = [...new Set[numbers]];
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const unique = Array.from[new Set[numbers]];
console.log[unique];
// [ 1, 2, 3, 4, 5, 6 ]
Trong hàm gọi lại, chúng tôi một lần nữa sử dụng phương thức indexOf[] để so sánh chỉ mục phần tử hiện tại với các phần tử khác trong mảng. Nếu cả hai chỉ mục đều giống nhau, điều đó có nghĩa là mục hiện tại không được trùng lặp:
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
const isDuplicate = numbers.some[[item, index] => index !== numbers.indexOf[item]];
if [!isDuplicate] {
console.log[`Array doesn't contain duplicates.`];
} else {
console.log[`Array contains duplicates.`];
}
// Output: Array contains duplicates.
const unique = [...new Set[numbers]];
3 Vòng lặp
const unique = [...new Set[numbers]];
Cuối cùng, phương pháp cuối cùng để tìm bản sao trong một mảng là sử dụng vòng lặp
const unique = [...new Set[numbers]];
Dưới đây là một ví dụ so sánh từng phần tử của mảng với tất cả các phần tử khác của mảng để kiểm tra xem hai giá trị có giống nhau bằng cách sử dụng Nested Loop không:
const numbers = [1, 2, 3, 2, 4, 5, 5, 6];
let isDuplicate = false;
// Outer for loop
for [let i = 0; i