ES6+ Fitur Modern
ES6 (ES2015) membawa perubahan besar pada JavaScript. Artikel ini membahas fitur-fitur modern yang wajib dikuasai: let/const, template literal, destructuring, spread/rest, module, class, Map/Set, dan generator.
Pendahuluan
ES6 (ECMAScript 2015) adalah pembaruan terbesar JavaScript sejak bahasa ini lahir. Sejak ES6, JavaScript terus berevolusi setiap tahun — fitur-fitur baru ditambahkan (ES2016, ES2017, …, ES2023).
Banyak fitur ES6+ yang sudah kita pakai di artikel sebelumnya:
let/const(Sintaks Dasar).- Arrow function (Fungsi).
- Spread & destructuring (Array & Object).
- Optional chaining & nullish coalescing (Object).
Artikel ini merangkum fitur-fitur modern tersebut dalam satu tempat, plus fitur yang belum dibahas: template literal, module, class, Map/Set, generator, dan iterator.
Asumsi: Anda sudah memahami dasar-dasar JavaScript dari artikel sebelumnya. Semua fitur di artikel ini didukung browser modern (Chrome, Firefox, Safari, Edge) dan Node.js 18+.
Ringkasan Fitur ES6+ per Versi
| Versi | Fitur Utama |
|---|---|
| ES2015 (ES6) | let/const, arrow function, template literal, destructuring, spread/rest, default parameter, class, module, Map/Set, Promise, Symbol, generator |
| ES2016 | Array.prototype.includes, operator ** |
| ES2017 | async/await, Object.entries/values, string padding |
| ES2018 | Rest/spread object, async iteration, Promise.finally |
| ES2019 | Array.flat, Object.fromEntries, catch tanpa binding |
| ES2020 | Optional chaining ?., nullish coalescing ??, BigInt, Promise.allSettled, dynamic import |
| ES2021 | Promise.any, String.replaceAll, logical assignment ??= |
| ES2022 | Class field, top-level await, Object.hasOwn, Array.at |
| ES2023 | Array.findLast, toReversed/toSorted/toSpliced |
Template Literal
String dengan backtick (`) yang mendukung interpolasi dan multi-baris.
const nama = "Budi";
const umur = 25;
// Interpolasi
const sapaan = `Halo, ${nama}! Umur Anda ${umur} tahun.`;
console.log(sapaan); // "Halo, Budi! Umur Anda 25 tahun."
// Ekspresi di dalam ${}
const total = `Total: Rp${(150000 * 3).toLocaleString("id-ID")}`;
console.log(total); // "Total: Rp450.000"
// Multi-baris
const html = `
<div class="card">
<h3>${nama}</h3>
<p>Umur: ${umur}</p>
</div>
`;
// Ternary
const status = `Status: ${umur >= 18 ? "Dewasa" : "Anak-anak"}`;
Tagged template — fungsi yang memproses template literal:
function highlight(strings, ...values) {
return strings.reduce((result, str, i) => {
return result + str + (values[i] ? `<mark>${values[i]}</mark>` : "");
}, "");
}
const nama = "Budi";
const umur = 25;
const html = highlight`Nama: ${nama}, Umur: ${umur}`;
console.log(html);
// "Nama: <mark>Budi</mark>, Umur: <mark>25</mark>"
Destructuring
Array Destructuring
const [a, b, c] = [1, 2, 3];
console.log(a, b, c); // 1 2 3
// Skip
const [x, , z] = [1, 2, 3];
console.log(x, z); // 1 3
// Default
const [p = 10, q = 20] = [5];
console.log(p, q); // 5 20
// Rest
const [kepala, ...ekor] = [1, 2, 3, 4];
console.log(kepala); // 1
console.log(ekor); // [2, 3, 4]
// Swap
let m = 1, n = 2;
[m, n] = [n, m];
console.log(m, n); // 2 1
Object Destructuring
const user = { nama: "Budi", umur: 25, email: "[email protected]" };
const { nama, umur, email } = user;
// Rename
const { nama: namaUser } = user;
// Default
const { kota = "Jakarta" } = user;
// Nested
const { alamat: { jalan, kota: kotaAlamat } = {} } = user;
// Rest
const { nama, ...sisanya } = user;
console.log(sisanya); // { umur: 25, email: "..." }
Destructuring Parameter
function buatUser({ nama, umur = 18, role = "user" }) {
return { nama, umur, role };
}
buatUser({ nama: "Budi", umur: 25 });
// { nama: "Budi", umur: 25, role: "user" }
Spread dan Rest
Spread (...) — Menyebarkan
// Array
const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5]; // [1, 2, 3, 4, 5]
// Object
const user = { nama: "Budi", umur: 25 };
const userBaru = { ...user, email: "[email protected]" };
// Fungsi
Math.max(...[3, 1, 4, 1, 5]); // 5
// String → array
[...“Hello”]; // ["H", "e", "l", "l", "o"]
// Set → array
[...new Set([1, 2, 2, 3])]; // [1, 2, 3]
Rest (...) — Mengumpulkan
// Parameter fungsi
function jumlahkan(...angka) {
return angka.reduce((sum, n) => sum + n, 0);
}
jumlahkan(1, 2, 3, 4); // 10
// Destructuring array
const [kepala, ...ekor] = [1, 2, 3, 4];
// Destructuring object
const { nama, ...sisanya } = { nama: "Budi", umur: 25, email: "..." };
Default Parameter
function sapa(nama = "Anonim", sapaan = "Halo") {
return `${sapaan}, ${nama}!`;
}
sapa(); // "Halo, Anonim!"
sapa("Budi"); // "Halo, Budi!"
sapa("Budi", "Selamat pagi"); // "Selamat pagi, Budi!"
Default parameter juga bisa berupa ekspresi:
function buatId(prefix = "user", timestamp = Date.now()) {
return `${prefix}_${timestamp}`;
}
Enhanced Object Literal
Shorthand Property
const nama = "Budi";
const umur = 25;
// ❌ Verbose
const user1 = { nama: nama, umur: umur };
// ✅ Shorthand
const user2 = { nama, umur };
Shorthand Method
const user = {
nama: "Budi",
// ❌ Verbose
sapa1: function() { return `Halo, ${this.nama}`; },
// ✅ Shorthand
sapa2() { return `Halo, ${this.nama}`; }
};
Computed Property
const key = "nama";
const nilai = "Budi";
const user = {
[key]: nilai,
[`${key}_panjang`]: nilai.length
};
console.log(user); // { nama: "Budi", nama_panjang: 4 }
Module: import dan export
Module memungkinkan memecah kode menjadi file-file terpisah yang saling mengimpor.
Named Export/Import
math.js:
export const PI = 3.14159;
export function tambah(a, b) {
return a + b;
}
export function kali(a, b) {
return a * b;
}
app.js:
import { PI, tambah, kali } from "./math.js";
console.log(PI); // 3.14159
console.log(tambah(2, 3)); // 5
// Rename
import { tambah as add } from "./math.js";
// Import semua
import * as math from "./math.js";
console.log(math.PI);
Default Export/Import
user.js:
export default class User {
constructor(nama) {
this.nama = nama;
}
}
app.js:
import User from "./user.js";
const budi = new User("Budi");
Bisa juga fungsi/nilai:
// logger.js
export default function log(pesan) {
console.log(`[LOG] ${pesan}`);
}
// app.js
import log from "./logger.js";
log("Hello");
Kombinasi Default + Named
// api.js
export default function fetchData() { ... }
export const BASE_URL = "https://api.example.com";
export const TIMEOUT = 5000;
// app.js
import fetchData, { BASE_URL, TIMEOUT } from "./api.js";
Dynamic Import
Memuat module secara lazy (saat dibutuhkan):
button.addEventListener("click", async () => {
const { default: Chart } = await import("./chart.js");
new Chart();
});
Berguna untuk code splitting — mengurangi ukuran bundle awal.
Module di Browser
Tambahkan type="module" pada tag <script>:
<script type="module" src="app.js"></script>
Ciri module:
- Scope sendiri (tidak bocor ke global).
- Strict mode otomatis.
thisdi top-level adalahundefined.- Di-load secara deferred (setelah HTML di-parse).
- Harus di-serve via HTTP (bukan
file://) karena CORS.
Class
Class adalah sintaks modern untuk membuat object dengan constructor dan method (syntactic sugar di atas prototype).
Class Dasar
class User {
constructor(nama, umur) {
this.nama = nama;
this.umur = umur;
}
sapa() {
return `Halo, ${this.nama}!`;
}
get info() {
return `${this.nama} (${this.umur} tahun)`;
}
set umurBaru(nilai) {
if (nilai < 0) throw new Error("Umur tidak valid");
this.umur = nilai;
}
static buatAnonim() {
return new User("Anonim", 0);
}
}
const budi = new User("Budi", 25);
console.log(budi.sapa()); // "Halo, Budi!"
console.log(budi.info); // "Budi (25 tahun)"
console.log(User.buatAnonim()); // User { nama: "Anonim", umur: 0 }
Inheritance (Pewarisan)
class Admin extends User {
constructor(nama, umur, level) {
super(nama, umur); // panggil constructor parent
this.level = level;
}
sapa() {
return `${super.sapa()} Anda admin level ${this.level}.`;
}
hapusUser(user) {
console.log(`${this.nama} menghapus ${user.nama}`);
}
}
const admin = new Admin("Siti", 30, "super");
console.log(admin.sapa()); // "Halo, Siti! Anda admin level super."
admin.hapusUser(budi); // "Siti menghapus Budi"
Class Field (ES2022)
class Counter {
count = 0; // instance field
static total = 0; // static field
#rahasia = "private"; // private field
increment() {
this.count++;
Counter.total++;
}
getRahasia() {
return this.#rahasia;
}
}
const c = new Counter();
c.increment();
console.log(c.count); // 1
console.log(Counter.total); // 1
console.log(c.getRahasia()); // "private"
console.log(c.#rahasia); // SyntaxError (tidak bisa diakses dari luar)
Getter dan Setter
class Produk {
constructor(nama, harga) {
this.nama = nama;
this._harga = harga;
}
get harga() {
return this._harga;
}
set harga(nilai) {
if (nilai < 0) throw new Error("Harga tidak boleh negatif");
this._harga = nilai;
}
get hargaFormatted() {
return `Rp${this._harga.toLocaleString("id-ID")}`;
}
}
const p = new Produk("Keyboard", 450000);
console.log(p.hargaFormatted); // "Rp450.000"
p.harga = 500000;
console.log(p.harga); // 500000
Map dan Set
Map — Key-Value dengan Key Apa Pun
Berbeda dari object, Map mengizinkan key tipe apa pun (object, function, number) dan menjaga urutan insertion.
const map = new Map();
map.set("nama", "Budi");
map.set(1, "satu");
map.set(true, "benar");
const objKey = { id: 1 };
map.set(objKey, "object key");
console.log(map.get("nama")); // "Budi"
console.log(map.get(objKey)); // "object key"
console.log(map.size); // 4
console.log(map.has("nama")); // true
map.delete("nama");
map.clear();
Iterasi Map:
const map = new Map([
["nama", "Budi"],
["umur", 25]
]);
for (const [key, value] of map) {
console.log(`${key}: ${value}`);
}
// Method
map.keys(); // MapIterator
map.values(); // MapIterator
map.entries(); // MapIterator
Map vs Object:
| Aspek | Map |
Object |
|---|---|---|
| Key tipe | Apa pun | String/Symbol |
| Urutan | Dijaga | Tidak dijamin (kecuali string) |
| Size | .size |
Object.keys().length |
| Iterasi | Langsung | Object.entries() |
| Prototype | Tidak ada | Ada (toString, dll.) |
Kapan menggunakan Map? Saat key bukan string, atau butuh urutan yang terjamin, atau sering menambah/hapus key.
Set — Koleksi Nilai Unik
const set = new Set([1, 2, 2, 3, 3, 3]);
console.log(set); // Set(3) { 1, 2, 3 }
set.add(4);
set.add(1); // sudah ada, diabaikan
console.log(set.size); // 4
console.log(set.has(2)); // true
set.delete(3);
set.clear();
Iterasi Set:
for (const nilai of set) {
console.log(nilai);
}
Kegunaan Set:
- Menghapus duplikat:
[...new Set(arr)]. - Cek keberadaan cepat:
set.has(x)— O(1). - Menyimpan nilai unik.
WeakMap dan WeakSet
Mirip Map/Set, tetapi:
- Key harus object.
- Tidak mencegah garbage collection (weak reference).
- Tidak bisa diiterasi.
Berguna untuk menyimpan metadata pada object tanpa mencegahnya di-GC.
const weakMap = new WeakMap();
let user = { nama: "Budi" };
weakMap.set(user, { lastLogin: Date.now() });
console.log(weakMap.get(user));
user = null; // object bisa di-GC, entry di WeakMap otomatis hilang
Symbol
Symbol adalah tipe primitif yang selalu unik. Berguna sebagai key properti yang “tersembunyi”.
const id = Symbol("id");
const id2 = Symbol("id");
console.log(id === id2); // false
const user = {
nama: "Budi",
[id]: 12345
};
console.log(user[id]); // 12345
console.log(Object.keys(user)); // ["nama"] — Symbol tidak muncul
Well-known Symbols:
// Symbol.iterator — membuat object iterable
const obj = {
data: [1, 2, 3],
[Symbol.iterator]() {
let i = 0;
return {
next: () => ({
value: this.data[i],
done: i++ >= this.data.length
})
};
}
};
console.log([...obj]); // [1, 2, 3]
Generator dan Iterator
Iterator
Iterator adalah object dengan method next() yang mengembalikan { value, done }.
function buatIterator(arr) {
let i = 0;
return {
next() {
if (i < arr.length) {
return { value: arr[i++], done: false };
}
return { value: undefined, done: true };
}
};
}
const it = buatIterator([1, 2, 3]);
console.log(it.next()); // { value: 1, done: false }
console.log(it.next()); // { value: 2, done: false }
console.log(it.next()); // { value: 3, done: false }
console.log(it.next()); // { value: undefined, done: true }
Generator — function*
Generator adalah fungsi yang bisa dijeda dan dilanjutkan, menghasilkan nilai satu per satu dengan yield.
function* angka() {
yield 1;
yield 2;
yield 3;
}
const gen = angka();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: 3, done: false }
console.log(gen.next()); // { value: undefined, done: true }
Generator bisa diiterasi:
for (const n of angka()) {
console.log(n); // 1, 2, 3
}
// Atau spread
console.log([...angka()]); // [1, 2, 3]
Generator dengan loop:
function* range(start, end, step = 1) {
for (let i = start; i <= end; i += step) {
yield i;
}
}
console.log([...range(1, 10, 2)]); // [1, 3, 5, 7, 9]
Generator tak terbatas (lazy):
function* fibonacci() {
let [a, b] = [0, 1];
while (true) {
yield a;
[a, b] = [b, a + b];
}
}
const fib = fibonacci();
console.log(fib.next().value); // 0
console.log(fib.next().value); // 1
console.log(fib.next().value); // 1
console.log(fib.next().value); // 2
// ... tak terbatas, tetapi hanya dihitung saat diminta
Kegunaan generator:
- Lazy evaluation (data besar/tak terbatas).
- Membuat iterable kustom.
- State machine.
async/awaitdiimplementasikan di atas generator (di balik layar).
Fitur Modern Lainnya
Logical Assignment (ES2021)
let a = null;
a ??= "default"; // a = "default" (jika null/undefined)
let b = 0;
b ||= 10; // b = 10 (jika falsy)
let c = 1;
c &&= 2; // c = 2 (jika truthy)
String.replaceAll() (ES2021)
"Hello World World".replaceAll("World", "JS");
// "Hello JS JS"
Array.at() (ES2022)
const arr = [10, 20, 30];
console.log(arr.at(-1)); // 30
console.log(arr.at(-2)); // 20
Object.hasOwn() (ES2022)
const user = { nama: "Budi" };
console.log(Object.hasOwn(user, "nama")); // true
console.log(Object.hasOwn(user, "toString")); // false (dari prototype)
Top-Level await (ES2022, module)
// Di module (bukan di fungsi)
const data = await fetch("/api/data").then(r => r.json());
console.log(data);
Array.findLast() / findLastIndex() (ES2023)
const angka = [1, 2, 3, 4, 5];
console.log(angka.findLast(n => n < 4)); // 3
toReversed(), toSorted(), toSpliced() (ES2023)
Versi non-mutasi dari reverse(), sort(), splice().
const arr = [3, 1, 2];
console.log(arr.toSorted()); // [1, 2, 3]
console.log(arr); // [3, 1, 2] (tidak berubah)
Ringkasan
| Fitur | Versi | Kegunaan |
|---|---|---|
let/const |
ES6 | Block scope |
| Arrow function | ES6 | Sintaks ringkas, lexical this |
| Template literal | ES6 | Interpolasi & multi-baris |
| Destructuring | ES6 | Ekstrak nilai dari array/object |
| Spread/Rest | ES6 | Sebarkan/kumpulkan |
| Default parameter | ES6 | Nilai default |
| Class | ES6 | OOP modern |
| Module | ES6 | import/export |
Map/Set |
ES6 | Koleksi key-value & unik |
Symbol |
ES6 | Identifier unik |
| Generator | ES6 | Lazy evaluation |
async/await |
ES2017 | Async code |
?. / ?? |
ES2020 | Optional chaining, nullish |
Object.hasOwn |
ES2022 | Cek properti sendiri |
Array.at |
ES2022 | Akses index negatif |
toSorted dll. |
ES2023 | Non-mutasi array |
Poin penting:
- Module memecah kode menjadi file terpisah — gunakan
type="module"di browser. - Class adalah syntactic sugar di atas prototype — gunakan
extendsdansuperuntuk inheritance. Mapmengizinkan key tipe apa pun dan menjaga urutan;Setmenyimpan nilai unik.- Generator (
function*denganyield) memungkinkan lazy evaluation. - Private field (
#nama) di class benar-benar tidak bisa diakses dari luar. toSorted()dan sejenisnya adalah versi non-mutasi — lebih aman untuk data yang tidak boleh berubah.
Pada artikel berikutnya, kita akan membahas Asynchronous JavaScript — callback, Promise, async/await, dan event loop.