PHP Anonim Fonksiyonlar ve Closure: use Anahtar Kelimesi

Closure olarak da adlandırılan anonim fonksiyon adı olmayan bir fonksiyondur. Bir değer beklenen yere function ($param) { ... } yazarsınız: bir değişkene atayın, başka bir fonksiyona verin ya da döndürün. Çevredeki koddan değişkenleri use ($var) ile taşıyabilir.

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

Her anonim fonksiyon yerleşik Closure sınıfının bir nesnesidir; saklanabilmesinin, aktarılabilmesinin ve daha sonra $greet(...) ile çağrılabilmesinin nedeni budur.

use anahtar kelimesi değerle yakalar

Bir closure dışarıdaki değişkenleri kendi başına göremez. use ($x) $x değerini closure çalıştığında değil, oluşturulduğu anda closure içine kopyalar:

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

Referansla use: &$var

use (&$x) closure'a kopya yerine değişkenin kendisini verir. Closure içindeki değişiklikler dışarıda görünür, dışarıdaki değişiklikler de içeride görülür. Bir geri çağırma bir toplama ekleme yapar veya bir sayaç tutarken böyle çalışır.

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

Her makeCounter() çağrısı yeni bir $count oluşturur ve döndürülen closure fonksiyon döndükten sonra da onu yaşatır. "Closure" (kapanış) kelimesinin anlatmak istediği budur: fonksiyon ihtiyaç duyduğu değişkenleri kapsar.

Bir closure'ı geri çağırma olarak verme

array_map(), array_filter(), usort() ve array_walk() gibi fonksiyonlar argüman olarak bir fonksiyon alır. Bir closure onu, işin gerektirdiği kadar deyimle yerinde yazmanızı sağlar:

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

Gövde tek bir ifade olduğunda fn($p) => $p['price'] gibi bir ok fonksiyonu daha kısadır ve use gerektirmez.

Callable değerler: fonksiyon adları, metotlar ve strlen(...)

callable türünde bir parametre closure'lardan fazlasını kabul eder. Fonksiyon adı içeren bir dizge, bir nesne ve metot adı içeren bir dizi, bir sınıf adı ve statik metot adı içeren bir dizi de sayılır. PHP 8.1'den beri strlen(...) birinci sınıf çağrılabilir söz dizimi bunların herhangi birini doğrudan bir Closure nesnesine çevirir.

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

(...) biçimi satır çalıştığında kontrol edilir: bir yazım hatası orada hemen bir Error fırlatır. 'strtoupr' gibi bir dizge, biri onu çağırmaya çalışana kadar yalnızca bir dizgedir.

Bir sınıf içindeki closure'lar: $this ve static

Bir metot içinde oluşturulan bir closure'a $this otomatik olarak bağlanır, böylece nesnenin özelliklerini kullanabilir. $this gerekmediğinde onu static function olarak işaretleyin; bu ayrıca nesneyi gereksiz yere yaşatmasını da önler.

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

use yazmayı unutmak

En yaygın closure hatası, dışarıdaki bir değişkeni use içinde listelemeden kullanmaktır. Closure içinde değişken yoktur:

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

PHP prints: Warning: Undefined variable $minAge

$minAge içeride null olur, >= null ile karşılaştırılan her yaş true olur ve herkes filtreden geçer. Uyarıları gizleyen bir sunucuda size hiçbir şey bunu söylemez. Değişkeni use içine ekleyin:

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