Fungsi PHP: Definisi, Return, Parameter, dan Tipe

Fungsi PHP didefinisikan dengan kata kunci function, sebuah nama, daftar parameter, dan body; return mengirim nilai kembali ke pemanggil. function add(int $a, int $b): int { return $a + $b; } mendefinisikannya, dan add(2, 3) memanggilnya serta mengembalikan 5.

<?php
function greet(string $name): string
{
    return "Hello, $name";
}

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

echo greet('Ada'), "\n";
echo add(2, 3), "\n";
echo add(add(1, 2), 10), "\n";

string dan int sebelum parameter adalah deklarasi tipe, dan : string setelah kurung adalah tipe return. Keduanya opsional, tetapi membantu menangkap kesalahan lebih awal dan mendokumentasikan apa yang diharapkan fungsi.

Nilai return dan mengembalikan beberapa nilai

return langsung mengakhiri fungsi. Fungsi tanpa return, atau dengan return; saja, mengembalikan null; deklarasikan : void jika fungsi itu dipanggil hanya untuk efeknya. Sebuah fungsi mengembalikan satu nilai, tetapi nilai itu bisa berupa array, yang kamu destructure di sisi pemanggil:

<?php
function grade(int $score): string
{
    if ($score >= 90) {
        return 'A';
    }
    return $score >= 75 ? 'B' : 'C';   // reached only below 90
}

function stats(array $numbers): array
{
    return [
        'min' => min($numbers),
        'max' => max($numbers),
        'avg' => array_sum($numbers) / count($numbers),
    ];
}

function logLine(string $msg): void
{
    echo "[log] $msg\n";
}

echo grade(95), grade(80), grade(40), "\n";

['min' => $min, 'max' => $max, 'avg' => $avg] = stats([4, 8, 15, 16, 23, 42]);
echo "min $min, max $max, average $avg\n";

[$quotient, $remainder] = [intdiv(17, 5), 17 % 5];
echo "17 / 5 = $quotient remainder $remainder\n";

var_dump(logLine('saved'));   // a void function returns null

Lihat array destructuring untuk bentuk lain dari [...] =.

Parameter default dan named argument

Parameter dengan = value bersifat opsional: pemanggil boleh tidak menyertakannya. Parameter opsional ditulis setelah parameter wajib. Sejak PHP 8.0, named argument memungkinkan pemanggil memberikan parameter mana pun berdasarkan namanya, jadi kamu bisa melewati parameter opsional yang tidak kamu perlukan.

<?php
function makeTag(string $text, string $tag = 'p', ?string $class = null, bool $escape = true): string
{
    $body = $escape ? htmlspecialchars($text) : $text;
    $attr = $class !== null ? " class=\"$class\"" : '';
    return "<$tag$attr>$body</$tag>";
}

echo makeTag('Hello'), "\n";
echo makeTag('Title', 'h1'), "\n";

// Named arguments: skip $tag and $class, set only $escape
echo makeTag('<b>bold</b>', escape: false), "\n";
echo makeTag(class: 'note', text: 'Order does not matter'), "\n";

Named argument juga membuat pemanggilan fungsi bawaan lebih mudah dibaca: str_pad('7', 3, '0', pad_type: STR_PAD_LEFT). Nama parameter menjadi bagian dari antarmuka publik fungsi, jadi mengganti nama parameter bisa merusak pemanggil yang memakai nama.

Pass by reference

Biasanya PHP mengirim salinan setiap argumen, jadi fungsi tidak bisa mengubah variabel milik pemanggil. Tanda & sebelum parameter mengirim variabel itu sendiri. Fungsi bawaan seperti sort() bekerja dengan cara ini.

<?php
function addOne(int $n): void
{
    $n++;          // changes the copy only
}

function addOneRef(int &$n): void
{
    $n++;          // changes the caller's variable
}

$a = 5;
addOne($a);
echo $a, "\n";

addOneRef($a);
echo $a, "\n";

function addItem(array &$cart, string $item): void
{
    $cart[] = $item;
}

$cart = [];
addItem($cart, 'apple');
addItem($cart, 'pear');
print_r($cart);

Mengembalikan nilai baru biasanya lebih jelas daripada mengubah argumen. Pakai referensi saat fungsi itu memang dimaksudkan untuk mengubah sesuatu di tempatnya.

Deklarasi tipe dan strict_types

Secara default, PHP mengonversi argumen ke tipe yang dideklarasikan jika bisa: add("5", 3) mengubah "5" menjadi 5. Menulis declare(strict_types=1); di bagian paling atas file mematikan perilaku itu untuk pemanggilan di file tersebut, sehingga tipe yang salah melempar TypeError alih-alih dikonversi.

<?php
declare(strict_types=1);
// This throws a TypeError on purpose: "5" is a string, not an int

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

echo add(2, 3), "\n";
echo add("5", 3), "\n";

Tanpa baris declare, pemanggilan yang sama mencetak 8. String yang bukan angka, seperti "five", melempar TypeError di kedua mode.

Tipe yang bisa kamu deklarasikan untuk parameter dan nilai return:

<?php
// ?string: a string or null
function findUser(int $id): ?string
{
    $users = [1 => 'Ada', 2 => 'Linus'];
    return $users[$id] ?? null;
}

// int|float: a union type (PHP 8.0)
function half(int|float $n): float
{
    return $n / 2;
}

// mixed: anything at all
function describe(mixed $value): string
{
    return get_debug_type($value);
}

var_dump(findUser(1), findUser(9));
var_dump(half(5), half(2.5));
echo describe([1, 2]), ' ', describe(null), ' ', describe(1.5), "\n";

never adalah tipe return untuk fungsi yang selalu melempar exception atau keluar. Nama class dan interface juga bisa dipakai sebagai tipe.

Jumlah argumen yang tidak tetap dengan ...$args

...$numbers mengumpulkan argumen berapa pun jumlahnya ke dalam array. Tanda ... yang sama di sisi pemanggil menyebarkan array menjadi argumen-argumen terpisah.

<?php
function sum(int ...$numbers): int
{
    return array_sum($numbers);
}

echo sum(), "\n";
echo sum(1, 2, 3), "\n";

$values = [10, 20, 30];
echo sum(...$values), "\n";          // spread an array

function logMessage(string $level, string ...$parts): string
{
    return strtoupper($level) . ': ' . implode(' ', $parts);
}

echo logMessage('info', 'user', 'Ada', 'logged in'), "\n";

Memakai variabel dari luar di dalam fungsi

Fungsi punya scope sendiri. Variabel yang didefinisikan di luarnya tidak terlihat di dalam, dan ini mengejutkan orang yang datang dari JavaScript:

<?php
$taxRate = 0.2;

function priceWithTax(float $price): float
{
    return $price * (1 + $taxRate);   // $taxRate is undefined here
}

Warning: Undefined variable $taxRate in /path/to/index.php on line 6

dan fungsi itu mengembalikan harga tanpa pajak. Sebagai gantinya, kirim nilainya sebagai parameter. Dengan begitu fungsi jujur tentang apa yang dibutuhkannya dan mudah diuji:

<?php
$taxRate = 0.2;

function priceWithTax(float $price, float $taxRate): float
{
    return $price * (1 + $taxRate);
}

echo priceWithTax(100, $taxRate), "\n";
echo priceWithTax(100, 0.1), "\n";

Kata kunci global juga berfungsi, tetapi menyembunyikan ketergantungan itu; variable scope membahasnya. Untuk fungsi pendek yang diberikan ke fungsi lain, seperti callback untuk array_map(), lihat anonymous function, yang bisa menangkap variabel dari luar dengan use.