Memanggil Fungsi

Mendefinisikan fungsi baru setengah pekerjaan; separuh lainnya adalah memanggilnya dengan benar. Pemanggilan (function call) adalah titik tempat nilai mengalir dari kode pemanggil ke badan fungsi, lalu hasilnya mengalir kembali. Pada chapter ini kita bedah mekanisme pemanggilan: bentuk sintaksnya, urutan evaluasi argumen, akibat jumlah argumen yang tidak sesuai, serta beberapa gaya pemanggilan khusus — dari pola lama berbasis string sampai syntax first-class callable yang modern.

Sintaks Dasar Pemanggilan #

Memanggil fungsi cukup dilakukan dengan menuliskan namanya diikuti tanda kurung. Nilai yang dikirim ditempatkan di dalam tanda kurung sebagai argument, dipisahkan koma:

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

echo sapa("Budi") . "\n";
echo sapa("Siti") . "\n";

Output yang Dihasilkan:

Halo, Budi!
Halo, Siti!

Mari kita telaah contoh di atas:

1. Baris 2-5: definisi fungsi sapa() dengan satu parameter $nama — diletakkan lebih dulu agar contoh bisa dijalankan sendirian.
2. Baris 7: pemanggilan sapa("Budi") menjalankan badan fungsi dengan $nama berisi "Budi"; nilai kembaliannya dirangkai dengan "\n" lalu dicetak.
3. Baris 8: pemanggilan kedua dengan argument berbeda menghasilkan keluaran berbeda dari definisi yang sama.

Pemanggilan fungsi adalah ekspresi: pemanggilan menghasilkan nilai, sehingga boleh berada di mana pun ekspresi diperbolehkan — di sisi kanan penugasan, di dalam rangkaian operator titik, atau sebagai argument bagi fungsi lain.

Argumen Dievaluasi dari Kiri ke Kanan #

Sebelum badan fungsi dijalankan, PHP mengevaluasi setiap argument hingga menjadi satu nilai. Urutan evaluasinya kiri ke kanan, dan contoh berikut membuktikannya lewat efek samping echo di dalam dua fungsi pembantu:

<?php
function evaluasiArgumenPertama()
{
    echo "(argumen pertama dievaluasi)\n";
    return 10;
}

function evaluasiArgumenKedua()
{
    echo "(argumen kedua dievaluasi)\n";
    return 20;
}

function jumlahkan($a, $b)
{
    return $a + $b;
}

echo jumlahkan(evaluasiArgumenPertama(), evaluasiArgumenKedua()) . "\n";

Output yang Dihasilkan:

(argumen pertama dievaluasi)
(argumen kedua dievaluasi)
30

Pada baris 19, kedua argument kita adalah pemanggilan fungsi lain. Hasil eksekusinya memperlihatkan urutan kerja PHP: pesan (argumen pertama dievaluasi) tercetak lebih dulu, disusul (argumen kedua dievaluasi), dan hanya setelah kedua nilai siap — 10 dan 20 — badan jumlahkan() berjalan dan mencetak 30. Jika PHP mengevaluasi argument kedua lebih dulu, urutan dua baris pertama keluaran akan terbalik. Perilaku ini penting diingat ketika argument kita memanggil fungsi lain yang memiliki efek samping.

Jumlah Argumen yang Tidak Cocok #

Parameter tanpa nilai default bersifat wajib: pemanggil harus mengirim nilai untuk setiap posinya. Panggilan dengan argument kurang membuat PHP melempar ArgumentCountError; bila tidak ditangkap, error tersebut menghentikan program:

<?php
function hitungLuas($panjang, $lebar)
{
    return $panjang * $lebar;
}

echo hitungLuas(10);

Output yang Dihasilkan:

Fatal error: Uncaught ArgumentCountError: Too few arguments to function hitungLuas(), 1 passed in /home/z/my-project/php-course/content/php/fungsi/memanggil-fungsi/.verify_tmp.php on line 7 and exactly 2 expected in /home/z/my-project/php-course/content/php/fungsi/memanggil-fungsi/.verify_tmp.php:2
Stack trace:
#0 /home/z/my-project/php-course/content/php/fungsi/memanggil-fungsi/.verify_tmp.php(7): hitungLuas(10)
#1 {main}
  thrown in /home/z/my-project/php-course/content/php/fungsi/memanggil-fungsi/.verify_tmp.php on line 2

Pesan error menjelaskan dua hal: fungsi hitungLuas() menuntut tepat 2 argument, sedangkan pemanggilan pada baris 7 hanya mengirim 1. Nama berkas .verify_tmp.php pada pesan adalah berkas sementara milik alat verifikasi contoh kode buku ini; pada berkas Anda sendiri, nama dan lokasi berkas Anda yang akan tampil.

ArgumentCountError berasal dari kelas Error, sehingga tetap bisa ditangkap dengan try-catch bila kita ingin menanganinya dengan anggun:

<?php
function hitungLuas($panjang, $lebar)
{
    return $panjang * $lebar;
}

try {
    echo hitungLuas(10);
} catch (ArgumentCountError $e) {
    echo "Panggilan ditolak: " . $e->getMessage() . "\n";
}

Output yang Dihasilkan:

Panggilan ditolak: Too few arguments to function hitungLuas(), 1 passed in /home/z/my-project/php-course/content/php/fungsi/memanggil-fungsi/.verify_tmp.php on line 8 and exactly 2 expected

Pada contoh ini pemanggilan yang gagal tidak menghentikan program. Alur eksekusi melompat ke blok catch, mencetak pesan errornya, lalu program berlanjut seolah tidak terjadi apa-apa. Strategi penanganan error selengkapnya kita bahas pada Section Error Handling .

Kelebihan argument justru ditoleransi untuk fungsi buatan sendiri:

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

echo sapa("Budi", "argumen", "berlebih") . "\n";

Output yang Dihasilkan:

Halo, Budi!

Fungsi sapa() hanya punya satu parameter, tetapi pemanggilan dengan tiga argument tetap berjalan; dua argument terakhir sekadar diabaikan. Nilai-nilai berlebih itu sebenarnya masih bisa diakses dari dalam fungsi lewat mekanisme variadic yang kita bahas pada chapter Variadic Functions .

Memanggil Lewat Nama String #

PHP dapat memanggil fungsi berdasarkan namanya dalam bentuk string — pola yang sering dijumpai pada kode era PHP 5 dan framework lama. Ada dua bentuk klasiknya:

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

echo call_user_func('sapa', 'Budi') . "\n";

$panggil = 'sapa';
echo $panggil('Siti') . "\n";

Output yang Dihasilkan:

Halo, Budi!
Halo, Siti!

Baris 7 memakai call_user_func(): argument pertamanya adalah nama fungsi dalam bentuk string, argument sisanya diteruskan ke fungsi tersebut. Baris 9-10 memakai variable function: ketika sebuah variabel berisi string nama fungsi yang valid, PHP menganggap $panggil('Siti') sebagai pemanggilan sapa('Siti'). Kedua pola ini tetap sah di PHP 8, tetapi keduanya rapuh terhadap salah ketik nama — kesalahan baru terdeteksi saat pemanggilan benar-benar berjalan.

Gaya Modern dengan First-Class Callable #

Sejak PHP 8.1 tersedia cara yang lebih aman: syntax first-class callable. Menulis sapa(...) — nama fungsi diikuti tiga titik — menghasilkan sebuah closure yang merujuk fungsi tersebut, siap dipanggil kapan pun:

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

$fungsiSapa = sapa(...);

echo $fungsiSapa("Siti") . "\n";

Output yang Dihasilkan:

Halo, Siti!

Variabel $fungsiSapa kini berisi callable; pemanggilan $fungsiSapa("Siti") pada baris 9 menjalankan sapa() persis seperti pemanggilan langsung. Berbeda dari pola string, kesalahan nama fungsi terdeteksi jauh lebih awal karena PHP memvalidasi nama saat sapa(...) dievaluasi. Kemampuan membawa fungsi sebagai nilai ini kita bedah tuntas pada chapter First-Class Callables .

Menyebarkan Array sebagai Argument #

Operator spread (...) juga bisa dipakai saat memanggil: sebuah array dibongkar menjadi argument satu per satu sesuai urutannya:

<?php
function jumlahkanTiga($a, $b, $c)
{
    return $a + $b + $c;
}

$angka = [2, 4, 6];
echo jumlahkanTiga(...$angka) . "\n";

Output yang Dihasilkan:

12

Pemanggilan jumlahkanTiga(...$angka) pada baris 9 setara dengan jumlahkanTiga(2, 4, 6): elemen pertama array mengisi parameter pertama, elemen kedua mengisi parameter kedua, dan seterusnya. Pola ini paling berguna ketika jumlah nilai baru diketahui saat program berjalan — kita dalami bersama fungsi variadic pada chapter Variadic Functions .

Fungsi yang Memanggil Dirinya Sendiri #

Sebuah fungsi juga boleh memanggil dirinya sendiri — teknik bernama recursion. Contoh klasiknya perhitungan faktorial, yang bisa ditulis ringkas dalam satu baris:

<?php
function faktorial($n)
{
    return $n <= 1 ? 1 : $n * faktorial($n - 1);
}

echo faktorial(5) . "\n";
echo faktorial(10) . "\n";

Output yang Dihasilkan:

120
3628800

Selama $n masih lebih dari 1, fungsi memanggil faktorial($n - 1) dan mengalikan hasilnya dengan $n. Rantai pemanggilan itu berhenti saat kondisi $n <= 1 terpenuhi dan fungsi mengembalikan 1 — saat itulah seluruh perkalian yang menumpuk diselesaikan berlapis-lapis dari dalam ke luar. Recursion membutuhkan satu chapter penuh agar aman dipakai — lengkap dengan kondisi berhenti dan risiko stack overflow — kita kunjungi pada chapter Recursion .

Ringkasan #

Pemanggilan fungsi mengalirkan nilai masuk lewat argument — dievaluasi kiri ke kanan sebelum badan fungsi berjalan — dan mengalirkan hasil keluar lewat nilai kembalian. Jumlah argument yang salah dibalas ArgumentCountError yang bisa ditangkap, dan PHP menyediakan berbagai gaya pemanggilan untuk kebutuhan berbeda. Pertanyaan berikutnya menyelam ke dalam: apa yang sebenarnya terjadi pada nilai yang kita kirim — apakah fungsi menerima salinannya, atau justru memegang variabel aslinya? Chapter Parameters dan Arguments menjawabnya.

Referensi #

• User-defined functions di manual PHP
• call_user_func()
• Arguments fungsi di manual PHP