Parameters dan Arguments

Materi sejauh ini memakai istilah parameter dan argument hampir bergantian; saatnya memisahkannya dengan tegas. Parameter adalah variabel penerima yang ditulis pada definisi fungsi, sedangkan argument adalah nilai nyata yang dikirim pemanggil pada saat pemanggilan. Perbedaan keduanya menentukan bagaimana nilai mengalir ke dalam fungsi — apakah fungsi bekerja pada salinan, atau justru memegang variabel asli milik pemanggil. Pada chapter ini kita bedah kedua model pengiriman tersebut beserta perilaku konversi tipe yang menyertainya.

Parameter Menerima, Argument Mengisi #

Bentuk paling ringkas hubungan keduanya terlihat pada fungsi satu parameter berikut:

<?php
function buatNomorPesanan($urutan)
{
    return "Pesanan #" . $urutan;
}

echo buatNomorPesanan(7) . "\n";
echo buatNomorPesanan("12") . "\n";

Output yang Dihasilkan:

Pesanan #7
Pesanan #12

Mari kita bedah contoh di atas:

1. Baris 2: $urutan adalah parameter — tempat kosong yang menunggu diisi setiap kali fungsi dipanggil.
2. Baris 7: angka 7 adalah argument yang mengisi $urutan pada pemanggilan pertama.
3. Baris 8: string "12" juga sah; pada pemanggilan kedua, $urutan berisi string "12", dan operator titik merangkainya apa adanya.

Karena fungsi ini tidak memiliki type declaration, parameter $urutan menerima nilai tipe apa pun, dan PHP menyesuaikan konteksnya: operator titik membutuhkan string, sehingga angka 7 otomatis dirangkai sebagai "7". Perilaku konversi semacam ini kita bahas lebih dalam pada bagian akhir chapter.

Parameter tanpa nilai default bersifat wajib — memanggil buatNomorPesanan() tanpa argument memicu ArgumentCountError, persis seperti yang kita lihat pada chapter Memanggil Fungsi . Cara membuat parameter opsional dengan nilai cadangan kita bahas pada chapter Default Parameters .

Parameter Tanpa Type Declaration Menerima Apa Saja #

Tanpa type declaration, sebuah parameter bisa menerima seluruh jenis nilai PHP. Contoh berikut memeriksa tipe nilai yang masuk memakai fungsi bawaan get_debug_type():

<?php
function inspeksiNilai($nilai)
{
    echo get_debug_type($nilai) . "\n";
}

inspeksiNilai(42);
inspeksiNilai("halo");
inspeksiNilai(3.14);
inspeksiNilai(true);
inspeksiNilai([1, 2, 3]);
inspeksiNilai(null);

Output yang Dihasilkan:

int
string
float
bool
array
null

Fungsi inspeksiNilai() pada baris 2-5 menerima satu parameter tanpa batasan tipe, lalu mencetak jenis nilai yang masuk. Enam pemanggilan pada baris 7-12 mengirim integer, string, float, bool, array, dan null — semuanya diterima tanpa keluhan. Keluwesan seperti ini terasa praktis untuk skrip kecil, tetapi juga memindahkan beban pemeriksaan ke pundak pemanggil: fungsi tidak lagi menjamin bentuk datanya. Ketika kode membesar, type declaration menjadi penjaga yang jauh lebih kuat — kita bedah pada chapter Parameter Types dan chapter Strict Types dalam Fungsi .

Pass by Value: Fungsi Menerima Salinan #

Secara bawaan, PHP mengirim argument berdasarkan nilai (pass by value): fungsi menerima salinan, sehingga perubahan di dalam badan fungsi tidak menyentuh variabel asli milik pemanggil:

<?php
function naikkanHarga($harga)
{
    $harga = $harga + 1000;
    return $harga;
}

$hargaAwal = 5000;
$hargaHasil = naikkanHarga($hargaAwal);

echo "Harga awal: $hargaAwal\n";
echo "Harga hasil: $hargaHasil\n";

Output yang Dihasilkan:

Harga awal: 5000
Harga hasil: 6000

Mari kita telaah alur nilainya:

1. Baris 2-6: fungsi menaikkan nilai parameternya sebesar 1.000, lalu mengembalikan hasilnya.
2. Baris 8: variabel $hargaAwal diberi nilai 5000.
3. Baris 9: pemanggilan menyalin isi $hargaAwal ke parameter $harga; variabel $hargaHasil menampung nilai kembalian.
4. Baris 11-12: keluaran membuktikan $hargaAwal tetap 5000 — penugasan pada baris 3 hanya mengubah salinan di dalam fungsi, sementara hasil perubahan itu keluar lewat return sebagai 6000.

Model salinan ini adalah alasan utama fungsi bertipe “kalkulator” terasa aman: pemanggil selalu tahu variabelnya tidak akan diam-diam diubah oleh fungsi yang dipanggil.

Pass by Reference: Fungsi Mengubah Variabel Pemanggil #

Mengawali parameter dengan tanda & mengubah model pengirimannya menjadi berdasarkan referensi (pass by reference): parameter menjadi nama lain bagi variabel pemanggil, sehingga penugasan di dalam fungsi mengubah variabel asli:

<?php
function naikkanHarga(&$harga)
{
    $harga = $harga + 1000;
}

$harga = 5000;
naikkanHarga($harga);

echo "Harga setelah pemanggilan: $harga\n";

Output yang Dihasilkan:

Harga setelah pemanggilan: 6000

Parameter &$harga kini menunjuk langsung ke variabel $harga milik pemanggil. Baris 3 menaikkan nilai lewat parameter tersebut, dan setelah pemanggilan selesai, $harga di luar sudah menjadi 6000 — tanpa perlu return sama sekali.

Pola ini paling terasa manfaatnya pada fungsi yang harus mengisi lebih dari satu variabel, seperti penukar dua nilai:

<?php
function tukar(&$a, &$b)
{
    $sementara = $a;
    $a = $b;
    $b = $sementara;
}

$x = 1;
$y = 2;

tukar($x, $y);

echo "x = $x, y = $y\n";

Output yang Dihasilkan:

x = 2, y = 1

Fungsi tukar() pada baris 2-7 memakai dua parameter by reference. Setelah pemanggilan tukar($x, $y) pada baris 13, isi kedua variabel bertukar: x = 2, y = 1. Tanpa referensi, versi by value akan menukar dua salinan lalu membuangnya — variabel asli tidak berubah.

Fungsi bawaan array juga banyak memakai model ini — sort() mengurutkan array asli tanpa mengembalikan array baru:

<?php
$nilaiUjian = [80, 95, 70, 88];

sort($nilaiUjian);

echo implode(", ", $nilaiUjian) . "\n";

Output yang Dihasilkan:

70, 80, 88, 95

Perhatikan bahwa sort($nilaiUjian) tidak kita rangkai dengan echo maupun penugasan. Nilai kembaliannya hanyalah true atau false sebagai penanda keberhasilan, sedangkan hasil kerjanya sudah tertanam langsung pada variabel $nilaiUjian — itulah tanda tangan fungsi by reference yang khas.

Konsekuensi langsung dari model referensi: argument by reference harus berupa sesuatu yang bisa ditimpa — yaitu variabel. Nilai harfiah ditolak keras:

<?php
function setNilai(&$target)
{
    $target = 99;
}

setNilai(5);

Output yang Dihasilkan:

Fatal error: Uncaught Error: setNilai(): Argument #1 ($target) could not be passed by reference in /home/z/my-project/php-course/content/php/fungsi/parameters-dan-arguments/.verify_tmp.php:7
Stack trace:
#0 {main}
  thrown in /home/z/my-project/php-course/content/php/fungsi/parameters-dan-arguments/.verify_tmp.php on line 7

Pesan could not be passed by reference muncul karena angka 5 bukanlah tempat penyimpanan yang bisa diubah — menulis 5 = 99 memang tidak bermakna. Nama berkas .verify_tmp.php pada pesan berasal dari alat verifikasi contoh kode buku ini; berkas simpanan Anda sendiri akan tertulis dengan namanya. Kirimkan variabel, atau tulis ulang fungsi agar mengembalikan nilai baru alih-alih mengubah argument.

Konversi Tipe pada Argument Tanpa Type Declaration #

Bersambung dari contoh buatNomorPesanan(): ketika parameter tidak dibatasi tipenya, PHP secara aktif mengonversi nilai agar operasi tetap bisa berjalan — perilaku yang dikenal sebagai type juggling. Pada operator aritmetika, string numerik diubah menjadi angka:

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

echo jumlahkan(5, 3) . "\n";
echo jumlahkan("5", "3") . "\n";
echo jumlahkan(2.5, 1) . "\n";

Output yang Dihasilkan:

8
8
3.5

Mari kita bandingkan ketiga pemanggilannya:

1. Baris 7: dua integer biasa — hasilnya 8.
2. Baris 8: string "5" dan "3" dikonversi menjadi angka terlebih dahulu, lalu dijumlahkan — hasilnya tetap 8.
3. Baris 9: float 2.5 bertemu integer 1 — hasilnya 3.5 dengan aturan operand float.

Keluwesan ini punya batas tegas. String non-numerik tidak bisa dikonversi menjadi angka, dan PHP 8 menolaknya dengan TypeError:

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

echo jumlahkan("lima", 3);

Output yang Dihasilkan:

Fatal error: Uncaught TypeError: Unsupported operand types: string + int in /home/z/my-project/php-course/content/php/fungsi/parameters-dan-arguments/.verify_tmp.php:4
Stack trace:
#0 /home/z/my-project/php-course/content/php/fungsi/parameters-dan-arguments/.verify_tmp.php(7): jumlahkan('lima', 3)
#1 {main}
  thrown in /home/z/my-project/php-course/content/php/fungsi/parameters-dan-arguments/.verify_tmp.php on line 4

Pesan Unsupported operand types: string + int menjelaskan penolakannya secara gamblang: string "lima" tidak punya bentuk angka sehingga operator + tidak bisa bekerja. Koersi string numerik ke angka pada operator seperti ini melekat pada bahasa PHP dan tidak dipengaruhi strict_types; mode ketat tersebut justru mengubah perilaku parameter yang memiliki type declaration — pembahasan lengkapnya menunggu di chapter Strict Types dalam Fungsi .

Ringkasan #

Parameter adalah wadah di definisi, argument adalah isi dari pemanggil, dan PHP mengirimkannya sebagai salinan kecuali parameter diawali &. Parameter tanpa type declaration menerima apa saja dengan konversi otomatis yang berhenti di string non-numerik. Sering kali sebagian argument itu hampir selalu bernilai sama dari pemanggilan ke pemanggilan — di situlah nilai default pada parameter menjadi berguna, topik chapter berikutnya.

Referensi #

• Arguments fungsi di manual PHP
• References — penjelasan bahasa
• Type juggling