Arrow Function PHP: Sintaks fn() => dan Contohnya

Arrow function adalah fungsi anonim yang pendek: fn($x) => $x * 2. Body setelah => berupa satu ekspresi yang nilainya dikembalikan, dan variabel apa pun dari kode di sekitarnya yang dipakai ekspresi itu otomatis ditangkap sebagai nilai. Arrow function ada sejak PHP 7.4 dan kebanyakan dipakai sebagai callback.

<?php
$double = fn($x) => $x * 2;
echo $double(21), "\n";

$prices = [10, 25, 40];
print_r(array_map(fn($p) => $p * 1.2, $prices));

$rate = 0.9;   // used inside without "use"
print_r(array_map(fn($p) => $p * $rate, $prices));

Sintaksnya

fn, daftar parameter, =>, lalu satu ekspresi. Tipe parameter, nilai bawaan, dan tipe kembalian bekerja sama seperti di fungsi biasa:

<?php
$add = fn(int $a, int $b = 1): int => $a + $b;
$greet = fn(string $name): string => "Hello, $name";
$isEven = fn(int $n): bool => $n % 2 === 0;
$now = fn() => 'no parameters';

echo $add(2, 3), ' ', $add(2), "\n";
echo $greet('Ada'), "\n";
var_dump($isEven(4), $isEven(7));
echo $now(), "\n";

// Call it immediately
echo (fn($x) => $x ** 2)(9), "\n";

Tidak ada kata kunci return dan tidak ada kurung kurawal. Ekspresi yang panjang tetap bisa dipecah ke beberapa baris supaya mudah dibaca.

Variabel luar ditangkap sebagai nilai

Arrow function melihat setiap variabel di scope tempat ia dibuat. Nilai-nilainya disalin pada saat itu. Perubahan di dalam tetap di dalam, dan perubahan di luar setelah fungsi dibuat tidak terlihat:

<?php
$count = 0;
$increment = fn() => ++$count;

echo $increment(), "\n";   // works on its own copy
echo $increment(), "\n";   // a fresh copy each call
echo $count, "\n";         // the outer variable is unchanged

$discount = 10;
$apply = fn($price) => $price - $discount;
$discount = 50;            // too late: 10 was already captured
echo $apply(100), "\n";

Inilah perbedaan utamanya dengan function () use (&$count), yang bisa berbagi variabel lewat referensi. Arrow function tidak bisa mengisi ulang variabel dari luar. Ia tetap bisa mengubah objek yang ditangkapnya (salinannya adalah penunjuk ke objek yang sama), dan parameter yang dideklarasikan sebagai referensi bekerja seperti di fungsi mana pun: fn(array &$list) => $list[] = 'x'.

Callback untuk array_map, array_filter, dan usort

Sebagian besar fungsi array menerima callback, dan di situlah arrow function paling banyak memangkas kode yang berisik. Bandingkan satu filter yang ditulis dengan dua cara:

<?php
$users = [
    ['name' => 'Ada', 'age' => 36, 'active' => true],
    ['name' => 'Linus', 'age' => 28, 'active' => false],
    ['name' => 'Grace', 'age' => 45, 'active' => true],
];

// Long form
$active1 = array_filter($users, function ($u) {
    return $u['active'];
});

// Arrow function
$active2 = array_filter($users, fn($u) => $u['active']);
var_dump($active1 === $active2);

$names = array_map(fn($u) => $u['name'], $active2);
echo implode(', ', $names), "\n";

usort($users, fn($a, $b) => $a['age'] <=> $b['age']);
echo implode(', ', array_column($users, 'name')), "\n";

$total = array_reduce($users, fn($sum, $u) => $sum + $u['age'], 0);
echo "Total age: $total\n";

<=> mengembalikan -1, 0, atau 1, persis yang dibutuhkan usort(), jadi mengurutkan berdasarkan sebuah field cukup satu baris. Tukar $a dan $b untuk mengurutkan secara menurun.

Arrow function yang mengembalikan arrow function

Variabel yang ditangkap termasuk parameter dari arrow function yang membungkusnya, jadi kamu bisa menyarangkannya untuk membuat fungsi dari nilai lain:

<?php
$multiplyBy = fn($factor) => fn($x) => $x * $factor;

$triple = $multiplyBy(3);
$tenTimes = $multiplyBy(10);

echo $triple(5), ' ', $tenTimes(5), "\n";

$between = fn($min, $max) => fn($n) => $n >= $min && $n <= $max;
$teen = $between(13, 19);
print_r(array_filter([8, 13, 16, 21, 19], $teen));

Perhatikan bahwa array_filter() mempertahankan key aslinya, karena itulah hasilnya dimulai dari indeks 1.

fn vs function: kapan kamu butuh closure lengkap

Arrow function tidak lagi cukup saat body-nya butuh lebih dari satu ekspresi atau harus mengubah variabel dari luar. Saat itu, pakai fungsi anonim:

<?php
$orders = [120, 45, 300, 80];

// Needs a statement and an outer total: a closure with use (&...)
$total = 0;
$big = [];
array_walk($orders, function ($amount) use (&$total, &$big) {
    $total += $amount;
    if ($amount > 100) {
        $big[] = $amount;
    }
});
echo "Total $total, big orders: ", implode(', ', $big), "\n";

// The same result split into expressions: arrow functions fit again
$total2 = array_sum($orders);
$big2 = array_values(array_filter($orders, fn($a) => $a > 100));
echo "Total $total2, big orders: ", implode(', ', $big2), "\n";

Saat sebuah arrow function terasa sesak, sering kali itu tanda tugasnya sebenarnya dua tugas. Memecahnya menjadi filter dan penjumlahan, seperti di atas, membuat setiap callback tetap satu ekspresi.