1. Loại bỏ phần tử trùng lặp bằng hai vòng lặp

Đầu tiên, tạo một mảng mới chứa phần tử đầu tiên của mảng gốc. Sau đó, duyệt qua mảng gốc và so sánh với mảng mới. Nếu phần tử không tồn tại trong mảng mới, thêm nó vào. Cuối cùng, trả về mảng mới.

let arr = [0, 2, 3, 4, 4, 0, 2];
function unique1(ary) {
    let res = [ary[0]];
    for (let i = 1; i < ary.length; i++) {
        let isUnique = true;
        for (let j = 0; j < res.length; j++) {
            if (ary[i] === res[j]) {
                isUnique = false;
                break;
            }
        }
        if (isUnique) res.push(ary[i]);
    }
    return res;
}
console.log(unique1(arr));
// [0, 2, 3, 4]

2. Sử dụng phương thức indexOf để loại bỏ phần tử trùng lặp

Phương thức indexOf trả về vị trí đầu tiên của phần tử trong mảng. Tạo một mảng rỗng, duyệt qua mảng gốc và sử dụng indexOf để kiểm tra xem phần tử có tồn tại trong mảng mới không. Nếu không, thêm nó vào mảng mới. Cuối cùng, trả về mảng mới.

let bosh = [1, 2, 3, 3, 2, 1, 1, 2, 3, 4, 5, 6, 7];
function unique2(a) {
    let temp = [];
    for (let i = 0; i < a.length; i++) {
        if (temp.indexOf(a[i]) === -1) {
            temp.push(a[i]);
        }
    }
    return temp;
}
console.log(unique2(bosh));
// [1, 2, 3, 4, 5, 6, 7]

3. Loại bỏ phần tử trùng lặp bằng cách so sánh các phần tử liền kề (sau khi sắp xếp)

Sắp xếp mảng gốc, sau đó duyệt qua mảng đã sắp xếp và so sánh các phần tử liền kề. Nếu phần tử hiện tại khác với phần tử trước đó, thêm nó vào mảng mới. Cuối cùng, trả về mảng mới.

let adjoin = [64, 5, 4, 2, 4, 5, 2];
function unique3(arr) {
    arr.sort((a, b) => a - b);
    let empt = [];
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] !== arr[i - 1]) {
            empt.push(arr[i]);
        }
    }
    return empt;
}
console.log(unique3(adjoin));
// [2, 4, 5, 64]

4. Sử dụng thuộc tính của đối tượng để loại bỏ phần tử trùng lặp

Tạo một đối tượng rỗng, duyệt qua mảng và sử dụng giá trị của phần tử làm khóa của đối tượng. Nếu khóa chưa tồn tại, thêm phần tử vào mảng mới và đặt giá trị của khóa là 1. Nếu khóa đã tồn tại, tăng giá trị của khóa lên 1. Cuối cùng, trả về mảng mới.

let sz = [6, 20, 0, 20, 9, 6, 0];
function unique4(arr) {
    let item = [];
    let obj = {};
    for (let i = 0; i < arr.length; i++) {
        if (!obj[arr[i]]) {
            item.push(arr[i]);
            obj[arr[i]] = 1;
        } else {
            obj[arr[i]]++;
        }
    }
    return item;
}
console.log(unique4(sz));
// [6, 20, 0, 9]

5. Sử dụng indexOf và filter để loại bỏ phần tử trùng lặp

Sử dụng indexOf để kiểm tra vị trí đầu tiên của phần tử trong mảng. Nếu vị trí này không bằng với vị trí hiện tại, phần tử đó là phần tử trùng lặp. Sử dụng filter để loại bỏ các phần tử trùng lặp.

let filt = [0, 99, 33, 22, 0, 44, 33];
function unique5(arr) {
    return arr.filter((item, index) => arr.indexOf(item) === index);
}
console.log(unique5(filt));
// [0, 99, 33, 22, 44]

6. Sử dụng Set và giải cấu trúc để loại bỏ phần tử trùng lặp

Set là một tập hợp các giá trị duy nhất. Chuyển đổi mảng thành Set và sau đó chuyển đổi Set trở lại thành mảng.

let es = [1, 2, 2, 3, 4, 1, 3, 5];
function unique6(arr) {
    return [...new Set(arr)];
}
console.log(unique6(es));
// [1, 2, 3, 4, 5]

7. Sử dụng Set và Array.from để loại bỏ phần tử trùng lặp

Array.from chuyển đổi một đối tượng giống mảng thành mảng. Chuyển đổi mảng thành Set và sau đó sử dụng Array.from để chuyển đổi Set trở lại thành mảng.

let array = [0, 3, 0, 5, 0, 6, 5];
function unique7(arr) {
    return Array.from(new Set(arr));
}
console.log(unique7(array));
// [0, 3, 5, 6]