BAB 6: FUNCTION

6-2: Parameter dan Return

Objectives

Default parameters
Named arguments (PHP 8+)
Variadic parameters (...$args)
Return types
Parameter by reference
Strict types

Review: Parameter vs Argument

Sebelum melangkah lebih jauh, ingat kembali dua istilah ini:

Istilah	Arti	Contoh
Parameter	Variabel di definisi function	`$name` di `function greet($name)`
Argument	Nilai yang dikirim saat memanggil	`"Andi"` di `greet("Andi")`

Di materi ini kita akan membahas cara membuat parameter lebih fleksibel: dengan nilai default, named arguments, jumlah tak terbatas, dan type declarations.

Default Parameters

php
<?php

function greet($name, $greeting = "Hello") {
    echo "$greeting, $name!\n";
}

greet("Andi");              // Hello, Andi!
greet("Budi", "Hi");        // Hi, Budi!
greet("Citra", "Good morning");  // Good morning, Citra!

?>

Parameter dengan nilai default boleh tidak dikirim saat memanggil — PHP akan memakai nilai defaultnya. Ini sangat berguna untuk membuat function yang fleksibel namun tetap mudah dipanggil.

⚠️Perhatian

Parameter dengan default harus diletakkan setelah parameter tanpa default. PHP tidak mengizinkan parameter wajib berada setelah parameter opsional:

php
<?php

// ❌ Error! Parameter wajib setelah parameter default
// function greet($greeting = "Hello", $name) { ... }

// ✅ Benar: default di belakang
function greet($name, $greeting = "Hello") { ... }

?>

Default Parameter dengan Array

php
<?php

function createOrder($items, $discount = 0, $note = "") {
    $total = array_sum($items);
    $total -= $total * $discount / 100;

    $result = "Order: " . count($items) . " item, total Rp " . number_format($total);
    if ($note !== "") {
        $result .= " (catatan: $note)";
    }
    return $result;
}

echo createOrder([10000, 20000]) . "\n";
// Output: Order: 2 item, total Rp 30.000

echo createOrder([10000, 20000], 10) . "\n";
// Output: Order: 2 item, total Rp 27.000

echo createOrder([10000, 20000], 10, "Bungkus kado") . "\n";
// Output: Order: 2 item, total Rp 27.000 (catatan: Bungkus kado)

?>

Named Arguments (PHP 8+)

php
<?php

function createUser($name, $email, $age, $city) {
    echo "$name, $email, $age, $city\n";
}

// Traditional - harus urut
createUser("Andi", "andi@example.com", 25, "Jakarta");

// Named arguments - bisa urut sembarang
createUser(
    name: "Andi",
    city: "Jakarta",
    email: "andi@example.com",
    age: 25
);

?>

Sebelum PHP 8, urutan argument harus persis sama dengan urutan parameter — satu saja tertukar, hasilnya salah (misal umur tertukar dengan kota). Named arguments menyelesaikan masalah ini: kamu menyebut nama parameternya, jadi urutan bebas.

Named Arguments + Default Parameters

Kombinasi keduanya sangat powerful — kamu hanya perlu mengirim argument yang ingin diubah:

php
<?php

function setupProfile($name, $age = 0, $city = "Jakarta", $bio = "") {
    echo "$name | $age tahun | $city | $bio\n";
}

// Hanya ubah $bio, biarkan $city memakai default
setupProfile(name: "Andi", age: 25, bio: "Belajar PHP");

// Output: Andi | 25 tahun | Jakarta | Belajar PHP

?>

Dengan named arguments, kamu tidak perlu mengirim null atau nilai kosong untuk parameter di tengah hanya demi mencapai parameter di belakang.

💡Tip

Named arguments membuat kode lebih jelas — pembaca langsung tahu nilai itu untuk parameter apa. Gunakan terutama untuk function dengan banyak parameter (3+).

Variadic Parameters

php
<?php

// Collect semua argument ke array
function sum(...$numbers) {
    $total = 0;
    foreach ($numbers as $num) {
        $total += $num;
    }
    return $total;
}

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

// Dengan array unpacking
$numbers = [1, 2, 3];
echo sum(...$numbers);   // 6

?>

Tanda ... sebelum nama parameter mengumpulkan semua argument yang dikirim menjadi satu array. Function bisa menerima jumlah argument berapa pun — dari 0 sampai tak terbatas.

Variadic dengan Parameter Lain

php
<?php

function logMessage($level, ...$messages) {
    $line = "[" . strtoupper($level) . "] " . implode(" ", $messages);
    echo $line . "\n";
}

logMessage("info", "User login");
// Output: [INFO] User login

logMessage("warning", "Disk hampir penuh", "sisa 500MB", "segera bersihkan");
// Output: [WARNING] Disk hampir penuh sisa 500MB segera bersihkan

?>

Variadic harus menjadi parameter terakhir — setelah ...$args tidak boleh ada parameter lain.

Return Types

php
<?php

// Return type declaration
function add(int $a, int $b): int {
    return $a + $b;
}

echo add(5, 3);  // 8

// Float return
function divide(float $a, float $b): float {
    return $a / $b;
}

// Nullable return
function findUser(int $id): ?string {
    if ($id === 1) return "Andi";
    return null;
}

// Union types (PHP 8+)
function process(int|float $value): int|float {
    return $value * 2;
}

?>

Type declarations membuat function lebih aman: PHP akan memeriksa tipe argument dan nilai return. Jika tidak cocok, PHP melempar TypeError (di mode strict).

Tabel Type Declarations

Type	Contoh	Keterangan
`int`	`function add(int $a): int`	Bilangan bulat
`float`	`function div(float $a): float`	Bilangan desimal
`string`	`function greet(string $n): string`	Teks
`bool`	`function isEven(int $n): bool`	true/false
`array`	`function sum(array $n): int`	Array
`?string`	`function find(int $id): ?string`	string atau null
`int\|float`	`function p(int\|float $v)`	Union: salah satu tipe
`void`	`function log(string $m): void`	Tanpa return value
`mixed`	`function x(mixed $v)`	Tipe apa pun (PHP 8+)

Passing by Reference

Secara default, PHP mengirim argument by value (salinan). Dengan & di depan parameter, function bisa mengubah variabel asli pemanggil:

php
<?php

// By value: salinan, tidak mengubah variabel asli
function addTax($price) {
    $price *= 1.11;
}

$harga = 100000;
addTax($harga);
echo $harga . "\n";  // 100000 (tidak berubah!)

// By reference: mengubah variabel asli
function addTaxRef(&$price) {
    $price *= 1.11;
}

$harga = 100000;
addTaxRef($harga);
echo $harga . "\n";  // 111000 (berubah!)

?>

Aspek	By Value	By Reference
Syntax	`$harga` → `$price` (salinan)	`$harga` → `&$price` (menunjuk sama)
Efek perubahan	Perubahan `$price` tidak memengaruhi `$harga`	Perubahan `$price` ikut mengubah `$harga`

⚠️Perhatian

Hati-hati dengan parameter by reference: function bisa mengubah data di luar dirinya, yang membuat kode sulit diprediksi. Gunakan hanya jika benar-benar perlu (misal function sorting yang mengubah array asli). Untuk kasus biasa, lebih baik return hasilnya.

Strict Types

Secara default, PHP melakukan "type juggling" — misalnya string "5" diterima sebagai int 5:

php
<?php

function add(int $a, int $b): int {
    return $a + $b;
}

// Tanpa strict types: PHP mengubah "5" jadi 5
echo add("5", 3) . "\n";  // 8

?>

Jika kamu ingin PHP menolak tipe yang salah dengan tegas, tambahkan deklarasi di baris pertama file:

php
<?php

declare(strict_types=1);

function add(int $a, int $b): int {
    return $a + $b;
}

// ⚠️ Dengan strict types, kode ini melempar TypeError:
// echo add("5", 3);

echo add(5, 3);  // 8

?>

💡Tip

declare(strict_types=1) harus menjadi statement pertama di file (boleh setelah <?php). Ini membuat kode lebih disiplin — bug tipe data tertangkap lebih awal.

Common Mistakes

Default Parameter di Posisi Salah

php
<?php

// ❌ Error: parameter tanpa default setelah parameter ber-default
// function config($host = "localhost", $port) { ... }

// ✅ Benar
function config($port, $host = "localhost") { ... }

?>

Mengirim Argument Kurang

php
<?php

function greeting($name, $greeting) {
    return "$greeting, $name";
}

// ❌ Argument kurang — error di PHP 8 (sebelumnya warning)
// echo greeting("Andi");  // ArgumentCountError

// ✅ Kirim semua argument
echo greeting("Andi", "Halo");  // Halo, Andi

?>

⚠️Perhatian

Di PHP 8, memanggil function tanpa argument wajib melempar ArgumentCountError (di PHP versi lama hanya warning). Ini perubahan perilaku yang bagus — error lebih cepat terdeteksi.

Tipe Return Tidak Sesuai

php
<?php

// ❌ Error: return type tidak sesuai
// function getName(): string {
//     return 123;  // TypeError
// }

?>

Pro Tips

Default parameter untuk nilai yang sering sama (misal $currency = "IDR").
Named arguments untuk function dengan banyak parameter — lebih jelas dan urutannya bebas.
Variadic ...$args untuk function yang menerima jumlah data tidak tentu.
Type declarations di semua function yang kamu tulis — mencegah bug tipe data.
Hindari by reference kecuali diperlukan; prefer return value.

Exercise

Buat function dengan 3 default parameters
Gunakan named arguments untuk call function
Buat function sumAll() yang menerima unlimited numbers
Buat function formatNama($depan, $tengah = "", $belakang = "") yang menggabungkan nama, lalu panggil dengan named arguments
Buat function rataRata(...$nilai): float yang menghitung rata-rata nilai ujian
Buat function incrementByRef(&$num) dan jelaskan bedanya dengan versi by value

Summary

Poin	Penjelasan
Default parameters	Nilai dipakai jika argument tidak dikirim
Urutan parameter	Default harus setelah parameter wajib
Named arguments	Panggil dengan `nama: nilai` (PHP 8+)
Variadic	`...$args` mengumpulkan semua argument ke array
Return types	`: int`, `: string`, `: ?string`, `: void`, dsb.
By reference	`&$param` mengubah variabel asli pemanggil
Strict types	`declare(strict_types=1)` menolak tipe salah
PHP 8 behavior	Argument kurang = `ArgumentCountError`

Klik tombol ini setelah menyelesaikan materi

📝

Quiz Bab 6

Uji pemahamanmu tentang Function

▶️ Mulai Quiz