Fungsi

Fungsi adalah blok kode yang dapat dipanggil berulang kali. Artikel ini membahas cara membuat fungsi, parameter, return value, scope, anonymous function, closure, dan arrow function 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 PHP 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 PHP: cara mendefinisikan, parameter, return value, scope, anonymous function, closure, dan arrow function.

Asumsi: Anda sudah memahami variabel, tipe data, dan struktur kontrol dari artikel sebelumnya.


Mendefinisikan Fungsi

Function Declaration

Cara paling umum — fungsi dideklarasikan dengan kata kunci function dan nama.

<?php
function sapa($nama) {
    return "Halo, $nama!";
}

echo sapa("Budi"); // "Halo, Budi!"

Ciri:

  • Nama fungsi case-insensitive — sapa() dan SAPA() dianggap sama.
  • Fungsi bisa dipanggil sebelum dideklarasikan (karena hoisting), selama masih dalam file yang sama.
  • Nama fungsi harus unik — tidak bisa mendeklarasikan dua fungsi dengan nama sama.
<?php
echo sapa("Budi"); // "Halo, Budi!" — berhasil

function sapa($nama) {
    return "Halo, $nama!";
}

Nested Function

Fungsi bisa dideklarasikan di dalam fungsi lain. Fungsi dalam baru tersedia setelah fungsi luar dipanggil.

<?php
function luar() {
    function dalam() {
        return "Dari fungsi dalam";
    }
    return "Dari fungsi luar";
}

echo luar();   // "Dari fungsi luar"
echo dalam();  // "Dari fungsi dalam" — baru tersedia setelah luar() dipanggil

Catatan: Nested function jarang dipakai dan bisa membingungkan. Hindari kecuali benar-benar perlu.

Fungsi dengan Type Declaration

PHP mendukung type declaration untuk parameter dan return value (PHP 7+).

<?php
function tambah(int $a, int $b): int {
    return $a + $b;
}

echo tambah(2, 3); // 5

Tipe yang didukung:

  • Scalar: int, float, string, bool
  • Compound: array, object, callable, iterable
  • Khusus: mixed (PHP 8+), void, never (PHP 8.1+)
  • Class/interface: nama class, self, static, parent
  • Union types (PHP 8+): int|string
  • Nullable: ?int (setara int|null)
<?php
function formatHarga(float $harga): string {
    return "Rp" . number_format($harga, 0, ",", ".");
}

function cariUser(int $id): ?array {
    // mengembalikan array atau null
    return $id > 0 ? ["id" => $id, "nama" => "Budi"] : null;
}

function logPesan(string $pesan): void {
    echo "[LOG] $pesan\n";
    // void = tidak mengembalikan nilai
}

Tips: Selalu gunakan type declaration jika memungkinkan — membuat kode lebih aman dan mudah dipahami.


Parameter dan Argumen

Parameter vs Argumen

  • Parameter — variabel yang dideklarasikan di definisi fungsi.
  • Argumen — nilai yang diberikan saat memanggil fungsi.
<?php
function sapa($nama, $umur) {  // $nama, $umur = parameter
    return "Halo $nama, umur $umur";
}

echo sapa("Budi", 25);  // "Budi", 25 = argumen

Parameter Default

Memberikan nilai default jika argumen tidak diberikan.

<?php
function sapa($nama = "Anonim", $sapaan = "Halo") {
    return "$sapaan, $nama!";
}

echo sapa();                    // "Halo, Anonim!"
echo sapa("Budi");              // "Halo, Budi!"
echo sapa("Budi", "Selamat pagi"); // "Selamat pagi, Budi!"

Default parameter bisa menggunakan konstanta atau ekspresi sederhana:

<?php
function buatId(string $prefix = "user", int $timestamp = null) {
    $timestamp = $timestamp ?? time();
    return "{$prefix}_{$timestamp}";
}

Catatan: Parameter dengan default harus berada setelah parameter tanpa default.

<?php
// ❌ Error — parameter tanpa default setelah parameter default
// function salah($a = 1, $b) {}

// ✅ Benar
function benar($a, $b = 1) {}

Type Declaration pada Parameter

<?php
function hitungTotal(array $items, float $pajak = 0.11): float {
    $total = 0;
    foreach ($items as $item) {
        $total += $item["harga"] * $item["jumlah"];
    }
    return $total * (1 + $pajak);
}

$items = [
    ["harga" => 450000, "jumlah" => 2],
    ["harga" => 150000, "jumlah" => 1],
];

echo hitungTotal($items);       // 1165500
echo hitungTotal($items, 0.05); // 1102500

Nullable Parameter

<?php
function sapa(?string $nama): string {
    return $nama !== null ? "Halo, $nama!" : "Halo, Anonim!";
}

echo sapa("Budi");  // "Halo, Budi!"
echo sapa(null);    // "Halo, Anonim!"

Variadic Parameter (...$args)

Menampung semua argumen sisa dalam sebuah array (PHP 5.6+).

<?php
function jumlahkan(...$angka): int {
    return array_sum($angka);
}

echo jumlahkan(1, 2, 3);       // 6
echo jumlahkan(1, 2, 3, 4, 5); // 15
echo jumlahkan();              // 0

Variadic dengan type declaration:

<?php
function rataRata(float ...$angka): float {
    return array_sum($angka) / count($angka);
}

echo rataRata(10, 20, 30); // 20

Variadic harus di akhir:

<?php
function log(string $level, ...$pesan) {
    echo "[$level] " . implode(" ", $pesan) . "\n";
}

log("INFO", "Server", "berjalan", "di port 3000");
// [INFO] Server berjalan di port 3000

Spread operator untuk memanggil fungsi:

<?php
$angka = [1, 2, 3, 4, 5];
echo jumlahkan(...$angka); // 15

Named Arguments — PHP 8+

Memanggil fungsi dengan nama parameter, bukan urutan.

<?php
function buatUser(string $nama, int $umur, string $role = "user") {
    return compact("nama", "umur", "role");
}

// Tanpa named arguments
$user1 = buatUser("Budi", 25, "admin");

// Dengan named arguments — urutan bebas
$user2 = buatUser(
    umur: 25,
    nama: "Budi",
    role: "admin"
);

// Melewati parameter default
$user3 = buatUser(nama: "Budi", umur: 25);

Tips: Named arguments sangat berguna untuk fungsi dengan banyak parameter opsional.

Pass by Value vs Pass by Reference

Secara default, argumen di PHP dikirim by value — perubahan di dalam fungsi tidak memengaruhi variabel asli.

<?php
function tambahSatu($nilai) {
    $nilai++;
}

$x = 5;
tambahSatu($x);
echo $x; // 5 (tidak berubah)

Untuk mengirim by reference, tambahkan & sebelum parameter:

<?php
function tambahSatu(&$nilai) {
    $nilai++;
}

$x = 5;
tambahSatu($x);
echo $x; // 6 (berubah!)

Peringatan: Pass by reference jarang diperlukan dan bisa membingungkan. Gunakan hanya jika fungsi memang perlu mengubah variabel asli. Untuk array besar, pass by reference bisa menghemat memori, tetapi PHP sudah menggunakan copy-on-write.

Destructuring Parameter (PHP 8+)

Parameter bisa di-destructure langsung jika berbentuk array:

<?php
function tampilkanUser(array $user) {
    // Destructuring di dalam fungsi
    ["nama" => $nama, "umur" => $umur] = $user;
    echo "$nama, $umur tahun\n";
}

// PHP 8+ juga mendukung destructuring di parameter
// (melalui array parameter biasa)

Return Value

return — Mengembalikan Nilai

<?php
function tambah(int $a, int $b): int {
    return $a + $b;
}

$hasil = tambah(3, 5);
echo $hasil; // 8

Fungsi Tanpa return

Jika tidak ada return, fungsi mengembalikan null.

<?php
function sapa($nama) {
    echo "Halo, $nama!";
}

$hasil = sapa("Budi");
var_dump($hasil); // NULL

return Menghentikan Eksekusi

Kode setelah return tidak dijalankan.

<?php
function cekUmur(int $umur): string {
    if ($umur < 0) {
        return "Umur tidak valid";
    }
    if ($umur < 18) {
        return "Belum dewasa";
    }
    return "Dewasa";
    echo "Tidak akan pernah dijalankan";
}

Return Type Declaration

<?php
function bagi(float $a, float $b): float {
    if ($b === 0.0) {
        throw new DivisionByZeroError("Pembagi tidak boleh nol");
    }
    return $a / $b;
}

function cariUser(int $id): ?array {
    return $id > 0 ? ["id" => $id] : null;
}

function logPesan(string $pesan): void {
    echo "[LOG] $pesan\n";
}

void vs never (PHP 8.1+):

  • void — fungsi tidak mengembalikan nilai (boleh return; tanpa nilai).
  • never — fungsi tidak pernah kembali normal (selalu throw atau exit).
<?php
function redirect(string $url): never {
    header("Location: $url");
    exit;
}

function lemparError(string $pesan): never {
    throw new RuntimeException($pesan);
}

Mengembalikan Banyak Nilai

PHP tidak mendukung multiple return secara langsung. Gunakan array atau object.

<?php
// Array — ringkas
function minMax(array $angka): array {
    return [min($angka), max($angka)];
}

[$nilaiMin, $nilaiMax] = minMax([5, 2, 9, 1]);
echo "Min: $nilaiMin, Max: $nilaiMax"; // "Min: 1, Max: 9"

// Associative array — lebih jelas
function statistik(array $angka): array {
    return [
        "total" => array_sum($angka),
        "rata" => array_sum($angka) / count($angka),
        "min" => min($angka),
        "max" => max($angka),
    ];
}

$stat = statistik([10, 20, 30, 40]);
echo $stat["total"]; // 100

Early Return

Pola “early return” membuat kode lebih mudah dibaca — hindari nested if yang dalam.

<?php
// ❌ 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";
}

Scope: Lingkup Variabel

Global Scope

Variabel yang dideklarasikan di luar fungsi memiliki global scope — tetapi tidak otomatis tersedia di dalam fungsi.

<?php
$x = 10;

function tampilkan() {
    echo $x; // Warning: Undefined variable $x
}

tampilkan();

Mengakses Global dari Dalam Fungsi

1. Kata kunci global:

<?php
$x = 10;

function tampilkan() {
    global $x;
    echo $x; // 10
}

tampilkan();

2. Array $GLOBALS:

<?php
$x = 10;

function tampilkan() {
    echo $GLOBALS["x"]; // 10
}

tampilkan();

Peringatan: Menggunakan global atau $GLOBALS adalah praktik yang tidak disarankan — membuat kode sulit dilacak dan diuji. Gunakan parameter fungsi atau dependency injection.

Local Scope

Variabel yang dideklarasikan di dalam fungsi hanya bisa diakses di dalam fungsi itu.

<?php
function hitung() {
    $hasil = 42;
    echo $hasil; // 42
}

hitung();
echo $hasil; // Warning: Undefined variable $hasil

Static Variable

Variabel static di dalam fungsi mempertahankan nilainya antar pemanggilan.

<?php
function counter() {
    static $count = 0;
    $count++;
    return $count;
}

echo counter(); // 1
echo counter(); // 2
echo counter(); // 3

Berguna untuk cache sederhana atau counter:

<?php
function getKoneksi() {
    static $koneksi = null;
    if ($koneksi === null) {
        $koneksi = new PDO("mysql:host=localhost;dbname=toko", "root", "");
        echo "Membuat koneksi baru\n";
    }
    return $koneksi;
}

getKoneksi(); // "Membuat koneksi baru"
getKoneksi(); // (tidak mencetak apa pun — koneksi sama)

Scope Constant

Konstanta (const / define) bersifat global — bisa diakses dari mana saja, termasuk di dalam fungsi.

<?php
const APP_NAME = "Toko Online";

function tampilkanNama() {
    echo APP_NAME; // "Toko Online"
}

tampilkanNama();

Anonymous Function dan Closure

Anonymous Function

Fungsi tanpa nama, biasanya disimpan di variabel atau dikirim sebagai argumen.

<?php
$sapa = function($nama) {
    return "Halo, $nama!";
};

echo $sapa("Budi"); // "Halo, Budi!"

// Cek tipe
var_dump($sapa); // object(Closure)

Anonymous function dengan use:

<?php
$pesan = "Halo";

$sapa = function($nama) use ($pesan) {
    return "$pesan, $nama!";
};

echo $sapa("Budi"); // "Halo, Budi!"

Closure

Closure adalah anonymous function yang “mengingat” variabel dari scope tempat ia dibuat, melalui use.

<?php
function buatPengali($faktor) {
    return function($angka) use ($faktor) {
        return $angka * $faktor;
    };
}

$kali2 = buatPengali(2);
$kali10 = buatPengali(10);

echo $kali2(5);  // 10
echo $kali10(5); // 50

use by value vs by reference:

<?php
$counter = 0;

// By value — nilai disalin saat closure dibuat
$fn1 = function() use ($counter) {
    return $counter; // selalu 0
};

// By reference — menggunakan variabel asli
$fn2 = function() use (&$counter) {
    $counter++;
    return $counter;
};

echo $fn1(); // 0
echo $fn2(); // 1
echo $fn2(); // 2
echo $counter; // 2 (berubah!)

Peringatan: use (&$var) memungkinkan closure mengubah variabel luar. Gunakan dengan hati-hati — bisa menyebabkan bug yang sulit dilacak.

Closure sebagai callback:

<?php
$angka = [1, 2, 3, 4, 5];

$kuadrat = array_map(function($n) {
    return $n * $n;
}, $angka);

print_r($kuadrat); // [1, 4, 9, 16, 25]

$genap = array_filter($angka, function($n) {
    return $n % 2 === 0;
});

print_r($genap); // [2, 4]

Arrow Function — PHP 7.4+

Sintaks ringkas untuk closure dengan satu ekspresi. Otomatis menangkap variabel dari scope luar (by value).

<?php
$angka = [1, 2, 3, 4, 5];

// Closure biasa
$kuadrat1 = array_map(function($n) {
    return $n * $n;
}, $angka);

// Arrow function — lebih ringkas
$kuadrat2 = array_map(fn($n) => $n * $n, $angka);

print_r($kuadrat2); // [1, 4, 9, 16, 25]

Arrow function otomatis menangkap variabel luar:

<?php
$faktor = 3;
$kali3 = fn($n) => $n * $faktor;
echo $kali3(5); // 15

Arrow function hanya bisa berisi satu ekspresi:

<?php
// ✅ Satu ekspresi
$tambah = fn($a, $b) => $a + $b;

// ❌ Multi-baris — gunakan closure biasa
// $proses = fn($x) => {
//     $y = $x * 2;
//     return $y + 1;
// };

Perbandingan Closure vs Arrow Function

Aspek Closure function() use() Arrow fn()
Sintaks Verbose Ringkas
Body Multi-baris Satu ekspresi
Capture variabel Manual (use) Otomatis (by value)
Capture by reference ✅ (use (&$x)) ❌
$this binding ✅ ✅
Versi PHP 5.3+ 7.4+

callable Type

Parameter atau return type yang menerima fungsi:

<?php
function jalankan(callable $fn, $nilai) {
    return $fn($nilai);
}

echo jalankan(fn($x) => $x * 2, 5); // 10
echo jalankan("strtoupper", "hello"); // "HELLO"
echo jalankan([new User, "method"], $arg); // method call

Contoh Praktis

1. Fungsi Utility: Format Rupiah

<?php
function formatRupiah(float $angka): string {
    return "Rp" . number_format($angka, 0, ",", ".");
}

echo formatRupiah(1500000); // "Rp1.500.000"

2. Fungsi dengan Validasi dan Early Return

<?php
function hitungDiskon(float $harga, float $persenDiskon): array {
    if ($harga < 0) {
        throw new InvalidArgumentException("Harga harus positif");
    }
    if ($persenDiskon < 0 || $persenDiskon > 100) {
        throw new InvalidArgumentException("Diskon harus antara 0 dan 100");
    }

    $diskon = $harga * ($persenDiskon / 100);

    return [
        "hargaAsli" => $harga,
        "diskon" => $diskon,
        "hargaAkhir" => $harga - $diskon,
    ];
}

$hasil = hitungDiskon(500000, 20);
print_r($hasil);
// [
//   "hargaAsli" => 500000,
//   "diskon" => 100000,
//   "hargaAkhir" => 400000,
// ]

3. Function Factory dengan Closure

<?php
function buatValidator(float $min, float $max): callable {
    return function(float $nilai) use ($min, $max): string {
        if ($nilai < $min) return "Minimal $min";
        if ($nilai > $max) return "Maksimal $max";
        return "Valid";
    };
}

$validasiUmur = buatValidator(17, 100);
echo $validasiUmur(15);  // "Minimal 17"
echo $validasiUmur(25);  // "Valid"
echo $validasiUmur(150); // "Maksimal 100"

$validasiNilai = buatValidator(0, 100);
echo $validasiNilai(85); // "Valid"

4. Komposisi Fungsi

<?php
$tambah = fn($a) => fn($b) => $a + $b;
$kali = fn($a) => fn($b) => $a * $b;

$tambah5 = $tambah(5);
$kali2 = $kali(2);

echo $tambah5(10);  // 15
echo $kali2(10);    // 20
echo $kali2($tambah5(10)); // 30

5. Higher-Order Function

Fungsi yang menerima fungsi lain sebagai argumen (atau mengembalikan fungsi).

<?php
function prosesArray(array $arr, callable $transformasi): array {
    $hasil = [];
    foreach ($arr as $item) {
        $hasil[] = $transformasi($item);
    }
    return $hasil;
}

$angka = [1, 2, 3, 4, 5];
$kuadrat = prosesArray($angka, fn($n) => $n * $n);
print_r($kuadrat); // [1, 4, 9, 16, 25]

6. Memoization dengan Static Variable

<?php
function fibonacci(int $n): int {
    static $cache = [];

    if ($n <= 1) return $n;
    if (isset($cache[$n])) return $cache[$n];

    return $cache[$n] = fibonacci($n - 1) + fibonacci($n - 2);
}

echo fibonacci(40); // cepat berkat cache

Tips dan Best Practice

  1. Gunakan type declaration untuk parameter dan return — kode lebih aman.

  2. Nama fungsi harus deskriptif — hitungTotalBelanja() lebih baik dari ht().

  3. Satu fungsi, satu tugas — hindari fungsi yang melakukan terlalu banyak hal.

  4. Hindari global — gunakan parameter atau dependency injection.

  5. Gunakan early return — hindari nested if yang dalam.

  6. Batasi jumlah parameter — jika lebih dari 4-5, pertimbangkan object atau named arguments.

  7. Gunakan void untuk fungsi yang tidak mengembalikan nilai.

  8. Gunakan arrow function untuk callback pendek — lebih ringkas.

  9. Selalu unset($n) setelah foreach dengan referensi di dalam fungsi.

  10. Dokumentasikan fungsi dengan PHPDoc:

<?php
/**
 * Menghitung total belanja termasuk pajak.
 *
 * @param array $items Daftar item dengan key "harga" dan "jumlah".
 * @param float $pajak Persentase pajak (default 0.11).
 * @return float Total belanja setelah pajak.
 * @throws InvalidArgumentException Jika item tidak valid.
 */
function hitungTotal(array $items, float $pajak = 0.11): float {
    // ...
}
  1. Hindari pass by reference kecuali benar-benar perlu.

  2. Gunakan static variable untuk cache sederhana, tetapi hati-hati dengan testing.


Ringkasan

Konsep Poin Penting
Function declaration Case-insensitive, bisa dipanggil sebelum deklarasi
Type declaration Untuk parameter dan return value
Default parameter Nilai default jika argumen tidak diberikan
Variadic ...$args Mengumpulkan argumen jadi array
Named arguments Memanggil dengan nama parameter (PHP 8+)
Pass by value Default — perubahan tidak memengaruhi variabel asli
Pass by reference &$x Perubahan memengaruhi variabel asli
return Mengembalikan nilai dan menghentikan eksekusi
Early return Hindari nested if yang dalam
Scope Global, local, static
Anonymous function Fungsi tanpa nama, disimpan di variabel
Closure Anonymous function dengan use
Arrow function fn() Closure ringkas (PHP 7.4+)
callable Type untuk parameter/return berupa fungsi

Poin penting:

  • Gunakan type declaration untuk keamanan kode.
  • Hindari global — gunakan parameter atau dependency injection.
  • static variable mempertahankan nilai antar pemanggilan.
  • Closure menggunakan use untuk menangkap variabel luar.
  • Arrow function (fn()) otomatis menangkap variabel luar (by value).
  • use (&$x) menangkap by reference — gunakan dengan hati-hati.
  • Pass by reference (&$param) jarang diperlukan.
  • Gunakan early return untuk kode yang lebih mudah dibaca.
  • Dokumentasikan fungsi dengan PHPDoc.

Pada artikel berikutnya, kita akan membahas Array dan Method-nya — membuat, mengakses, dan memanipulasi array di PHP.

Top