פונקציות חץ ב-PHP: תחביר fn() => ודוגמאות

פונקציית חץ היא פונקציה אנונימית קצרה: fn($x) => $x * 2. הגוף שאחרי => הוא ביטוי יחיד שהערך שלו מוחזר, וכל משתנה מהקוד שמסביב שהביטוי משתמש בו נלכד אוטומטית, לפי ערך. פונקציות חץ קיימות מאז PHP 7.4 ומשמשות בעיקר כ-callbacks.

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

התחביר

fn, רשימת הפרמטרים, =>, ביטוי אחד. טיפוסי פרמטרים, ערכי ברירת מחדל וטיפוס החזרה עובדים כמו בפונקציות רגילות:

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

אין מילת מפתח return ואין סוגריים מסולסלים. ביטוי ארוך עדיין אפשר לפצל על פני כמה שורות כדי שיהיה קריא.

משתנים חיצוניים נלכדים לפי ערך

פונקציית חץ רואה כל משתנה בטווח שבו היא נוצרת. היא מעתיקה את הערכים שלהם באותו רגע. שינויים שנעשים בפנים נשארים בפנים, ושינויים שנעשים בחוץ אחרי שהפונקציה נוצרה לא נראים לה:

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

זה ההבדל העיקרי מ-function () use (&$count), שיכולה לשתף משתנה לפי הפניה. פונקציית חץ לא יכולה להציב מחדש משתנה חיצוני. היא עדיין יכולה לשנות אובייקט שהיא לכדה (העותק הוא ידית לאותו אובייקט), ופרמטר שמוצהר לפי הפניה עובד כמו בכל פונקציה: fn(array &$list) => $list[] = 'x'.

callbacks ל-array_map, array_filter ו-usort

רוב פונקציות המערך מקבלות callback, ושם פונקציות חץ חוסכות הכי הרבה רעש. השוו סינון אחד שכתוב בשתי הדרכים:

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

<=> מחזיר -1, 0 או 1, בדיוק מה ש-usort() רוצה, ולכן מיון לפי שדה נכנס בשורה אחת. החליפו בין $a ל-$b כדי למיין בסדר יורד.

פונקציות חץ שמחזירות פונקציות חץ

המשתנים הנלכדים כוללים את הפרמטרים של פונקציית חץ עוטפת, כך שאפשר לקנן אותן כדי לבנות פונקציות מערכים אחרים:

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

שימו לב ש-array_filter() שומרת על המפתחות המקוריים, ולכן התוצאה מתחילה באינדקס 1.

fn מול function: מתי צריך closure מלא

פונקציות חץ מפסיקות לעבוד כשהגוף צריך יותר מביטוי אחד או חייב לשנות משתנה חיצוני. אז השתמשו בפונקציה אנונימית:

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

כשפונקציית חץ מרגישה צפופה, זה אומר לעיתים קרובות שהעבודה היא בעצם שתי עבודות. פיצול שלה לסינון ולסכום, כמו למעלה, שומר כל callback כביטוי יחיד.