BAB 6: JavaScript Modern untuk React (ES6+)
Fitur JavaScript modern yang wajib dipahami sebelum coding React: arrow function, destructuring, spread, modules, dan class.
Di akhir bab sebelumnya, kita bicara tentang evolusi React (bagaimana API lama digantikan yang baru, dan mengapa perubahan itu diperlukan. Evolusi yang sama juga terjadi di JavaScript sendiri. Sebelum tahun 2015, JavaScript punya banyak keterbatasan yang membuat kode menjadi verbose dan sulit dikelola. ES6) atau ECMAScript 2015, datang mengubah itu secara fundamental.
React tidak bisa dilepaskan dari ES6. Hampir setiap baris kode React yang akan kita tulis ke depan menggunakan fitur-fitur dari standar ini: dari cara kita mendeklarasikan variabel, mendefinisikan fungsi, mengambil data dari objek dan array, hingga cara kita mengorganisir kode ke dalam modul. Memahami ES6 dengan baik bukan sekadar bekal, ia adalah prasyarat untuk menulis kode React yang idiomatis dan mudah dipahami.
let dan const
Sebelum ES6, JavaScript hanya punya satu cara mendeklarasikan variabel: var. Masalahnya, var punya perilaku yang sering mengejutkan, ia tidak terbatas pada blok kode, melainkan pada seluruh fungsi di mana ia dideklarasikan.
// cara lama dengan var
function hitungTotal() {
var harga = 25000
if (true) {
var harga = 99000 // menimpa variabel di atas!
console.log(harga) // 99000
}
console.log(harga) // 99000, bukan 25000
}
ES6 memperkenalkan let dan const yang punya block scope, keduanya hanya hidup di dalam blok kode tempat mereka dideklarasikan:
// src/App.jsx
function hitungTotal() {
const harga = 25000
if (true) {
const harga = 99000 // variabel berbeda, scope berbeda
console.log(harga) // 99000
}
console.log(harga) // 25000, tidak berubah
}
Panduan penggunaannya sederhana:
- Gunakan
constuntuk nilai yang tidak akan pernah di-reassign, ini mencakup hampir semua deklarasi di React - Gunakan
letketika nilai memang perlu berubah di kemudian hari (counter dalam loop, akumulasi nilai, dll.) - Hindari
varsepenuhnya
Di kode React, kamu akan melihat const mendominasi. Komponen, fungsi handler, variabel hasil destructuring, hampir semua dideklarasikan dengan const. Ini bukan kebetulan, melainkan konvensi yang disengaja: ia membantu kita dan pembaca kode memahami bahwa referensi variabel tersebut tidak akan berubah.
Arrow Function
Arrow function adalah cara menulis fungsi yang lebih ringkas. Sebelum ES6, fungsi ditulis seperti ini:
// fungsi biasa
const kalikanDua = function(angka) {
return angka * 2
}
Dengan arrow function, penulisannya jauh lebih singkat:
// arrow function
const kalikanDua = (angka) => {
return angka * 2
}
// jika body hanya satu ekspresi, return bisa diimplisitkan
const kalikanDua = (angka) => angka * 2
// jika hanya satu parameter, kurung bisa dihilangkan
const kalikanDua = angka => angka * 2
Di React, arrow function dipakai di mana-mana. Event handler, fungsi transform data, dan komponen kecil sering ditulis menggunakan arrow function:
// src/App.jsx: daftar tugas yang sudah kita buat
const tugasSudahSelesai = daftarTugas.filter(tugas => tugas.selesai)
const judulTugas = daftarTugas.map(tugas => tugas.judul)
Ada satu perbedaan penting antara arrow function dan fungsi biasa yang perlu dipahami: arrow function tidak punya this sendiri. Ia mewarisi this dari scope di sekitarnya. Dalam konteks React modern dengan functional component dan hooks, ini hampir tidak pernah jadi masalah, tapi penting diketahui saat bekerja dengan class component (yang kita bahas di Bab 12).
Destructuring
Destructuring adalah cara mengekstrak nilai dari objek atau array dan langsung menyimpannya ke variabel. Bayangkan kamu punya objek pengguna:
const pengguna = {
nama: 'Budi',
usia: 28,
kota: 'Bandung'
}
Tanpa destructuring, mengakses setiap field terasa repetitif:
const nama = pengguna.nama
const usia = pengguna.usia
const kota = pengguna.kota
Dengan destructuring objek, cukup satu baris:
const { nama, usia, kota } = pengguna
console.log(nama) // Budi
console.log(usia) // 28
Destructuring Array
Destructuring juga bekerja pada array, nilai diambil berdasarkan posisi, bukan nama:
const koordinat = [106.8272, -6.1751]
const [longitude, latitude] = koordinat
console.log(longitude) // 106.8272
console.log(latitude) // -6.1751
Destructuring dengan Nilai Default
Jika field yang di-destructure mungkin tidak ada, kita bisa menetapkan nilai default:
const { nama, usia, status = 'aktif' } = pengguna
// jika pengguna tidak punya field 'status', nilainya jadi 'aktif'
Destructuring di React
Destructuring adalah pola paling umum di React. Kamu akan menggunakannya saat:
Mengambil nilai dari hooks:
// src/App.jsx
const [jumlahTugas, setJumlahTugas] = useState(0)
Membaca props di dalam komponen:
// bukan props.judul, props.deskripsi
const KartuTugas = ({ judul, deskripsi, selesai }) => {
return <div>{judul}</div>
}
Kita akan membahas props dan hooks secara mendalam di bab-bab selanjutnya. Yang perlu dipahami sekarang: destructuring membuat kode React terasa bersih dan langsung ke poin.
Spread dan Rest Operator
Keduanya menggunakan sintaks yang sama (tiga titik (...)) tapi digunakan dalam konteks yang berbeda.
Spread: Menyebarkan Isi
Spread operator "menyebarkan" isi array atau objek ke dalam konteks baru. Cara termudah memvisualisasikannya:
const bulan = ['Jan', 'Feb', 'Mar']
const bulanTambahan = ['Apr', 'Mei']
// tanpa spread, hasilnya array dalam array
const gabungan = [bulan, bulanTambahan]
// [['Jan', 'Feb', 'Mar'], ['Apr', 'Mei']]
// dengan spread, isinya "ditumpahkan" ke array baru
const gabungan = [...bulan, ...bulanTambahan]
// ['Jan', 'Feb', 'Mar', 'Apr', 'Mei']
Hal yang sama berlaku untuk objek:
const infoAlamat = { kota: 'Jakarta', provinsi: 'DKI' }
const infoKontak = { telepon: '08123', email: '[email protected]' }
// menggabungkan dua objek
const profilLengkap = { ...infoAlamat, ...infoKontak }
Di React, spread operator digunakan hampir di mana-mana. Saat memperbarui state array (menambah item tanpa mutasi), meneruskan semua props ke komponen anak, atau membuat salinan objek dengan beberapa field yang diubah, semuanya menggunakan spread.
Rest: Mengumpulkan Sisanya
Rest operator bekerja sebaliknya: ia mengumpulkan elemen-elemen yang tersisa menjadi satu array atau objek. Paling sering digunakan di parameter fungsi dan destructuring:
const [ketua, wakil, ...anggotaLain] = ['Ali', 'Budi', 'Citra', 'Dian', 'Eka']
console.log(ketua) // Ali
console.log(wakil) // Budi
console.log(anggotaLain) // ['Citra', 'Dian', 'Eka']
Atau di parameter fungsi untuk menerima jumlah argumen yang fleksibel:
const jumlahkan = (...angka) => angka.reduce((total, n) => total + n, 0)
console.log(jumlahkan(1, 2, 3, 4, 5)) // 15
Array Methods: map, filter, reduce
Tiga method array ini adalah tulang punggung transformasi data di React. Sebelum bisa nyaman dengan React, kamu perlu benar-benar fasih menggunakan ketiganya.
map: Transformasi Satu per Satu
map mengiterasi setiap elemen array dan menghasilkan array baru berisi nilai yang sudah ditransformasi:
// src/App.jsx
const nilai = [70, 85, 90, 60, 95]
// tambah 5 poin ke semua nilai
const nilaiSetelahBonus = nilai.map(n => n + 5)
// [75, 90, 95, 65, 100]
Di React, map adalah cara standar mengubah array data menjadi array elemen JSX:
const daftarSiswa = ['Alya', 'Bima', 'Cinta']
// menghasilkan array elemen <li>
const elemenList = daftarSiswa.map(nama => <li key={nama}>{nama}</li>)
Kita akan membahas rendering list secara khusus di Bab 18.
filter: Menyaring Elemen
filter menghasilkan array baru yang hanya berisi elemen-elemen yang memenuhi kondisi tertentu:
const produk = [
{ nama: 'Laptop', harga: 8000000, tersedia: true },
{ nama: 'Mouse', harga: 150000, tersedia: false },
{ nama: 'Keyboard', harga: 500000, tersedia: true },
]
// hanya tampilkan produk yang tersedia
const produkTersedia = produk.filter(p => p.tersedia)
// [{ nama: 'Laptop', ... }, { nama: 'Keyboard', ... }]
// hanya tampilkan produk di bawah 1 juta
const produkTerjangkau = produk.filter(p => p.harga < 1000000)
reduce: Akumulasi Nilai
reduce adalah method paling fleksibel, ia "melipat" seluruh array menjadi satu nilai tunggal. Sering dipakai untuk penjumlahan, pengelompokan, atau membangun struktur data baru:
const hargaBelanja = [25000, 50000, 15000, 80000]
const totalBelanja = hargaBelanja.reduce((total, harga) => total + harga, 0)
// 170000
map, filter, dan reduce tidak mengubah array asli, ketiganya selalu menghasilkan array baru. Di React, ini penting: kita tidak ingin memodifikasi data secara langsung (mutasi), karena React menggunakan perbandingan referensi untuk mendeteksi perubahan state.
Ternary Operator
Ternary operator adalah cara ringkas menulis kondisi sederhana dalam satu baris. Formatnya: kondisi ? jikaBetul : jikaFalse.
const skor = 75
const predikat = skor >= 70 ? 'Lulus' : 'Tidak Lulus'
// 'Lulus'
Di React, ternary operator sering digunakan untuk render kondisional di dalam JSX, karena if/else tidak bisa digunakan langsung di tengah markup:
// src/App.jsx
return (
<div>
{sedangMemuat ? <Spinner /> : <DaftarProduk data={produk} />}
</div>
)
Untuk kondisi yang hanya perlu menampilkan atau tidak menampilkan sesuatu (tanpa cabang else), ada cara yang lebih ringkas lagi menggunakan short-circuit &&:
// tampilkan pesan hanya jika ada error
return (
<div>
{pesanError && <div className="error">{pesanError}</div>}
<FormPendaftaran />
</div>
)
Ekspresi A && B di JavaScript mengevaluasi ke B jika A adalah truthy, atau ke A jika falsy. Di JSX, React mengabaikan false, null, dan undefined, sehingga pola ini efektif untuk render kondisional.
Modules: import dan export
Di proyek React yang nyata, kode dipecah ke banyak file. Setiap file adalah sebuah modul, dan kita menggunakan import serta export untuk berbagi kode antar modul.
Named Export
// src/utils/format.js
export const formatRupiah = (angka) => {
return new Intl.NumberFormat('id-ID', {
style: 'currency',
currency: 'IDR'
}).format(angka)
}
export const formatTanggal = (tanggal) => {
return new Intl.DateTimeFormat('id-ID').format(new Date(tanggal))
}
File lain bisa mengimpor fungsi-fungsi ini dengan menyebut namanya:
// src/components/KartuProduk.jsx
import { formatRupiah, formatTanggal } from '../utils/format'
const KartuProduk = ({ nama, harga, tanggalRilis }) => {
return (
<div>
<h3>{nama}</h3>
<p>{formatRupiah(harga)}</p>
<p>{formatTanggal(tanggalRilis)}</p>
</div>
)
}
Default Export
Setiap file juga bisa punya satu default export, biasanya komponen utama yang menjadi "isi utama" file tersebut:
// src/components/KartuProduk.jsx
const KartuProduk = ({ nama, harga }) => {
return <div>{nama}, {harga}</div>
}
export default KartuProduk
Saat mengimport default export, kita bisa memilih nama apapun:
// src/App.jsx
import KartuProduk from './components/KartuProduk'
// atau bisa juga
import Kartu from './components/KartuProduk'
Kapan Pakai Mana?
Konvensi umum di proyek React:
- Default export untuk komponen utama per file
- Named export untuk utility functions, helper, konstanta, atau beberapa item dari satu file
Proyek Vite yang sudah kita buat menggunakan pola ini: App.jsx mengekspor komponen App sebagai default, sementara main.jsx mengimpornya dengan import App from './App'.
Class di JavaScript
JavaScript ES6 memperkenalkan sintaks class, bukan paradigma baru, melainkan sintaks yang lebih familiar bagi developer yang berasal dari bahasa seperti Java atau Python. Di balik layar, JavaScript tetap menggunakan prototype-based inheritance.
class Kendaraan {
constructor(merek, tahun) {
this.merek = merek
this.tahun = tahun
}
info() {
return `${this.merek} (${this.tahun})`
}
}
class Mobil extends Kendaraan {
constructor(merek, tahun, pintu) {
super(merek, tahun) // panggil constructor parent
this.pintu = pintu
}
deskripsi() {
return `${this.info()}, ${this.pintu} pintu`
}
}
const sedan = new Mobil('Toyota', 2022, 4)
console.log(sedan.deskripsi()) // Toyota (2022): 4 pintu
Di React, class digunakan untuk membuat class component: cara lama sebelum Hooks diperkenalkan di React 16.8. Kita akan membahas class component di Bab 12. Untuk bab-bab selanjutnya hingga Bab 11, semua komponen yang kita tulis menggunakan functional component, yang lebih sederhana dan kini menjadi standar industri.
Kamu tidak perlu mahir menulis class untuk bisa coding React modern. Tapi memahami sintaksnya penting karena banyak tutorial lama, kode warisan, dan library yang masih menggunakan class component. Kemampuan membaca class component adalah kompetensi yang perlu dimiliki, meski menulis functional component lebih sering dilakukan.
Template Literals
Sebelum ES6, menggabungkan string dan variabel terasa awkward:
const nama = 'Ani'
const usia = 24
const pesan = 'Halo, nama saya ' + nama + ' dan saya berusia ' + usia + ' tahun.'
Template literal menggunakan backtick (`) dan ekspresi ${...} untuk interpolasi yang jauh lebih bersih:
const pesan = `Halo, nama saya ${nama} dan saya berusia ${usia} tahun.`
Template literal juga mendukung string multi-baris tanpa karakter escape:
const html = `
<div class="kartu">
<h2>${nama}</h2>
<p>Usia: ${usia}</p>
</div>
`
Di React, template literal paling sering muncul untuk membangun className secara dinamis atau menyusun pesan yang menggabungkan data:
const statusKelas = `tombol ${aktif ? 'tombol--aktif' : 'tombol--nonaktif'}`
Latihan
Coba terapkan konsep-konsep yang baru kita pelajari pada proyek daftar-tugas yang sudah dibuat di bab sebelumnya:
-
Di
App.jsx, buat array objek tugas dengan minimal 5 item, masing-masing punya fieldid,judul,selesai(boolean), danprioritas('tinggi','sedang', atau'rendah'). Gunakanconstdan objek literal ES6. -
Gunakan
filteruntuk membuat dua array turunan: satu berisi tugas yang sudah selesai, satu berisi yang belum. Tampilkan jumlah masing-masing di konsol. -
Gunakan
mapuntuk menghasilkan array string berformat`[${selesai ? 'x' : ' '}] ${judul}`dari setiap tugas, lalu tampilkan di konsol. Ini adalah representasi teks tugas seperti yang ada di aplikasi todo CLI. -
Gunakan destructuring saat mengambil field dari setiap tugas di dalam callback
map, jangan gunakantugas.judul, tapi destructure langsung di parameter.
Penutup
ES6 bukan sekadar sekumpulan fitur baru, ia mengubah cara developer JavaScript berpikir tentang kode. const dan let membuat scope lebih terprediksi. Arrow function membuat kode lebih ringkas. Destructuring menghilangkan repetisi. Spread menjaga immutability. Modules membuat kode terorganisir. Dan template literal membuat string composition menjadi menyenangkan.
Semua yang kita pelajari di bab ini akan muncul terus-menerus di bab-bab selanjutnya, bukan sebagai konsep yang dipelajari lagi, melainkan sebagai alat yang langsung digunakan. Mulai bab berikutnya, kita masuk ke salah satu konsep paling khas React: JSX. Kamu akan segera melihat bagaimana destructuring dan spread operator yang baru dipelajari langsung berperan dalam cara kita menulis markup di React.