Fungsi Anonim (Closure) di PHP: Kata Kunci use

Fungsi anonim, yang juga disebut closure, adalah fungsi tanpa nama. Kamu menulis function ($param) { ... } di tempat yang membutuhkan sebuah nilai: simpan ke variabel, kirim ke fungsi lain, atau kembalikan sebagai hasil. Fungsi ini bisa membawa variabel dari kode di sekitarnya dengan use ($var).

<?php
$greet = function (string $name): string {
    return "Hello, $name";
};   // the semicolon ends the assignment

echo $greet('Ada'), "\n";

$greeting = 'Welcome';
$welcome = function (string $name) use ($greeting): string {
    return "$greeting, $name";
};
echo $welcome('Linus'), "\n";

var_dump($greet instanceof Closure);

Setiap fungsi anonim adalah objek dari class bawaan Closure. Karena itulah ia bisa disimpan, dioper ke mana-mana, lalu dipanggil nanti dengan $greet(...).

Kata kunci use menangkap nilai (by value)

Closure tidak bisa melihat variabel di luar dirinya dengan sendirinya. use ($x) menyalin nilai $x ke dalam closure pada saat closure dibuat, bukan saat closure dijalankan:

<?php
$discount = 10;

$apply = function (float $price) use ($discount): float {
    return $price - $discount;
};

$discount = 50;            // changed after the closure was created
echo $apply(100), "\n";    // still uses 10

// Several variables
$currency = 'EUR';
$rate = 1.08;
$convert = function (float $usd) use ($rate, $currency): string {
    return number_format($usd / $rate, 2) . " $currency";
};
echo $convert(54), "\n";

use lewat referensi: &$var

use (&$x) memberi closure variabel itu sendiri, bukan salinannya. Perubahan di dalam closure terlihat di luar, dan perubahan di luar terlihat di dalam. Dengan cara inilah sebuah callback menambah total atau menyimpan penghitung.

<?php
$total = 0;
$addToTotal = function (int $amount) use (&$total): void {
    $total += $amount;
};

$addToTotal(10);
$addToTotal(32);
echo $total, "\n";

// A counter that remembers its state between calls
function makeCounter(): Closure
{
    $count = 0;
    return function () use (&$count): int {
        return ++$count;
    };
}

$next = makeCounter();
echo $next(), $next(), $next(), "\n";

$other = makeCounter();     // its own $count
echo $other(), "\n";

Setiap panggilan ke makeCounter() membuat $count yang baru, dan closure yang dikembalikan menjaga variabel itu tetap hidup setelah fungsinya selesai. Itulah maksud kata "closure": fungsi itu "menutup" variabel yang ia butuhkan.

Mengirim closure sebagai callback

Fungsi seperti array_map(), array_filter(), usort(), dan array_walk() menerima fungsi sebagai argumen. Dengan closure, kamu bisa menulis fungsi itu langsung di tempatnya, dengan pernyataan sebanyak yang dibutuhkan:

<?php
$products = [
    ['name' => 'Laptop', 'price' => 1200, 'stock' => 3],
    ['name' => 'Mouse', 'price' => 25, 'stock' => 0],
    ['name' => 'Monitor', 'price' => 300, 'stock' => 7],
];

$minPrice = 100;
$available = array_filter($products, function ($p) use ($minPrice) {
    return $p['stock'] > 0 && $p['price'] >= $minPrice;
});

usort($available, function ($a, $b) {
    return $b['price'] <=> $a['price'];   // most expensive first
});

$labels = array_map(function ($p) {
    $label = strtoupper($p['name']);
    return "$label ({$p['stock']} left)";
}, $available);

print_r($labels);

Kalau body-nya hanya satu ekspresi, arrow function seperti fn($p) => $p['price'] lebih pendek dan tidak butuh use.

Callable: nama fungsi, method, dan strlen(...)

Parameter bertipe callable menerima lebih dari sekadar closure. String berisi nama fungsi, array berisi objek dan nama method, serta array berisi nama class dan nama static method juga dihitung. Sejak PHP 8.1, sintaks first-class callable strlen(...) langsung mengubah semuanya menjadi Closure.

<?php
class Formatter
{
    public function shout(string $s): string { return strtoupper($s) . '!'; }
    public static function whisper(string $s): string { return strtolower($s) . '...'; }
}

$words = ['Hello', 'World'];
$f = new Formatter();

print_r(array_map('strtoupper', $words));                   // function name
print_r(array_map([$f, 'shout'], $words));                  // object method
print_r(array_map([Formatter::class, 'whisper'], $words));  // static method

// PHP 8.1 first-class callable syntax
$len = strlen(...);
$shout = $f->shout(...);
$whisper = Formatter::whisper(...);
echo $len('closure'), ' ', $shout('hey'), ' ', $whisper('PSST'), "\n";

function apply(callable $fn, string $value): string
{
    return $fn($value);
}
echo apply('ucfirst', 'php'), "\n";
var_dump(is_callable('no_such_function'));

Bentuk (...) diperiksa saat barisnya berjalan: salah ketik langsung melempar Error di situ. String seperti 'strtoupr' hanyalah string sampai ada yang mencoba memanggilnya.

Closure di dalam class: $this dan static

Closure yang dibuat di dalam method otomatis terikat ke $this, jadi ia bisa memakai property objek. Tandai dengan static function kalau tidak butuh $this; ini juga mencegah closure membuat objeknya tetap hidup.

<?php
class Cart
{
    private array $items = [];
    private float $taxRate = 0.2;

    public function add(string $name, float $price): void
    {
        $this->items[$name] = $price;
    }

    public function pricesWithTax(): array
    {
        // $this is available inside the closure
        return array_map(function (float $price): float {
            return round($price * (1 + $this->taxRate), 2);
        }, $this->items);
    }

    public function names(): array
    {
        return array_map(static function (string $name): string {
            return ucfirst($name);
        }, array_keys($this->items));
    }
}

$cart = new Cart();
$cart->add('book', 12.5);
$cart->add('pen', 1.99);
print_r($cart->pricesWithTax());
print_r($cart->names());

Lupa menulis use

Bug closure yang paling umum adalah memakai variabel dari luar tanpa mencantumkannya di use. Di dalam closure, variabel itu tidak ada:

$minAge = 18;
$adults = array_filter($people, function ($p) {
    return $p['age'] >= $minAge;   // $minAge is not in use (...)
});

PHP prints: Warning: Undefined variable $minAge

$minAge bernilai null di dalam closure, usia apa pun yang dibandingkan >= null hasilnya true, dan setiap orang lolos filter. Di server yang menyembunyikan warning, tidak ada yang memberitahumu. Tambahkan variabelnya ke use:

<?php
$people = [['name' => 'Ada', 'age' => 36], ['name' => 'Tom', 'age' => 12]];
$minAge = 18;

$adults = array_filter($people, function ($p) use ($minAge) {
    return $p['age'] >= $minAge;
});
print_r(array_column($adults, 'name'));

// Or an arrow function, which captures $minAge automatically
$adults2 = array_filter($people, fn($p) => $p['age'] >= $minAge);
print_r(array_column($adults2, 'name'));