PHP Academy · Lekcja

Funkcje anonimowe i domknięcia

Pisanie funkcji wbudowanych w kodzie i przechwytywanie zmiennych za pomocą use.

Funkcje anonimowe i domknięcia to bezpłatna lekcja PHP Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej PHP Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs PHP Academy zawiera 4 lekcji w sumie.

Czym są funkcje anonimowe?

Funkcja anonimowa (lambda) to funkcja bez nazwy. W PHP jest instancją wbudowanej klasy Closure i może być przechowywana w zmiennej, przekazywana jako argument lub zwracana przez inną funkcję.

Podstawowa funkcja anonimowa

Przypisz funkcję do zmiennej i wywołaj ją:

<?php
$double = function(int $n): int {
    return $n * 2;
};

echo $double(5);   // 10
echo $double(21);  // 42

Przekazywanie funkcji anonimowych

Przekaż domknięcie jako argument do funkcji takich jak array_map, usort lub do własnych funkcji zwrotnych:

<?php
$nums = [3, 1, 4, 1, 5, 9];

$squared = array_map(function(int $n): int {
    return $n ** 2;
}, $nums);

print_r($squared); // [9, 1, 16, 1, 25, 81]

Zwracanie funkcji

Funkcja może utworzyć i zwrócić domknięcie — jest to wzorzec fabryki:

<?php
function makeMultiplier(int $factor): Closure {
    return function(int $n) use ($factor): int {
        return $n * $factor;
    };
}

$triple  = makeMultiplier(3);
$tenX    = makeMultiplier(10);

echo $triple(5);   // 15
echo $tenX(5);     // 50

Domknięcia i use

Domknięcia mogą przechwytywać zmienne z zewnętrznego zakresu za pomocą use. Przechwytywanie odbywa się przez wartość (kopię), chyba że dodasz &:

<?php
$taxRate = 0.18;

$addTax = function(float $price) use ($taxRate): float {
    return $price * (1 + $taxRate);
};

$taxRate = 0.20;  // change outer variable
echo $addTax(100); // 118 — captured value at creation time

Przechwytywanie przez referencję za pomocą use(&)

Aby domknięcie widziało zaktualizowane wartości zewnętrzne, przechwytuj je przez referencję:

<?php
$count = 0;

$increment = function() use (&$count): void {
    $count++;
};

$increment();
$increment();
echo $count;  // 2

Funkcje strzałkowe (PHP 7.4)

Funkcje strzałkowe to zwięzłe domknięcia zawierające pojedyncze wyrażenie, które automatycznie przechwytują zewnętrzny zakres przez wartość:

<?php
$rate = 1.18;
$prices = [10, 20, 30];

// Arrow function — no 'use' needed
$withTax = array_map(fn($p) => $p * $rate, $prices);

print_r($withTax); // [11.8, 23.6, 35.4]

Funkcje strzałkowe nie mogą modyfikować zewnętrznego zakresu

Funkcje strzałkowe przechwytują wyłącznie przez wartość — nie mogą modyfikować zmiennych zewnętrznych:

<?php
$total = 0;
$nums  = [1, 2, 3];

// This does NOT modify $total!
array_walk($nums, fn($n) => $total += $n);

echo $total;  // 0

// Use a reference closure for mutation:
array_walk($nums, function($n) use (&$total) { $total += $n; });
echo $total;  // 6

Domknięcia jako funkcje zwrotne

Wiele funkcji PHP przyjmuje wartość typu callable — można przekazać domknięcie, tablicę [$obj, 'method'] lub nazwę funkcji w postaci ciągu znaków:

<?php
$words = ['banana', 'apple', 'cherry'];

usort($words, fn($a, $b) => strcmp($a, $b));

print_r($words); // ['apple', 'banana', 'cherry']

Natychmiast wywoływane domknięcie

Można zdefiniować i wywołać domknięcie w tym samym wierszu — jest to przydatne do utworzenia odizolowanego zakresu:

<?php
$result = (function(): int {
    $x = 10;
    $y = 20;
    return $x + $y;
})();

echo $result; // 30
// $x and $y are not in outer scope

Closure::bind i bindTo

Można ponownie powiązać domknięcie z kontekstem innego obiektu za pomocą Closure::bind():

<?php
class Counter {
    private int $value = 0;
}

$increment = Closure::bind(function(int $by): void {
    $this->value += $by;
}, new Counter(), Counter::class);

// Now $increment has access to private $value

Szybki test

Jaka jest główna różnica między zwykłym domknięciem z use a funkcją strzałkową w PHP?

Podsumowanie: funkcje anonimowe i domknięcia

Podsumowanie:

Funkcje anonimowe są przechowywane w zmiennych i przekazywane dalej
Domknięcia przechwytują zmienne zewnętrzne za pomocą use($var) (przez wartość) lub use(&$var) (przez referencję)
Funkcje strzałkowe (PHP 7.4) automatycznie przechwytują zewnętrzny zakres przez wartość
Przydatne w funkcjach zwrotnych: array_map, usort, array_filter…
Mogą być zwracane przez funkcje fabrykujące

Często zadawane pytania

Czy lekcja „Funkcje anonimowe i domknięcia” jest bezpłatna?

Tak — pełny tekst „Funkcje anonimowe i domknięcia” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu PHP Academy, przejdź na CoddyKit PRO. Kurs PHP Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Funkcje anonimowe i domknięcia”?

Pisanie funkcji wbudowanych w kodzie i przechwytywanie zmiennych za pomocą use. Ćwiczysz PHP Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć PHP Academy?

Nie wymagamy żadnego doświadczenia. PHP Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Funkcje anonimowe i domknięcia”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji PHP Academy?

Tak. Każda lekcja PHP Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do PHP Academy