Kiểm tra sự tồn tại của phần tử trùng lặp trong mảng một chiều

Sử dụng một đối tượng (hash map) để lưu trữ các phần tử đã gặp. Nếu gặp lại một phần tử đã có trong hash map, nghĩa là có phần tử trùng lặp.

function kiemTraTrungLap(mang) {
  const daGap = {};
  for (const phanTu of mang) {
    if (daGap[phanTu]) {
      return true; // Tìm thấy phần tử trùng lặp
    }
    daGap[phanTu] = true;
  }
  return false; // Không có phần tử trùng lặp
}

console.log(kiemTraTrungLap(['11', '22', '1111'])); // false
console.log(kiemTraTrungLap(['11', '22', '22']));   // true
  

Đếm số lần xuất hiện của mỗi ký tự trong chuỗi

Sử dụng phương thức reduce để duyệt qua từng ký tự và cập nhật số đếm trong một đối tượng.

const chuoi = 'abcdaabddcca';
const tanSuatKýTu = chuoi.split('').reduce((boDem, kyTuHienTai) => {
  boDem[kyTuHienTai] = (boDem[kyTuHienTai] || 0) + 1;
  return boDem;
}, {});

console.log(tanSuatKýTu);
// Kết quả: { a: 4, b: 2, c: 3, d: 3 }
  

Sắp xếp mảng đối tượng theo một thuộc tính (thứ tự giảm dần)

Sử dụng phương thức sort với một hàm so sánh tùy chỉnh. Hàm này trả về giá trị để xác định thứ tự của hai phần tử.

// Giả sử có mảng arrA chứa các đối tượng có thuộc tính 'time'
// const arrB = arrA.sort(sapXepTheoThuocTinh);

function sapXepTheoThuocTinh(doiTuong1, doiTuong2) {
  // Để sắp xếp giảm dần, lấy doiTuong2.time trừ đi doiTuong1.time
  return doiTuong2.time - doiTuong1.time;
}
  

Tạo bản sao sâu (Deep Copy)

Một phương pháp đơn giản để tạo bản sao sâu cho các đối tượng JSON có thể tuần tự hóa là sử dụng JSON.stringify và JSON.parse.

function taoBanSaoSau(doiTuong) {
  const chuoiDaChuyenDoi = JSON.stringify(doiTuong);
  const banSao = JSON.parse(chuoiDaChuyenDoi);
  return banSao;
}

// Ví dụ:
// const banSaoCuaA = taoBanSaoSau(a);
  

Sắp xếp ngẫu nhiên mảng

Thuật toán Fisher-Yates (hay Knuth) là một phương pháp hiệu quả để xáo trộn mảng. Lặp qua mảng từ cuối về đầu, hoán đổi mỗi phần tử với một phần tử ngẫu nhiên được chọn từ các phần tử chưa được xử lý.

function sapXepNgauNhien(mangGoc) {
  const mangKetQua = [...mangGoc]; // Tạo bản sao để không ảnh hưởng mảng gốc
  let viTriConLai = mangKetQua.length;

  // Vẫn còn các phần tử để chọn
  while (viTriConLai !== 0) {
    // Chọn một phần tử còn lại
    const viTriNgauNhien = Math.floor(Math.random() * viTriConLai);
    viTriConLai--;

    // Hoán đổi nó với phần tử hiện tại
    [mangKetQua[viTriConLai], mangKetQua[viTriNgauNhien]] = [
      mangKetQua[viTriNgauNhien], mangKetQua[viTriConLai]];
  }

  return mangKetQua;
}

const mangSo = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(sapXepNgauNhien(mangSo));
  

Loại bỏ phần tử trùng lặp khỏi mảng

Duyệt qua mảng và thêm các phần tử vào một mảng mới chỉ khi chúng chưa tồn tại trong mảng mới đó.

function loaiBoTrungLap(mangNguon) {
  const mangMoi = [];
  for (let i = 0; i < mangNguon.length; i++) {
    if (mangMoi.indexOf(mangNguon[i]) === -1) {
      mangMoi.push(mangNguon[i]);
    }
  }
  return mangMoi;
}

const mangGoc = [1, 2, 2, 4, 9, 6, 7, 5, 2, 3, 5, 6, 5];
console.log(loaiBoTrungLap(mangGoc)); // [ 1, 2, 4, 9, 6, 7, 5, 3 ]
  

Loại bỏ phần tử trùng lặp sử dụng ES6

Sử dụng Set để tự động xử lý việc loại bỏ trùng lặp, sau đó chuyển đổi lại thành mảng.

function loaiBoTrungLapES6(mang) {
  return Array.from(new Set(mang));
}

console.log(loaiBoTrungNhapES6([1, 1, 2, 3])); // [ 1, 2, 3 ]
  

Hợp (Union) của hai mảng một chiều

Nối hai mảng lại với nhau.

function hopMang(mangA, mangB) {
  return [...mangA, ...mangB];
}

console.log(hopMang([1, 2, 3], [2, 3, 4])); // [ 1, 2, 3, 2, 3, 4 ]
  

Hợp hai mảng và loại bỏ trùng lặp (sử dụng ES6)

Kết hợp hai mảng, sau đó sử dụng Set để loại bỏ các phần tử trùng lặp.

function hopVaLoaiBoTrungLap(mangA, mangB) {
  return Array.from(new Set([...mangA, ...mangB]));
}

console.log(hopVaLoaiBoTrungLap([1, 2, 3, 4], [2, 3, 4, 5])); // [ 1, 2, 3, 4, 5 ]
  

Phương pháp khác để hợp và loại bỏ trùng lặp

Nối hai mảng, sau đó sử dụng một đối tượng để theo dõi và chỉ thêm các phần tử chưa xuất hiện.

function hopKhac(mangA, mangB) {
  const mangKetHop = mangA.concat(mangB);
  const ketQua = [];
  const daThem = {};

  for (const phanTu of mangKetHop) {
    if (!daThem[phanTu]) {
      ketQua.push(phanTu);
      daThem[phanTu] = true;
    }
  }
  return ketQua;
}
  

Giao (Intersection) của hai mảng một chiều

Lọc các phần tử của mảng thứ nhất, chỉ giữ lại những phần tử cũng tồn tại trong mảng thứ hai (sử dụng Set để tăng hiệu suất tìm kiếm).

function giaoMang(mangA, mangB) {
  const boMangB = new Set(mangB);
  const phanTuChung = mangA.filter(phanTu => boMangB.has(phanTu));
  return phanTuChung;
}

console.log(giaoMang([1, 2, 3, 4], [2, 3, 4, 5])); // [ 2, 3, 4 ]
  

Hiệu (Difference) của hai mảng một chiều (a - b)

Lọc các phần tử của mảng thứ nhất, chỉ giữ lại những phần tử KHÔNG tồn tại trong mảng thứ hai.

function hieuMang(mangA, mangB) {
  const boMangB = new Set(mangB);
  const phanTuA_tru_B = mangA.filter(phanTu => !boMangB.has(phanTu));
  return phanTuA_tru_B;
}

console.log(hieuMang([1, 2, 3, 4], [2, 3, 4, 5])); // [ 1 ]
  

Loại bỏ phần tử trùng lặp khỏi mảng đối tượng JSON dựa trên một khóa chính (ví dụ: 'id')

Sử dụng một đối tượng để theo dõi các giá trị khóa đã gặp. Duyệt qua mảng và chỉ thêm đối tượng vào kết quả nếu giá trị khóa của nó chưa được thấy.

function loaiBoTrungLapTheoKhoa(mang, khoa) {
  const ketQua = [];
  const daGhiNhan = {};

  for (const doiTuong of mang) {
    const giaTriKhoa = doiTuong[khoa];
    if (!daGhiNhan[giaTriKhoa]) {
      ketQua.push(doiTuong);
      daGhiNhan[giaTriKhoa] = true;
    }
  }
  return ketQua;
}

const danhSachThanhToan = [
  { chnlNo: "Cash", amount: 300, type: 2 },
  { chnlNo: "Alipay", amount: "100", type: 2 },
  { chnlNo: "Bank Card", amount: "400", type: 2 },
  { chnlNo: "Cash", amount: 200, type: 2 } // Phần tử này sẽ bị loại bỏ vì 'Cash' đã có
];

console.log(loaiBoTrungLapTheoKhoa(danhSachThanhToan, 'chnlNo'));
/*
Kết quả:
[
  { chnlNo: 'Cash', amount: 300, type: 2 },
  { chnlNo: 'Alipay', amount: '100', type: 2 },
  { chnlNo: 'Bank Card', amount: '400', type: 2 }
]
*/