Fungsi
Fungsi adalah blok kode yang dapat dipanggil berulang kali. Artikel ini membahas cara membuat fungsi, parameter, return value, arrow function, scope, closure, dan IIFE dengan contoh praktis.
Pendahuluan
Fungsi adalah blok kode yang dirancang untuk melakukan tugas tertentu dan dapat dipanggil berulang kali. Fungsi adalah fondasi pemrograman — hampir semua kode JavaScript modern terdiri dari fungsi-fungsi yang saling memanggil.
Fungsi memungkinkan kita untuk:
- Menghindari duplikasi — tulis sekali, panggil berkali-kali.
- Memecah masalah kompleks menjadi bagian-bagian kecil.
- Mengabstraksi detail — pengguna fungsi tidak perlu tahu implementasinya.
- Menguji kode secara terpisah.
Artikel ini membahas semua aspek fungsi di JavaScript: cara mendefinisikan, parameter, return value, arrow function, scope, closure, dan IIFE.
Asumsi: Anda sudah memahami variabel, tipe data, dan struktur kontrol dari artikel sebelumnya.
Mendefinisikan Fungsi
Ada beberapa cara mendefinisikan fungsi di JavaScript.
1. Function Declaration
Cara paling klasik. Fungsi dideklarasikan dengan kata kunci function dan nama.
function sapa(nama) {
return `Halo, ${nama}!`;
}
console.log(sapa("Budi")); // "Halo, Budi!"
Ciri: Bisa dipanggil sebelum dideklarasikan (karena hoisting).
console.log(sapa("Budi")); // "Halo, Budi!" — berhasil!
function sapa(nama) {
return `Halo, ${nama}!`;
}
2. Function Expression
Fungsi disimpan dalam variabel. Fungsi bisa anonim atau bernama.
const sapa = function(nama) {
return `Halo, ${nama}!`;
};
console.log(sapa("Budi")); // "Halo, Budi!"
Tidak bisa dipanggil sebelum dideklarasikan (karena const/let berada di TDZ):
console.log(sapa("Budi")); // ReferenceError!
const sapa = function(nama) {
return `Halo, ${nama}!`;
};
Named function expression (berguna untuk debugging — nama muncul di stack trace):
const faktorial = function hitungFaktorial(n) {
return n <= 1 ? 1 : n * hitungFaktorial(n - 1);
};
3. Arrow Function (ES6)
Sintaks ringkas untuk fungsi. Tidak memiliki this sendiri (dibahas di bagian Arrow Function).
const sapa = (nama) => {
return `Halo, ${nama}!`;
};
// Lebih ringkas: implicit return (tanpa kurung kurawal)
const sapa2 = (nama) => `Halo, ${nama}!`;
// Satu parameter: kurung bisa dihilangkan
const kuadrat = x => x * x;
// Tanpa parameter: kurung wajib
const halo = () => "Halo!";
// Mengembalikan object: bungkus dengan kurung
const buatUser = (nama) => ({ nama, aktif: true });
Perbandingan Tiga Cara
| Aspek | Declaration | Expression | Arrow |
|---|---|---|---|
| Hoisting | ✅ Bisa dipanggil sebelum deklarasi | ❌ | ❌ |
this sendiri |
✅ | ✅ | ❌ (warisan) |
arguments object |
✅ | ✅ | ❌ |
Bisa jadi constructor (new) |
✅ | ✅ | ❌ |
| Sintaks | Paling verbose | Verbose | Ringkas |
| Kapan dipakai | Fungsi utama | Callback, variabel | Callback, fungsi pendek |
Rekomendasi: Gunakan function declaration untuk fungsi utama yang kompleks, arrow function untuk callback dan fungsi pendek.
Parameter dan Argumen
Parameter vs Argumen
- Parameter — variabel yang dideklarasikan di definisi fungsi.
- Argumen — nilai yang diberikan saat memanggil fungsi.
function sapa(nama, umur) { // nama, umur = parameter
return `Halo ${nama}, umur ${umur}`;
}
sapa("Budi", 25); // "Budi", 25 = argumen
Parameter Default
Memberikan nilai default jika argumen tidak diberikan (atau undefined).
function sapa(nama = "Anonim") {
return `Halo, ${nama}!`;
}
console.log(sapa()); // "Halo, Anonim!"
console.log(sapa("Budi")); // "Halo, Budi!"
console.log(sapa(undefined)); // "Halo, Anonim!"
console.log(sapa(null)); // "Halo, null!" (null bukan undefined!)
Default parameter bisa menggunakan parameter sebelumnya:
function buatPesanan(produk, jumlah = 1, harga = 0) {
return { produk, jumlah, total: jumlah * harga };
}
Rest Parameter (...args)
Menampung semua argumen sisa dalam sebuah array.
function jumlahkan(...angka) {
return angka.reduce((sum, n) => sum + n, 0);
}
console.log(jumlahkan(1, 2, 3)); // 6
console.log(jumlahkan(1, 2, 3, 4, 5)); // 15
console.log(jumlahkan()); // 0
Rest parameter harus di akhir:
function log(level, ...pesan) {
console.log(`[${level}]`, ...pesan);
}
log("INFO", "Server", "berjalan", "di port 3000");
// [INFO] Server berjalan di port 3000
Perbedaan rest dan spread:
// Rest: mengumpulkan argumen menjadi array
function kumpulkan(...args) {
console.log(args); // array
}
// Spread: menyebarkan array menjadi argumen
const angka = [1, 2, 3];
console.log(Math.max(...angka)); // 3
arguments Object (Function Biasa)
Fungsi biasa (bukan arrow) memiliki object arguments — array-like berisi semua argumen.
function jumlahkan() {
let total = 0;
for (let i = 0; i < arguments.length; i++) {
total += arguments[i];
}
return total;
}
console.log(jumlahkan(1, 2, 3)); // 6
Catatan:
argumentsbukan array sungguhan (tidak punyamap,filter, dll.). Gunakan rest parameter (...args) di kode modern — lebih bersih dan bekerja di arrow function.
Destructuring Parameter
Parameter bisa di-destructure langsung:
// Object destructuring
function tampilkanUser({ nama, umur, kota = "Tidak diketahui" }) {
console.log(`${nama}, ${umur} tahun, ${kota}`);
}
tampilkanUser({ nama: "Budi", umur: 25 }); // "Budi, 25 tahun, Tidak diketahui"
// Array destructuring
function koordinat([x, y]) {
console.log(`X: ${x}, Y: ${y}`);
}
koordinat([10, 20]); // "X: 10, Y: 20"
Return Value
return — Mengembalikan Nilai
function tambah(a, b) {
return a + b;
}
const hasil = tambah(3, 5);
console.log(hasil); // 8
Fungsi Tanpa return
Jika tidak ada return, fungsi mengembalikan undefined.
function sapa(nama) {
console.log(`Halo, ${nama}!`);
}
const hasil = sapa("Budi");
console.log(hasil); // undefined
return Menghentikan Eksekusi
Kode setelah return tidak dijalankan.
function cekUmur(umur) {
if (umur < 0) {
return "Umur tidak valid";
}
if (umur < 18) {
return "Belum dewasa";
}
return "Dewasa";
console.log("Tidak akan pernah dijalankan");
}
Mengembalikan Banyak Nilai
JavaScript tidak mendukung multiple return secara langsung. Gunakan object atau array.
// Object — lebih jelas
function statistik(angka) {
const total = angka.reduce((s, n) => s + n, 0);
const rata = total / angka.length;
const min = Math.min(...angka);
const max = Math.max(...angka);
return { total, rata, min, max };
}
const { total, rata, min, max } = statistik([10, 20, 30, 40]);
console.log(total, rata, min, max); // 100 25 10 40
// Array — ringkas tapi kurang jelas
function minMax(angka) {
return [Math.min(...angka), Math.max(...angka)];
}
const [nilaiMin, nilaiMax] = minMax([5, 2, 9, 1]);
console.log(nilaiMin, nilaiMax); // 1 9
Early Return
Pola “early return” membuat kode lebih mudah dibaca — hindari nested if yang dalam.
// ❌ Nested if yang dalam
function prosesUser(user) {
if (user) {
if (user.aktif) {
if (user.umur >= 18) {
return "OK";
} else {
return "Terlalu muda";
}
} else {
return "Tidak aktif";
}
} else {
return "User tidak ada";
}
}
// ✅ Early return
function prosesUser(user) {
if (!user) return "User tidak ada";
if (!user.aktif) return "Tidak aktif";
if (user.umur < 18) return "Terlalu muda";
return "OK";
}
Arrow Function Secara Detail
Arrow function memiliki perilaku khusus yang membedakannya dari fungsi biasa.
Sintaks Ringkas
// Tanpa parameter
const halo = () => "Halo!";
// Satu parameter (tanpa kurung)
const kuadrat = x => x * x;
// Beberapa parameter
const tambah = (a, b) => a + b;
// Body multi-baris (butuh return eksplisit)
const proses = (x) => {
const hasil = x * 2;
return hasil + 1;
};
// Mengembalikan object (bungkus dengan kurung)
const buatUser = (nama) => ({ nama, aktif: true });
Arrow Function Tidak Memiliki this Sendiri
Ini perbedaan paling penting. Arrow function mewarisi this dari scope sekitarnya (lexical this).
const user = {
nama: "Budi",
// Fungsi biasa: `this` merujuk ke user
sapaBiasa: function() {
console.log(this.nama); // "Budi"
},
// Arrow: `this` bukan user (mewarisi dari luar)
sapaArrow: () => {
console.log(this.nama); // undefined (atau error)
}
};
user.sapaBiasa(); // "Budi"
user.sapaArrow(); // undefined
Kapan this arrow berguna? Saat menggunakan callback di dalam method object:
const timer = {
detik: 0,
mulai() {
// Arrow function mewarisi `this` dari method `mulai`
setInterval(() => {
this.detik++;
console.log(this.detik);
}, 1000);
}
};
timer.mulai();
Jika menggunakan function(), this di dalam setInterval akan merujuk ke window/global, bukan timer.
Arrow Function Tidak Memiliki arguments
const biasa = function() {
console.log(arguments); // { '0': 1, '1': 2 }
};
const arrow = () => {
console.log(arguments); // ReferenceError (atau arguments dari luar)
};
biasa(1, 2);
arrow(1, 2);
Gunakan rest parameter sebagai gantinya:
const arrow = (...args) => {
console.log(args); // [1, 2]
};
Arrow Function Tidak Bisa Jadi Constructor
const Person = (nama) => {
this.nama = nama;
};
const budi = new Person("Budi"); // TypeError: Person is not a constructor
Kapan Menghindari Arrow Function?
- Method object — gunakan fungsi biasa agar
thismerujuk ke object. - Constructor — gunakan
classatau fungsi biasa. - Event handler yang butuh
thiselemen — gunakan fungsi biasa. - Fungsi yang menggunakan
arguments— gunakan rest parameter atau fungsi biasa.
Scope: Lingkup Variabel
Scope menentukan di mana variabel bisa diakses.
Global Scope
Variabel yang dideklarasikan di luar fungsi apa pun.
const globalVar = "Saya global";
function tampilkan() {
console.log(globalVar); // bisa diakses
}
tampilkan();
console.log(globalVar); // bisa diakses
Function Scope
Variabel yang dideklarasikan di dalam fungsi hanya bisa diakses di dalam fungsi itu.
function hitung() {
const hasil = 42;
console.log(hasil); // bisa diakses
}
hitung();
console.log(hasil); // ReferenceError: hasil is not defined
Block Scope
Variabel let dan const yang dideklarasikan di dalam blok {} hanya hidup di blok itu.
if (true) {
let x = 10;
const y = 20;
console.log(x, y); // 10, 20
}
console.log(x); // ReferenceError
console.log(y); // ReferenceError
// var TIDAK block scope
if (true) {
var z = 30;
}
console.log(z); // 30 (bocor!)
Scope Chain
JavaScript mencari variabel dari scope terdalam ke luar.
const global = "global";
function luar() {
const luarVar = "luar";
function dalam() {
const dalamVar = "dalam";
// Bisa akses semua: dalam, luar, global
console.log(dalamVar, luarVar, global);
}
dalam();
}
luar();
// "dalam luar global"
Jika variabel tidak ditemukan di scope mana pun, akan menghasilkan ReferenceError.
Shadowing
Variabel di scope dalam bisa “menutupi” variabel di scope luar.
const nama = "Global";
function tampilkan() {
const nama = "Lokal"; // shadowing
console.log(nama); // "Lokal"
}
tampilkan();
console.log(nama); // "Global"
Tips: Hindari shadowing yang tidak perlu — bisa membingungkan. Gunakan nama yang berbeda untuk variabel di scope berbeda.
Variabel Global Implisit (Hindari!)
Jika Anda mengassign variabel tanpa deklarasi, JavaScript membuat variabel global secara implisit:
function test() {
globalImplisit = "Saya global!"; // tanpa let/const/var
}
test();
console.log(globalImplisit); // "Saya global!" (!!)
⚠️ Peringatan: Ini adalah sumber bug. Selalu deklarasikan variabel dengan
letatauconst. Gunakan"use strict"untuk mencegah perilaku ini.
Closure
Closure adalah fungsi yang “mengingat” variabel dari scope tempat ia dibuat, bahkan setelah scope itu selesai.
Contoh Dasar
function buatCounter() {
let count = 0; // variabel "private"
return function() {
count++;
return count;
};
}
const counter = buatCounter();
console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3
// count tidak bisa diakses dari luar
console.log(count); // ReferenceError
Fungsi yang dikembalikan “mengingat” variabel count — inilah closure.
Closure untuk Data Private
Closure memungkinkan enkapsulasi — variabel hanya bisa diakses melalui method yang disediakan.
function buatRekening(saldoAwal) {
let saldo = saldoAwal; // private
return {
deposit(jumlah) {
if (jumlah <= 0) throw new Error("Jumlah harus positif");
saldo += jumlah;
return saldo;
},
tarik(jumlah) {
if (jumlah > saldo) throw new Error("Saldo tidak cukup");
saldo -= jumlah;
return saldo;
},
getSaldo() {
return saldo;
}
};
}
const rekening = buatRekening(100000);
console.log(rekening.getSaldo()); // 100000
rekening.deposit(50000);
console.log(rekening.getSaldo()); // 150000
rekening.tarik(30000);
console.log(rekening.getSaldo()); // 120000
// saldo tidak bisa diakses langsung
console.log(rekening.saldo); // undefined
Closure dalam Loop (Masalah Klasik)
// ❌ Masalah dengan var
for (var i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 100);
}
// Output: 3, 3, 3 (bukan 0, 1, 2!)
// ✅ Solusi 1: gunakan let (block scope)
for (let i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 100);
}
// Output: 0, 1, 2
// ✅ Solusi 2: IIFE (untuk var)
for (var i = 0; i < 3; i++) {
(function(j) {
setTimeout(() => console.log(j), 100);
})(i);
}
// Output: 0, 1, 2
Kegunaan Closure
- Data private — variabel tidak bisa diakses dari luar.
- Function factory — membuat fungsi dengan konfigurasi berbeda.
- Memoization — cache hasil perhitungan.
- Event handler — mengingat state saat event didaftarkan.
Contoh function factory:
function buatPengali(faktor) {
return (angka) => angka * faktor;
}
const kali2 = buatPengali(2);
const kali10 = buatPengali(10);
console.log(kali2(5)); // 10
console.log(kali10(5)); // 50
Contoh memoization:
function memoize(fn) {
const cache = new Map();
return function(...args) {
const key = JSON.stringify(args);
if (cache.has(key)) {
return cache.get(key);
}
const hasil = fn.apply(this, args);
cache.set(key, hasil);
return hasil;
};
}
const fibonacci = memoize(function(n) {
if (n <= 1) return n;
return fibonacci(n - 1) + fibonacci(n - 2);
});
console.log(fibonacci(40)); // cepat berkat cache
IIFE — Immediately Invoked Function Expression
IIFE adalah fungsi yang langsung dipanggil saat didefinisikan.
Sintaks
(function() {
console.log("Langsung dijalankan!");
})();
// Atau dengan arrow
(() => {
console.log("Arrow IIFE!");
})();
Mengapa dibungkus kurung? Agar JavaScript menganggapnya sebagai ekspresi, bukan deklarasi fungsi. Tanpa kurung, akan error karena deklarasi fungsi butuh nama.
Kegunaan IIFE
1. Menghindari variabel global:
(function() {
const privateVar = "Tidak bocor ke global";
console.log(privateVar);
})();
console.log(typeof privateVar); // "undefined"
2. Module pattern (sebelum ES6 module):
const Counter = (function() {
let count = 0;
return {
increment: () => ++count,
decrement: () => --count,
getCount: () => count
};
})();
console.log(Counter.increment()); // 1
console.log(Counter.increment()); // 2
console.log(Counter.getCount()); // 2
3. Inisialisasi sekali:
(async function() {
const data = await fetch("/api/data");
console.log(await data.json());
})();
Catatan: Di kode modern dengan module (
import/export), IIFE jarang diperlukan karena module sudah memiliki scope sendiri.
Hoisting Fungsi
Function declaration diangkat ke atas scope — bisa dipanggil sebelum dideklarasikan.
console.log(sapa("Budi")); // "Halo, Budi!" — berhasil
function sapa(nama) {
return `Halo, ${nama}!`;
}
Function expression dan arrow function tidak di-hoist (berada di TDZ jika menggunakan let/const).
console.log(sapa("Budi")); // ReferenceError
const sapa = (nama) => `Halo, ${nama}!`;
Contoh Praktis
1. Fungsi Utility: Format Rupiah
function formatRupiah(angka) {
return new Intl.NumberFormat("id-ID", {
style: "currency",
currency: "IDR",
minimumFractionDigits: 0
}).format(angka);
}
console.log(formatRupiah(1500000)); // "Rp 1.500.000"
2. Fungsi dengan Validasi dan Early Return
function hitungDiskon(harga, persenDiskon) {
// Validasi
if (typeof harga !== "number" || harga < 0) {
throw new Error("Harga harus angka positif");
}
if (persenDiskon < 0 || persenDiskon > 100) {
throw new Error("Diskon harus antara 0 dan 100");
}
const diskon = harga * (persenDiskon / 100);
return {
hargaAsli: harga,
diskon,
hargaAkhir: harga - diskon
};
}
const hasil = hitungDiskon(500000, 20);
console.log(hasil);
// { hargaAsli: 500000, diskon: 100000, hargaAkhir: 400000 }
3. Function Factory dengan Closure
function buatValidator(min, max) {
return function(nilai) {
if (nilai < min) return `Minimal ${min}`;
if (nilai > max) return `Maksimal ${max}`;
return "Valid";
};
}
const validasiUmur = buatValidator(17, 100);
console.log(validasiUmur(15)); // "Minimal 17"
console.log(validasiUmur(25)); // "Valid"
console.log(validasiUmur(150)); // "Maksimal 100"
const validasiNilai = buatValidator(0, 100);
console.log(validasiNilai(85)); // "Valid"
4. Komposisi Fungsi
const tambah = (a) => (b) => a + b;
const kali = (a) => (b) => a * b;
const tambah5 = tambah(5);
const kali2 = kali(2);
console.log(tambah5(10)); // 15
console.log(kali2(10)); // 20
console.log(kali2(tambah5(10))); // 30
5. Callback dan Higher-Order Function
Fungsi yang menerima fungsi lain sebagai argumen (atau mengembalikan fungsi) disebut higher-order function.
function prosesArray(arr, transformasi) {
const hasil = [];
for (const item of arr) {
hasil.push(transformasi(item));
}
return hasil;
}
const angka = [1, 2, 3, 4, 5];
const kuadrat = prosesArray(angka, (n) => n * n);
console.log(kuadrat); // [1, 4, 9, 16, 25]
const genap = prosesArray(angka, (n) => n % 2 === 0);
console.log(genap); // [false, true, false, true, false]
Ringkasan
| Konsep | Poin Penting |
|---|---|
| Function declaration | Di-hoist, bisa dipanggil sebelum deklarasi |
| Function expression | Tidak di-hoist, disimpan di variabel |
| Arrow function | Ringkas, tidak punya this/arguments sendiri |
| Parameter default | Nilai default jika argumen undefined |
| Rest parameter | ...args — mengumpulkan argumen jadi array |
| Destructuring parameter | Langsung ekstrak properti/elemen |
return |
Mengembalikan nilai & menghentikan eksekusi |
| Early return | Hindari nested if yang dalam |
| Scope | Global, function, block (let/const) |
| Closure | Fungsi “mengingat” variabel dari scope asalnya |
| IIFE | Fungsi yang langsung dipanggil |
| Higher-order function | Menerima/mengembalikan fungsi |
Poin penting:
- Gunakan function declaration untuk fungsi utama, arrow function untuk callback.
- Arrow function tidak punya
thissendiri — hindari sebagai method object. - Gunakan rest parameter (
...args) daripadaarguments. - Closure memungkinkan data private dan function factory.
- Early return membuat kode lebih mudah dibaca.
- Selalu deklarasikan variabel dengan
let/const— hindari variabel global implisit. - Pahami scope chain dan shadowing.
Pada artikel berikutnya, kita akan membahas Array & Method-nya — map, filter, reduce, forEach, dan lainnya.