Arrow function trong PHP: cú pháp fn() => và ví dụ

Arrow function là một hàm ẩn danh ngắn gọn: fn($x) => $x * 2. Phần thân sau => là một biểu thức duy nhất và giá trị của nó được trả về; biến nào ở đoạn code bao quanh mà biểu thức dùng đến đều được bắt tự động, theo giá trị. Arrow function có từ PHP 7.4 và chủ yếu được dùng làm 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));

Cú pháp

fn, danh sách tham số, =>, một biểu thức. Kiểu tham số, giá trị mặc định và kiểu trả về hoạt động giống như ở hàm thông thường:

<?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";

Không có từ khóa return và không có dấu ngoặc nhọn. Bạn vẫn có thể ngắt một biểu thức dài thành nhiều dòng cho dễ đọc.

Biến bên ngoài được bắt theo giá trị

Arrow function thấy mọi biến của phạm vi nơi nó được tạo ra. Nó sao chép giá trị của các biến đó ngay tại thời điểm ấy. Thay đổi bên trong chỉ nằm bên trong, còn thay đổi bên ngoài sau khi hàm đã được tạo thì hàm không thấy:

<?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";

Đây là khác biệt chính so với function () use (&$count), vốn có thể dùng chung một biến theo tham chiếu. Arrow function không gán lại được biến bên ngoài. Nó vẫn có thể thay đổi một đối tượng đã bắt (bản sao là một handle trỏ tới cùng đối tượng), và một tham số khai báo theo tham chiếu hoạt động như ở mọi hàm khác: fn(array &$list) => $list[] = 'x'.

Callback cho array_map, array_filter và usort

Phần lớn các hàm mảng nhận một callback, và đó là nơi arrow function giúp code gọn nhất. Hãy so sánh cùng một phép lọc viết theo hai cách:

<?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";

<=> trả về -1, 0 hoặc 1, đúng thứ mà usort() cần, nên sắp xếp theo một trường chỉ cần một dòng. Đổi chỗ $a và $b để sắp xếp giảm dần.

Arrow function trả về arrow function

Các biến được bắt bao gồm cả tham số của arrow function bao ngoài, nên bạn có thể lồng chúng vào nhau để tạo hàm từ các giá trị khác:

<?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));

Lưu ý rằng array_filter() giữ nguyên khóa gốc, vì vậy kết quả bắt đầu ở chỉ số 1.

fn và function: khi nào cần closure đầy đủ

Arrow function không còn phù hợp khi phần thân cần nhiều hơn một biểu thức hoặc phải thay đổi biến bên ngoài. Lúc đó hãy dùng hàm ẩn danh:

<?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";

Khi arrow function trở nên chật chội, thường đó là dấu hiệu công việc thực ra gồm hai việc. Tách nó thành một phép lọc và một phép tính tổng như trên giúp mỗi callback chỉ còn một biểu thức.