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: arguments bukan array sungguhan (tidak punya map, 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 this merujuk ke object.
  • Constructor — gunakan class atau fungsi biasa.
  • Event handler yang butuh this elemen — 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 let atau const. 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 this sendiri — hindari sebagai method object.
  • Gunakan rest parameter (...args) daripada arguments.
  • 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.

Top