PHP Ok Fonksiyonları: fn() => Söz Dizimi ve Örnekler

Ok fonksiyonu kısa bir anonim fonksiyondur: fn($x) => $x * 2. => sonrasındaki gövde, değeri döndürülen tek bir ifadedir ve ifadenin kullandığı çevredeki koddan her değişken otomatik olarak, değerle yakalanır. Ok fonksiyonları PHP 7.4'ten beri vardır ve çoğunlukla geri çağırma olarak kullanılır.

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

Söz dizimi

fn, parametre listesi, =>, tek bir ifade. Parametre türleri, varsayılan değerler ve dönüş türü normal fonksiyonlardaki gibi çalışır:

<?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 anahtar kelimesi ve süslü parantez yoktur. Uzun bir ifade okunurluk için yine de birkaç satıra bölünebilir.

Dış değişkenler değerle yakalanır

Bir ok fonksiyonu oluşturulduğu kapsamın her değişkenini görür. Değerlerini o anda kopyalar. İçeride yapılan değişiklikler içeride kalır ve fonksiyon oluşturulduktan sonra dışarıda yapılan değişiklikler görülmez:

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

Bir değişkeni referansla paylaşabilen function () use (&$count) ile temel fark budur. Bir ok fonksiyonu dışarıdaki bir değişkene yeniden atama yapamaz. Yakaladığı bir nesneyi yine de değiştirebilir (kopya aynı nesneye bir tanıtıcıdır) ve referansla bildirilen bir parametre her fonksiyonda olduğu gibi çalışır: fn(array &$list) => $list[] = 'x'.

array_map, array_filter ve usort için geri çağırmalar

Çoğu dizi fonksiyonu bir geri çağırma alır ve ok fonksiyonlarının en çok kalabalıktan kurtardığı yer orasıdır. İki şekilde yazılmış bir filtreyi karşılaştırın:

<?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 veya 1 döndürür, usort() tam olarak bunu ister, bu yüzden bir alana göre sıralama tek satıra sığar. Azalan sıralamak için $a ve $b yerini değiştirin.

Ok fonksiyonu döndüren ok fonksiyonları

Yakalanan değişkenler, dıştaki bir ok fonksiyonunun parametrelerini de içerir, bu yüzden onları iç içe yazarak başka değerlerden fonksiyonlar oluşturabilirsiniz:

<?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() orijinal anahtarları koruduğu için sonucun 1 indeksinden başladığına dikkat edin.

fn ile function: ne zaman tam bir closure gerekir

Gövde birden fazla ifade gerektirdiğinde ya da dışarıdaki bir değişkeni değiştirmesi gerektiğinde ok fonksiyonları yetmez. O zaman bir anonim fonksiyon kullanın:

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

Bir ok fonksiyonu dar geldiğinde bu çoğu zaman işin aslında iki iş olduğu anlamına gelir. Yukarıdaki gibi bir filtre ve bir toplama bölmek her geri çağırmayı tek bir ifade olarak tutar.