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.
  • this di top-level adalah undefined.
  • 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/await diimplementasikan 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 extends dan super untuk inheritance.
  • Map mengizinkan key tipe apa pun dan menjaga urutan; Set menyimpan nilai unik.
  • Generator (function* dengan yield) 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.

Top