Fondasi React

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.

React JSXJSX
// 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:

React JSXJSX
// 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 const untuk nilai yang tidak akan pernah di-reassign, ini mencakup hampir semua deklarasi di React
  • Gunakan let ketika nilai memang perlu berubah di kemudian hari (counter dalam loop, akumulasi nilai, dll.)
  • Hindari var sepenuhnya

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:

React JSXJSX
// fungsi biasa
const kalikanDua = function(angka) {
  return angka * 2
}

Dengan arrow function, penulisannya jauh lebih singkat:

React JSXJSX
// 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:

React JSXJSX
// 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:

React JSXJSX
const pengguna = {
  nama: 'Budi',
  usia: 28,
  kota: 'Bandung'
}

Tanpa destructuring, mengakses setiap field terasa repetitif:

React JSXJSX
const nama = pengguna.nama
const usia = pengguna.usia
const kota = pengguna.kota

Dengan destructuring objek, cukup satu baris:

React JSXJSX
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:

React JSXJSX
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:

React JSXJSX
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:

React JSXJSX
// src/App.jsx
const [jumlahTugas, setJumlahTugas] = useState(0)

Membaca props di dalam komponen:

React JSXJSX
// 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:

React JSXJSX
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:

React JSXJSX
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:

React JSXJSX
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:

React JSXJSX
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:

React JSXJSX
// 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:

React JSXJSX
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:

React JSXJSX
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:

React JSXJSX
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.

React JSXJSX
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:

React JSXJSX
// 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 &&:

React JSXJSX
// 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

React JSXJSX
// 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:

React JSXJSX
// 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:

React JSXJSX
// 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:

React JSXJSX
// 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.

React JSXJSX
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:

React JSXJSX
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:

React JSXJSX
const pesan = `Halo, nama saya ${nama} dan saya berusia ${usia} tahun.`

Template literal juga mendukung string multi-baris tanpa karakter escape:

React JSXJSX
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:

React JSXJSX
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:

  1. Di App.jsx, buat array objek tugas dengan minimal 5 item, masing-masing punya field id, judul, selesai (boolean), dan prioritas ('tinggi', 'sedang', atau 'rendah'). Gunakan const dan objek literal ES6.

  2. Gunakan filter untuk membuat dua array turunan: satu berisi tugas yang sudah selesai, satu berisi yang belum. Tampilkan jumlah masing-masing di konsol.

  3. Gunakan map untuk 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.

  4. Gunakan destructuring saat mengambil field dari setiap tugas di dalam callback map, jangan gunakan tugas.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.

Referensi

  1. 1 Belajar JavaScript Dasar #7: Arrow Function: SantriKoding
  2. 2 Belajar JavaScript Dasar #12: Destructuring & Restructuring: SantriKoding