Module Bundler & Build Tool
Proyek JavaScript modern membutuhkan build tool: bundler untuk menggabungkan module, transpiler untuk kompatibilitas, linter untuk kualitas kode, dan formatter untuk konsistensi. Artikel ini membahas Vite, Webpack, Babel, ESLint, dan Prettier.
Pendahuluan
Saat proyek JavaScript tumbuh, kita menghadapi masalah baru:
- Banyak file module — browser perlu banyak request HTTP (lambat).
- Fitur modern — sebagian browser belum mendukung (
?.,??, class field). - Kualitas kode — tanpa aturan, kode menjadi tidak konsisten.
- Aset non-JS — CSS, gambar, font perlu diproses.
- Optimasi produksi — minifikasi, tree shaking, code splitting.
Build tool menyelesaikan masalah ini. Artikel ini membahas:
- Bundler — Vite (rekomendasi modern) dan Webpack.
- Transpiler — Babel (dan esbuild/SWC).
- Linter — ESLint.
- Formatter — Prettier.
Asumsi: Anda sudah memahami Node.js dan npm dari artikel sebelumnya. Semua contoh menggunakan npm.
Mengapa Perlu Build Tool?
Masalah Tanpa Build Tool
<!-- Banyak tag script — banyak request HTTP -->
<script src="utils.js"></script>
<script src="api.js"></script>
<script src="components/button.js"></script>
<script src="components/modal.js"></script>
<script src="app.js"></script>
<!-- ... 50 file lagi -->
- Banyak request — setiap file = satu request HTTP.
- Urutan manual — dependency harus dimuat dalam urutan yang benar.
- Tidak ada optimasi — kode tidak diminifikasi.
- Kompatibilitas — fitur modern mungkin gagal di browser lama.
Solusi Build Tool
Source code (banyak file, fitur modern)
↓ Build tool
Bundle (satu/beberapa file, dioptimasi, kompatibel)
↓
Browser
Build tool menangani:
- Bundling — menggabungkan module menjadi satu/beberapa file.
- Transpiling — mengubah fitur modern ke kode yang kompatibel.
- Minifikasi — menghapus spasi, komentar, memperpendek nama.
- Tree shaking — menghapus kode yang tidak dipakai.
- Code splitting — memecah bundle agar dimuat sesuai kebutuhan.
- Asset handling — memproses CSS, gambar, font.
- Dev server — live reload / hot reload.
Vite — Bundler Modern (Rekomendasi)
Vite (dibaca “vit”, bahasa Prancis untuk “cepat”) adalah build tool modern yang dikembangkan oleh Evan You (pembuat Vue). Vite menggunakan esbuild (sangat cepat) untuk development dan Rollup untuk produksi.
Mengapa Vite?
- Sangat cepat — dev server启动 dalam milidetik (bukan detik).
- Hot Module Replacement (HMR) instan.
- Konfigurasi minimal — bekerja out-of-the-box.
- Native ES Module di development — tidak perlu bundling saat dev.
- Optimasi produksi — Rollup + minifikasi.
Membuat Proyek Vite
npm create vite@latest my-app
Ikuti prompt:
? Select a framework: › Vanilla
? Select a variant: › JavaScript
Atau langsung:
npm create vite@latest my-app -- --template vanilla
Masuk dan jalankan:
cd my-app
npm install
npm run dev
Output:
VITE v5.0.0 ready in 312 ms
➜ Local: http://localhost:5173/
➜ Network: use --host to expose
Struktur Proyek Vite
my-app/
├── index.html # Entry point HTML
├── package.json
├── vite.config.js # Konfigurasi (opsional)
├── public/ # Aset statis (tidak diproses)
│ └── favicon.ico
└── src/
├── main.js # Entry point JS
├── style.css
└── counter.js
index.html — entry point (bukan src/index.html):
<!DOCTYPE html>
<html lang="id">
<head>
<meta charset="UTF-8">
<title>Vite App</title>
</head>
<body>
<div id="app"></div>
<script type="module" src="/src/main.js"></script>
</body>
</html>
src/main.js:
import "./style.css";
import { setupCounter } from "./counter.js";
document.querySelector("#app").innerHTML = `
<h1>Hello Vite!</h1>
<button id="counter">count is 0</button>
`;
setupCounter(document.querySelector("#counter"));
src/counter.js:
export function setupCounter(element) {
let counter = 0;
const setCounter = (count) => {
counter = count;
element.textContent = `count is ${counter}`;
};
element.addEventListener("click", () => setCounter(counter + 1));
setCounter(0);
}
Perintah Vite
npm run dev # Dev server (HMR)
npm run build # Build untuk produksi → dist/
npm run preview # Preview hasil build
Konfigurasi Vite (vite.config.js)
import { defineConfig } from "vite";
export default defineConfig({
server: {
port: 3000,
open: true, // buka browser otomatis
proxy: {
"/api": {
target: "http://localhost:5000",
changeOrigin: true
}
}
},
build: {
outDir: "dist",
sourcemap: true,
minify: "esbuild"
}
});
Environment Variables di Vite
Vite hanya mengekspos variable dengan prefix VITE_:
# .env
VITE_API_URL=https://api.example.com
VITE_APP_TITLE=Toko Online
console.log(import.meta.env.VITE_API_URL);
console.log(import.meta.env.VITE_APP_TITLE);
console.log(import.meta.env.MODE); // "development" / "production"
console.log(import.meta.env.DEV); // true di development
console.log(import.meta.env.PROD); // true di production
⚠️ Peringatan: Semua
VITE_*variable terekspos di bundle client. Jangan simpan rahasia (API key server, password) di sini.
Import Aset di Vite
// CSS
import "./style.css";
// Gambar — menghasilkan URL
import logo from "./assets/logo.png";
document.querySelector("img").src = logo;
// JSON
import data from "./data.json";
console.log(data);
// Dynamic import (code splitting)
const module = await import("./heavy-module.js");
Vite untuk React/Vue
# React
npm create vite@latest my-app -- --template react
# Vue
npm create vite@latest my-app -- --template vue
# TypeScript
npm create vite@latest my-app -- --template vanilla-ts
Webpack — Bundler Klasik
Webpack adalah bundler paling populer sebelum Vite. Masih sangat banyak digunakan, terutama di proyek lama dan enterprise.
Kelebihan dan Kekurangan
| Kelebihan | Kekurangan |
|---|---|
| Ekosistem plugin & loader sangat besar | Konfigurasi kompleks |
| Fleksibel — bisa handle apa saja | Dev server lebih lambat dari Vite |
| Banyak digunakan di enterprise | Kurva belajar curam |
| Dukungan jangka panjang | Setup awal memakan waktu |
Instalasi
npm install --save-dev webpack webpack-cli webpack-dev-server
Konfigurasi Dasar (webpack.config.js)
const path = require("path");
const HtmlWebpackPlugin = require("html-webpack-plugin");
module.exports = {
mode: "development",
entry: "./src/index.js",
output: {
path: path.resolve(__dirname, "dist"),
filename: "[name].[contenthash].js",
clean: true
},
module: {
rules: [
{
test: /\.css$/i,
use: ["style-loader", "css-loader"]
},
{
test: /\.(png|svg|jpg|jpeg|gif)$/i,
type: "asset/resource"
},
{
test: /\.js$/,
exclude: /node_modules/,
use: {
loader: "babel-loader",
options: {
presets: ["@babel/preset-env"]
}
}
}
]
},
plugins: [
new HtmlWebpackPlugin({
template: "./src/index.html"
})
],
devServer: {
static: "./dist",
port: 3000,
hot: true,
open: true
},
devtool: "source-map"
};
Script package.json
{
"scripts": {
"start": "webpack serve --mode development",
"build": "webpack --mode production"
}
}
Konsep Webpack
- Entry — file awal yang menjadi titik masuk.
- Output — tempat hasil bundle.
- Loaders — memproses file non-JS (CSS, gambar, dll.) sebelum di-bundle.
- Plugins — melakukan tugas tambahan (generate HTML, minify, dll.).
- Mode —
development(cepat, debug) atauproduction(optimasi).
Rekomendasi: Untuk proyek baru, gunakan Vite. Untuk proyek lama atau yang butuh konfigurasi sangat spesifik, Webpack masih relevan.
Babel — Transpiler
Babel mengubah kode JavaScript modern menjadi kode yang kompatibel dengan browser lama.
Mengapa Babel?
// Kode modern
const sapa = (nama) => `Halo, ${nama}!`;
const user = data?.user ?? "Anonim";
// Setelah Babel (target browser lama)
var sapa = function sapa(nama) {
return "Halo, ".concat(nama, "!");
};
var user = (_data$user = data === null || data === void 0 ? void 0 : data.user) !== null && _data$user !== void 0 ? _data$user : "Anonim";
Instalasi
npm install --save-dev @babel/core @babel/cli @babel/preset-env
Konfigurasi (babel.config.json)
{
"presets": [
["@babel/preset-env", {
"targets": "> 0.5%, last 2 versions, not dead",
"useBuiltIns": "usage",
"corejs": 3
}]
]
}
targets menentukan browser yang didukung:
"> 0.5%, last 2 versions, not dead"— browser dengan market share > 0.5%, 2 versi terakhir, yang masih di-maintain."last 2 chrome versions"— hanya Chrome 2 versi terakhir."ie 11"— termasuk IE11 (butuh banyak polyfill).
Menggunakan Babel
# Transpile satu file
npx babel src/index.js --out-file dist/index.js
# Transpile folder
npx babel src --out-dir dist
Babel dengan Bundler
Babel biasanya digunakan bersama Webpack (via babel-loader) atau Vite (via plugin). Untuk Vite, transpilasi dilakukan oleh esbuild secara otomatis — Babel hanya diperlukan untuk fitur yang belum didukung esbuild.
Preset Umum
| Preset | Kegunaan |
|---|---|
@babel/preset-env |
Transpile ES6+ ke target browser |
@babel/preset-react |
JSX untuk React |
@babel/preset-typescript |
TypeScript |
Polyfill
Babel tidak menambahkan fitur baru (seperti Promise, Array.includes) — itu tugas polyfill. Gunakan core-js:
npm install core-js
Dengan useBuiltIns: "usage", Babel otomatis mengimpor polyfill yang dibutuhkan.
Catatan: Vite (esbuild) dan browser modern sudah mendukung sebagian besar fitur. Polyfill hanya diperlukan untuk browser lama.
ESLint — Linter
ESLint menganalisis kode untuk menemukan error dan masalah style sebelum dijalankan.
Mengapa ESLint?
// ESLint akan menandai:
if (x == 5) { } // gunakan ===
const unused = 10; // variabel tidak dipakai
function f() { return; }
console.log(y); // y tidak dideklarasikan
Instalasi
npm install --save-dev eslint
npx eslint --init
Ikuti prompt:
? How would you like to use ESLint? › To check syntax, find problems, and enforce code style
? What type of modules does your project use? › JavaScript modules (import/export)
? Which framework does your project use? › None of these
? Does your project use TypeScript? › No
? Where does your code run? › Browser, Node
? How would you like to define a style for your project? › Use a popular style guide
? Which style guide do you want to follow? › Airbnb
? What format do you want your config file to be in? › JSON
Menghasilkan eslint.config.js (flat config, ESLint 9+) atau .eslintrc.json (lama).
Konfigurasi Flat (eslint.config.js)
import js from "@eslint/js";
export default [
js.configs.recommended,
{
languageOptions: {
ecmaVersion: 2022,
sourceType: "module",
globals: {
window: "readonly",
document: "readonly",
console: "readonly"
}
},
rules: {
"no-unused-vars": "warn",
"no-console": "off",
"eqeqeq": "error",
"prefer-const": "error",
"no-var": "error"
}
}
];
Menjalankan ESLint
# Cek semua file
npx eslint .
# Cek satu file
npx eslint src/index.js
# Auto-fix
npx eslint . --fix
# Format output
npx eslint . --format stylish
Tingkat Rule
| Level | Arti |
|---|---|
"off" / 0 |
Nonaktif |
"warn" / 1 |
Peringatan (tidak gagal) |
"error" / 2 |
Error (gagal) |
Script package.json
{
"scripts": {
"lint": "eslint .",
"lint:fix": "eslint . --fix"
}
}
Integrasi Editor
Install extension ESLint di VS Code — error dan warning muncul langsung di editor.
Prettier — Formatter
Prettier memformat kode secara otomatis agar konsisten — spasi, indentasi, tanda kutip, titik koma, dll.
Mengapa Prettier?
// Sebelum Prettier
const user={nama:"Budi",umur:25,alamat:{kota:"Jakarta"}}
function sapa(nama){return `Halo, ${nama}!`}
// Setelah Prettier
const user = { nama: "Budi", umur: 25, alamat: { kota: "Jakarta" } };
function sapa(nama) {
return `Halo, ${nama}!`;
}
Instalasi
npm install --save-dev prettier
Konfigurasi (.prettierrc)
{
"semi": true,
"singleQuote": false,
"tabWidth": 2,
"trailingComma": "es5",
"printWidth": 80,
"arrowParens": "always"
}
| Opsi | Arti |
|---|---|
semi |
Titik koma di akhir statement |
singleQuote |
Gunakan ' bukan " |
tabWidth |
Lebar indentasi |
trailingComma |
Koma di akhir (es5, all, none) |
printWidth |
Panjang baris maksimum |
arrowParens |
Kurung pada arrow function satu parameter |
Menjalankan Prettier
# Format semua file
npx prettier . --write
# Cek tanpa mengubah
npx prettier . --check
# Format file tertentu
npx prettier src/index.js --write
.prettierignore
node_modules/
dist/
package-lock.json
*.min.js
Script package.json
{
"scripts": {
"format": "prettier . --write",
"format:check": "prettier . --check"
}
}
Integrasi dengan ESLint
ESLint dan Prettier bisa bertugas secara terpisah:
- ESLint — kualitas kode (bug, best practice).
- Prettier — format (spasi, indentasi).
Untuk menghindari konflik rule, gunakan eslint-config-prettier:
npm install --save-dev eslint-config-prettier
// eslint.config.js
import js from "@eslint/js";
import prettier from "eslint-config-prettier";
export default [
js.configs.recommended,
prettier, // nonaktifkan rule ESLint yang konflik dengan Prettier
// ...
];
Integrasi Editor
Install extension Prettier di VS Code, lalu aktifkan format on save di .vscode/settings.json:
{
"editor.formatOnSave": true,
"editor.defaultFormatter": "esbenp.prettier-vscode"
}
Contoh Setup Proyek Lengkap
Mari gabungkan semua: Vite + ESLint + Prettier.
1. Buat Proyek Vite
npm create vite@latest toko-app -- --template vanilla
cd toko-app
npm install
2. Instal ESLint & Prettier
npm install --save-dev eslint @eslint/js prettier eslint-config-prettier
3. Konfigurasi ESLint (eslint.config.js)
import js from "@eslint/js";
import prettier from "eslint-config-prettier";
export default [
js.configs.recommended,
prettier,
{
languageOptions: {
ecmaVersion: 2022,
sourceType: "module",
globals: {
window: "readonly",
document: "readonly",
console: "readonly"
}
},
rules: {
"no-unused-vars": "warn",
"eqeqeq": "error",
"prefer-const": "error",
"no-var": "error"
}
}
];
4. Konfigurasi Prettier (.prettierrc)
{
"semi": true,
"singleQuote": false,
"tabWidth": 2,
"printWidth": 80,
"trailingComma": "es5"
}
5. Tambahkan Script
{
"scripts": {
"dev": "vite",
"build": "vite build",
"preview": "vite preview",
"lint": "eslint .",
"lint:fix": "eslint . --fix",
"format": "prettier . --write",
"format:check": "prettier . --check"
}
}
6. Jalankan
npm run dev # development
npm run lint # cek kualitas kode
npm run format # format kode
npm run build # build produksi
7. .gitignore
node_modules/
dist/
.env
*.log
.DS_Store
Ringkasan Alat Build
| Alat | Kategori | Kegunaan | Rekomendasi |
|---|---|---|---|
| Vite | Bundler + Dev Server | Bundling, HMR, optimasi | ✅ Proyek baru |
| Webpack | Bundler | Bundling dengan plugin/loader | Proyek lama/enterprise |
| Rollup | Bundler | Bundling library | Library npm |
| esbuild | Bundler/Transpiler | Sangat cepat | Digunakan Vite |
| Babel | Transpiler | Kompatibilitas browser lama, JSX | Dengan Webpack |
| ESLint | Linter | Kualitas kode & bug | ✅ Semua proyek |
| Prettier | Formatter | Konsistensi format | ✅ Semua proyek |
Tips & Best Practice
-
Gunakan Vite untuk proyek baru — lebih cepat dan konfigurasi minimal.
-
Gunakan ESLint + Prettier di semua proyek — kualitas & konsistensi.
-
Aktifkan format on save di editor — kode selalu rapi tanpa manual.
-
Jalankan lint & format di pre-commit hook (via Husky + lint-staged) — mencegah kode jelek masuk repo.
-
Jangan commit
dist/ataunode_modules/— tambahkan ke.gitignore. -
Gunakan environment variables untuk konfigurasi — jangan hardcode.
-
Untuk library, gunakan Rollup atau Vite library mode — bukan Webpack.
-
Tree shaking — gunakan ES Module (
import/export), bukan CommonJS, agar kode yang tidak dipakai bisa dihapus. -
Code splitting — manfaatkan dynamic
import()untuk memuat kode sesuai kebutuhan. -
Source map — aktifkan di development untuk debugging, pertimbangkan mematikannya di produksi (keamanan).
Ringkasan
| Konsep | Poin Penting |
|---|---|
| Bundler | Menggabungkan module menjadi file siap pakai |
| Vite | Bundler modern, cepat, konfigurasi minimal |
| Webpack | Bundler klasik, fleksibel, ekosistem besar |
| Babel | Transpiler untuk kompatibilitas browser |
| esbuild | Transpiler/bundler sangat cepat (Vite) |
| ESLint | Linter — kualitas & bug |
| Prettier | Formatter — konsistensi |
| Tree shaking | Menghapus kode tidak dipakai |
| Code splitting | Memecah bundle agar dimuat sesuai kebutuhan |
| HMR | Hot Module Replacement — update tanpa reload |
Poin penting:
- Vite adalah pilihan default untuk proyek baru — cepat dan minimal konfigurasi.
- Webpack masih relevan untuk proyek lama dan kebutuhan spesifik.
- Babel hanya diperlukan untuk target browser lama; Vite/esbuild sudah cukup untuk modern.
- ESLint + Prettier adalah kombinasi wajib untuk kualitas & konsistensi kode.
- Environment variables di Vite hanya yang berprefix
VITE_— jangan simpan rahasia. - Tree shaking bekerja optimal dengan ES Module.
- Jangan commit
dist/dannode_modules/— gunakan.gitignore.
Pada artikel berikutnya, kita akan membahas Testing JavaScript — unit test dengan Jest/Vitest.