Lecture ini melanjutkan pembahasan Set, tetapi sekarang fokusnya bukan lagi “apa itu Set?”, melainkan kapan Set berguna dan kenapa kita memilih Set daripada Array untuk operasi tertentu.

Kalau lecture sebelumnya menjelaskan:

Set = kumpulan nilai unik

maka lecture ini menjelaskan:

Set sangat berguna ketika kita sering melakukan pengecekan keberadaan data, menghapus data, atau memastikan data tidak duplikat.

Ada beberapa use case penting yang dibahas:

1. Menghapus duplikat dari Array
2. Mengecek apakah suatu data ada
3. Union dua Array
4. Intersection dua Array
5. Difference dua Array
6. Menghapus element
7. Memahami kapan harus menggunakan Array dan kapan Set

Mari kita bahas satu per satu.

1. Mengapa kita membutuhkan Set?

Misalkan kita punya Array:

const numbers = [1, 2, 3, 2, 4, 3, 5];

Masalahnya adalah terdapat duplicate:

1
2
3
2  ← duplicate
4
3  ← duplicate
5

Kalau kebutuhan kita adalah:

“Saya hanya ingin data yang unik.”

maka Set sangat cocok.

const numberSet = new Set(numbers);

Hasilnya:

Set {1, 2, 3, 4, 5}

Set otomatis membuang duplicate.

2. Mengubah Array menjadi Set

Syntax-nya:

const mySet = new Set(array);

Contoh:

const numbers = [1, 2, 3, 2, 4, 3, 5];

const numberSet = new Set(numbers);

Sekarang:

console.log(numberSet);

hasilnya kurang lebih:

Set(5) {1, 2, 3, 4, 5}

Perhatikan bahwa 2 dan 3 yang awalnya muncul dua kali sekarang hanya muncul sekali.

3. Tapi bagaimana kalau kita ingin hasil akhirnya tetap Array?

Nah, ini penting.

new Set() menghasilkan Set, bukan Array.

Kalau kita ingin:

Array → Set → Array

kita bisa menggunakan spread operator (...).

Contoh:

const numbers = [1, 2, 3, 2, 4, 3, 5];

const uniqueNumbers = [...new Set(numbers)];

Hasil:

[1, 2, 3, 4, 5]

4. Memahami [...new Set(numbers)]

Untuk pemula, syntax ini memang terlihat membingungkan.

Kita pecah menjadi beberapa langkah.

Langkah 1

Kita punya:

const numbers = [1, 2, 3, 2, 4, 3, 5];

Langkah 2

Kita ubah Array menjadi Set:

new Set(numbers)

Hasil:

Set {1, 2, 3, 4, 5}

Langkah 3

Kita menggunakan spread operator:

...new Set(numbers)

Spread operator mengambil semua element dari Set tersebut.

Secara konsep:

Set {1, 2, 3, 4, 5}
       ↓
   spread (...)
       ↓
1, 2, 3, 4, 5

Langkah 4

Kita bungkus menggunakan []:

[
    ...new Set(numbers)
]

Sehingga menjadi Array:

[1, 2, 3, 4, 5]

Jadi:

const uniqueNumbers = [...new Set(numbers)];

artinya:

“Buat Set dari numbers supaya duplicate hilang, kemudian ambil semua isi Set tersebut dan masukkan kembali ke Array.”

5. Versi yang lebih mudah dipahami

Kalau syntax ini masih terasa terlalu singkat:

const uniqueNumbers = [...new Set(numbers)];

kita bisa menulisnya dalam beberapa langkah:

const numberSet = new Set(numbers);

const uniqueNumbers = [...numberSet];

Ini menghasilkan hal yang sama.

Urutannya:

Array
  ↓
new Set()
  ↓
Set dengan nilai unik
  ↓
spread operator
  ↓
Array

6. Use case kedua: Mengecek apakah sebuah element ada

Misalnya:

const numbers = [1, 2, 3, 4, 5, 7, 8];

Kita ingin tahu:

Apakah angka 7 ada?

Dengan Array kita bisa menggunakan:

numbers.includes(7);

Hasil:

true

Karena 7 ada.

Kalau:

numbers.includes(10);

hasilnya:

false

7. Kita juga bisa menggunakan Set

Kita ubah dulu Array menjadi Set:

const numberSet = new Set(numbers);

Kemudian:

numberSet.has(7);

hasil:

true

Sedangkan:

numberSet.has(10);

hasil:

false

Jadi:

set.has(value)

digunakan untuk mengecek apakah value ada di Set.

8. includes() vs has()

Ini bagian penting.

Untuk Array:

numbers.includes(7);

Untuk Set:

numberSet.has(7);

Keduanya sama-sama digunakan untuk mengecek keberadaan suatu value.

Namun secara konsep:

Array → includes()
Set   → has()

Dan lecture menjelaskan bahwa Set dirancang untuk melakukan membership checking secara efisien, sehingga untuk kebutuhan pengecekan keberadaan yang sering dilakukan pada data besar, Set bisa menjadi pilihan yang lebih baik.

9. Contoh penggunaan nyata

Bayangkan kita punya daftar username yang sudah digunakan:

const usernames = new Set([
    "budi",
    "andi",
    "joko",
    "siti"
]);

Kemudian user mencoba menggunakan username:

budi

Kita cukup:

if (usernames.has("budi")) {
    console.log("Username sudah digunakan");
}

Hasil:

Username sudah digunakan

Kalau:

usernames.has("doni");

hasilnya:

false

Artinya username doni belum ada.

10. Use case ketiga: Union

Sekarang masuk ke operasi yang sedikit lebih matematis.

Kita punya dua Array:

const arr1 = [1, 2, 3];

const arr2 = [3, 4, 5];

Kita ingin menggabungkan keduanya:

arr1 → 1, 2, 3
arr2 → 3, 4, 5

Kalau menggunakan spread operator saja:

const result = [...arr1, ...arr2];

hasil:

[1, 2, 3, 3, 4, 5]

Masalahnya:

3

muncul dua kali.

11. Union dengan Set

Dalam matematika, union berarti:

Menggabungkan semua element dari dua kelompok tanpa duplikat.

Jadi kita bisa:

const union = [...new Set([...arr1, ...arr2])];

Mari kita pecah.

Pertama:

[...arr1, ...arr2]

menghasilkan:

[1, 2, 3, 3, 4, 5]

Kemudian:

new Set([1, 2, 3, 3, 4, 5])

menjadi:

Set {1, 2, 3, 4, 5}

Kemudian:

[...Set]

menghasilkan Array:

[1, 2, 3, 4, 5]

Jadi:

const union = [...new Set([...arr1, ...arr2])];

hasil akhirnya:

[1, 2, 3, 4, 5]

12. Gambaran Union

Bayangkan:

arr1                 arr2

1                     3
2                     4
3                     5

Union:

1
2
3
4
5

Semua masuk, tetapi duplicate dibuang.

Secara sederhana:

Union = semua data dari A + semua data dari B, tanpa duplicate.

13. Use case keempat: Intersection

Sekarang kebalikannya.

Intersection berarti:

Hanya mengambil element yang terdapat di kedua Array.

Misalnya:

const arr1 = [1, 2, 3];

const arr2 = [3, 4, 5];

Kita lihat:

arr1 → 1, 2, 3
arr2 → 3, 4, 5

Yang muncul di keduanya hanya:

3

Jadi hasil intersection:

[3]

14. Cara mendapatkan Intersection

Salah satu cara:

const set2 = new Set(arr2);

const intersection = arr1.filter(x => set2.has(x));

Mari kita pahami perlahan.

Pertama:

const set2 = new Set(arr2);

menghasilkan:

Set {3, 4, 5}

Kemudian:

arr1.filter(...)

akan memeriksa setiap element dari arr1.

arr1:

1
2
3

Saat x = 1

Kita cek:

set2.has(1)

Hasil:

false

Jadi 1 tidak dimasukkan.

Saat x = 2

set2.has(2)

Hasil:

false

Tidak dimasukkan.

Saat x = 3

set2.has(3)

Hasil:

true

Maka 3 dimasukkan.

Hasil:

[3]

15. Kenapa menggunakan Set di sini?

Karena kita berkali-kali melakukan pertanyaan:

“Apakah element dari arr1 ini terdapat di arr2?”

Daripada terus melakukan pencarian pada Array, kita mengubah arr2 menjadi Set:

const set2 = new Set(arr2);

Kemudian:

set2.has(x)

digunakan untuk membership check.

Ini adalah salah satu pola penggunaan Set yang sangat berguna.

16. Contoh Intersection lain

Misalnya:

const studentsA = [
    "Budi",
    "Andi",
    "Siti"
];

const studentsB = [
    "Siti",
    "Joko",
    "Andi"
];

Kita ingin mengetahui:

Siapa yang berada di kedua kelompok?

const studentsBSet = new Set(studentsB);

const commonStudents = studentsA.filter(student =>
    studentsBSet.has(student)
);

Hasil:

["Andi", "Siti"]

Karena Andi dan Siti terdapat di kedua Array.

17. Use case kelima: Difference

Sekarang kita ingin mendapatkan data yang:

Ada di Array A tetapi tidak ada di Array B.

Misalnya:

const arr1 = [1, 2, 3];

const arr2 = [3, 4, 5];

Kita ingin:

Yang ada di arr1
TAPI tidak ada di arr2

arr1:

1
2
3

arr2:

3
4
5

3 terdapat di keduanya, jadi 3 harus dibuang.

Hasil:

[1, 2]

18. Cara mendapatkan Difference

Kita bisa:

const set2 = new Set(arr2);

const difference = arr1.filter(x => !set2.has(x));

Perhatikan tanda:

!

Ini adalah NOT operator.

Untuk x = 1

set2.has(1)

hasil:

false

Kemudian:

!false

menjadi:

true

Jadi 1 masuk.

Untuk x = 3

set2.has(3)

hasil:

true

Kemudian:

!true

menjadi:

false

Jadi 3 tidak masuk.

Hasil akhirnya:

[1, 2]

19. Bedakan Union, Intersection, Difference

Ini wajib dipahami karena konsepnya sering digunakan.

Misalnya:

A = {1, 2, 3}
B = {3, 4, 5}

Union

Semua yang ada di A atau B:

{1, 2, 3, 4, 5}

Intersection

Yang ada di A dan B:

{3}

Difference A - B

Yang ada di A tetapi tidak ada di B:

{1, 2}

Secara visual:

A                 B
┌─────────┐     ┌─────────┐
│ 1       │     │       4 │
│   2     │     │         │
│     3 ──┼─────┼── 3     │
│         │     │       5 │
└─────────┘     └─────────┘

Union:

1, 2, 3, 4, 5

Intersection:

3

A difference B:

1, 2

20. Use case keenam: Menghapus element

Misalnya kita punya Array:

const numbers = [1, 2, 3, 4, 5, 6, 7];

Kita ingin menghapus angka:

5

Dengan Array, kita biasanya perlu mengetahui index angka tersebut.

Misalnya:

const index = numbers.indexOf(5);

Hasil:

4

Kemudian:

numbers.splice(index, 1);

Jadi prosesnya:

Cari index
    ↓
indexOf()
    ↓
Dapat index
    ↓
splice()
    ↓
Hapus

Agak panjang.

21. Dengan Set lebih sederhana

Kita bisa:

const numbers = new Set([
    1, 2, 3, 4, 5, 6, 7
]);

numbers.delete(5);

Selesai.

Kita tidak perlu:

indexOf()

dan tidak perlu:

splice()

Karena Set memang memiliki:

delete(value)

Jadi kita mengatakan langsung:

“Hapus nilai 5.”

22. Tapi ada hal penting saat Array diubah menjadi Set

Misalnya:

const numbers = [1, 2, 3, 2, 4, 5, 5, 6];

Kalau kita:

const numberSet = new Set(numbers);

Set menjadi:

1, 2, 3, 4, 5, 6

Duplicate sudah hilang.

Kemudian:

numberSet.delete(5);

menjadi:

1, 2, 3, 4, 6

Kalau kita ubah kembali menjadi Array:

const result = [...numberSet];

hasil:

[1, 2, 3, 4, 6]

Jadi ketika menggunakan pola:

Array → Set → Array

kita harus sadar bahwa informasi duplicate dari Array akan hilang.

23. Ini penting dalam memilih data structure

Jangan berpikir:

“Set selalu lebih bagus daripada Array.”

Tidak.

Mereka memiliki tujuan berbeda.

Gunakan Array ketika:

• membutuhkan index
• membutuhkan akses berdasarkan posisi
• duplicate diperbolehkan
• urutan/posisi merupakan bagian penting dari data

Contoh:

const students = [
    "Budi",
    "Andi",
    "Siti"
];

console.log(students[0]);

Gunakan Set ketika:

• hanya membutuhkan nilai unik
• ingin mencegah duplicate
• sering mengecek apakah value ada
• sering menambahkan value
• sering menghapus value

Contoh:

const usernames = new Set();

usernames.add("budi");
usernames.add("andi");

usernames.has("budi");
usernames.delete("andi");

24. Jangan gunakan Set hanya karena “lebih cepat”

Ini juga penting.

Set bukan berarti:

“Array jelek, Set bagus.”

Tetapi:

Pilih data structure berdasarkan kebutuhan operasi yang paling sering dilakukan.

Kalau kebutuhanmu:

"Berikan element index ke-5"

gunakan Array.

Kalau kebutuhanmu:

"Apakah ID 123 sudah ada?"

Set sangat cocok.

Kalau kebutuhanmu:

"Jangan sampai ada username yang sama"

Set cocok.

Kalau kebutuhanmu:

"Ambil data pada posisi ke-10"

Array lebih cocok.

25. Contoh nyata: daftar ID unik

Bayangkan sebuah aplikasi menerima banyak ID:

const ids = [
    101,
    102,
    103,
    101,
    104,
    102
];

Kita ingin:

“Pastikan setiap ID hanya muncul sekali.”

Gunakan:

const uniqueIds = [...new Set(ids)];

Hasil:

[101, 102, 103, 104]

26. Contoh nyata: Mengecek user yang sudah login

Misalnya:

const onlineUsers = new Set();

onlineUsers.add("budi");
onlineUsers.add("andi");
onlineUsers.add("siti");

Ketika ingin mengecek apakah Budi sedang online:

onlineUsers.has("budi");

Hasil:

true

Ketika Budi logout:

onlineUsers.delete("budi");

Kemudian:

onlineUsers.has("budi");

hasil:

false

Ini sangat sesuai dengan karakteristik Set.

27. Contoh nyata: Produk yang sudah dipilih

Misalnya user memilih beberapa produk:

const selectedProducts = new Set();

selectedProducts.add("laptop");
selectedProducts.add("mouse");
selectedProducts.add("keyboard");

User tidak sengaja memilih laptop lagi:

selectedProducts.add("laptop");

Tidak akan muncul dua kali.

Kemudian kita bisa mengecek:

selectedProducts.has("laptop");

atau menghapus:

selectedProducts.delete("mouse");

Ini contoh sederhana kenapa Set berguna.

28. Pola kode yang perlu kamu kuasai

Menghilangkan duplicate

const unique = [...new Set(array)];

Union

const union = [...new Set([...arr1, ...arr2])];

Intersection

const set2 = new Set(arr2);

const intersection = arr1.filter(x => set2.has(x));

Difference

const set2 = new Set(arr2);

const difference = arr1.filter(x => !set2.has(x));

Membership check

const set = new Set(array);

set.has(value);

Delete

set.delete(value);

29. Kenapa lecture sering mengubah Array menjadi Set?

Perhatikan pola yang berulang:

const set = new Set(array);

Kemudian:

set.has(...)

atau:

set.delete(...)

Kenapa?

Karena kita sedang mengatakan:

“Saya punya Array, tetapi untuk operasi tertentu saya membutuhkan karakteristik Set.”

Misalnya kita punya:

const users = [/* banyak data */];

Tetapi kita ingin melakukan banyak pengecekan:

Apakah A ada?
Apakah B ada?
Apakah C ada?
Apakah D ada?
...

Maka kita bisa membuat:

const userSet = new Set(users);

Kemudian melakukan:

userSet.has(A);
userSet.has(B);
userSet.has(C);
userSet.has(D);

30. Tetapi ada trade-off

Ada satu hal yang perlu kamu sadari.

Ketika kita melakukan:

const set = new Set(array);

kita membuat struktur data baru.

Jadi kalau hanya melakukan satu kali pengecekan sederhana, belum tentu perlu mengubah Array menjadi Set.

Misalnya:

const numbers = [1, 2, 3, 4, 5];

numbers.includes(3);

sudah sangat sederhana.

Tetapi kalau kita punya data besar dan melakukan banyak sekali membership checks, membuat Set bisa menjadi pilihan yang lebih tepat.

Jadi jangan sekadar menghafal:

“Set lebih cepat.”

Lebih tepatnya:

Set dirancang untuk operasi membership seperti has() dan operasi penambahan/penghapusan secara efisien.

31. Hubungkan dengan lecture sebelumnya

Lecture sebelumnya mengatakan:

Set
 │
 ├── add()
 ├── delete()
 ├── has()
 ├── clear()
 └── size

Lecture sekarang menunjukkan kapan method-method tersebut berguna.

add()

Untuk menambahkan nilai unik:

set.add(value);

delete()

Untuk menghapus nilai:

set.delete(value);

has()

Untuk mengecek keberadaan:

set.has(value);

size

Untuk mengetahui jumlah:

set.size;

32. Cara berpikir paling sederhana

Ketika melihat sebuah masalah, tanyakan:

Pertanyaan 1

“Apakah saya butuh duplicate?”

Kalau iya → Array mungkin cocok.

Kalau tidak → Set mungkin cocok.

Pertanyaan 2

“Apakah saya perlu mengambil data berdasarkan index?”

Kalau iya:

array[0]
array[1]

→ gunakan Array.

Kalau tidak dan lebih sering mengecek keberadaan:

set.has(value)

→ Set cocok.

Pertanyaan 3

“Apakah saya sering menghapus berdasarkan value?”

Misalnya:

hapus "Budi"

bukan:

hapus index 5

Set bisa sangat cocok.

33. Kesimpulan besar

Jadi lecture ini sebenarnya ingin mengajarkan satu konsep utama:

Set bukan dibuat untuk menggantikan Array. Set dibuat untuk kebutuhan yang berbeda.

Array:

Fokus:
- posisi
- index
- urutan
- bisa duplicate

Set:

Fokus:
- uniqueness
- membership
- add
- delete
- has

Dan beberapa use case pentingnya:

Array
  │
  ├── hapus duplicate
  │       ↓
  │      Set
  │
  ├── cek keberadaan berkali-kali
  │       ↓
  │      Set
  │
  ├── Union
  │       ↓
  │      Set
  │
  ├── Intersection
  │       ↓
  │      Set + filter
  │
  └── Difference
          ↓
         Set + filter

Cheat sheet

// Array → Set
const set = new Set(array);

// Set → Array
const array = [...set];

// Array → Array unik
const unique = [...new Set(array)];

// Union
const union = [...new Set([...arr1, ...arr2])];

// Intersection
const set2 = new Set(arr2);
const intersection = arr1.filter(x => set2.has(x));

// Difference
const difference = arr1.filter(x => !set2.has(x));

// Cek keberadaan
set.has(value);

// Hapus
set.delete(value);

Kalimat kunci untuk diingat:

🟦 Array = “Data ini ada di posisi/index berapa?” 🟩 Set = “Data ini ada atau tidak, dan jangan sampai ada duplikat.”

Kalau kamu sudah memahami perbedaan dua kalimat tersebut, sebenarnya inti dari lecture ini sudah kamu kuasai.