PHP Academy · Lektion

Anonyme Funktionen und Closures

Schreiben Sie Inline-Funktionen und erfassen Sie Variablen mit use.

Lektion 4 von 413 Schritte

Anonyme Funktionen und Closures ist eine kostenlose PHP Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des PHP Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind anonyme Funktionen?

Eine anonyme Funktion (Lambda) ist eine Funktion ohne Namen. In PHP ist sie eine Instanz der integrierten Klasse Closure und kann in einer Variablen gespeichert, als Argument übergeben oder von einer anderen Funktion zurückgegeben werden.

Einfache anonyme Funktion

Weisen Sie einer Variablen eine Funktion zu und rufen Sie sie auf:

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

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

Anonyme Funktionen übergeben

Übergeben Sie eine Closure als Argument an Funktionen wie array_map, usort oder an Ihre eigenen Callbacks:

<?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]

Funktionen zurückgeben

Eine Funktion kann eine Closure erstellen und zurückgeben – dies ist ein Factory-Muster:

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

Closures und use

Closures können Variablen aus dem äußeren Gültigkeitsbereich mit use übernehmen. Die Übernahme erfolgt per Wert (Kopie), sofern Sie nicht & hinzufügen:

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

Übernahme per Referenz mit use(&)

Damit die Closure aktualisierte äußere Werte sehen kann, übernehmen Sie die Variable per Referenz:

<?php
$count = 0;

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

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

Pfeilfunktionen (PHP 7.4)

Pfeilfunktionen sind kompakte Closures mit einem einzigen Ausdruck, die den äußeren Gültigkeitsbereich automatisch per Wert übernehmen:

<?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]

Pfeilfunktionen können den äußeren Gültigkeitsbereich nicht ändern

Pfeilfunktionen übernehmen Variablen ausschließlich per Wert – sie können äußere Variablen nicht ändern:

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

Closures als Callbacks

Viele PHP-Funktionen akzeptieren ein Callable – Sie können eine Closure, ein Array wie [$obj, 'method'] oder den Namen einer String-Funktion übergeben:

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

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

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

Sofort aufgerufene Closure

Sie können eine Closure in derselben Zeile definieren und aufrufen – dies ist nützlich, um einen isolierten Gültigkeitsbereich zu erstellen:

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

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

Closure::bind und bindTo

Sie können eine Closure mithilfe von Closure::bind() an den Kontext eines anderen Objekts binden:

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

Kurze Überprüfung

Was ist der wichtigste Unterschied zwischen einer regulären Closure mit use und einer PHP-Pfeilfunktion?

Beantworte es in der interaktiven Lektion

Zusammenfassung: Anonyme Funktionen und Closures

Zusammenfassung:

Anonyme Funktionen werden in Variablen gespeichert und weitergegeben
Closures übernehmen äußere Variablen mit use($var) (per Wert) oder use(&$var) (per Referenz)
Pfeilfunktionen (PHP 7.4) übernehmen den äußeren Gültigkeitsbereich automatisch per Wert
Nützlich für Callbacks: array_map, usort, array_filter …
Sie können von Factory-Funktionen zurückgegeben werden

Kostenlos starten

Lerne PHP mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 49
Lektionen: 195

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Anonyme Funktionen und Closures“ kostenlos?

Ja — der vollständige Text von „Anonyme Funktionen und Closures“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des PHP Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Anonyme Funktionen und Closures“?

Schreiben Sie Inline-Funktionen und erfassen Sie Variablen mit use. Du übst PHP Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um PHP Academy zu starten?

Keine Vorkenntnisse erforderlich. PHP Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Anonyme Funktionen und Closures“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser PHP Academy-Lektion Code schreiben und ausführen?

Ja. Jede PHP Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu PHP Academy