From b88323929e8cb1c40fbc9bca0017ed6f7e740865 Mon Sep 17 00:00:00 2001 From: lacatoire Date: Fri, 29 May 2026 21:46:19 +0200 Subject: [PATCH 1/7] [Sync EN] Major rewrite of the callable type chapter MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Brings language/types/callable.xml up to date with the upstream rewrite (EN-Revision 312c0c7b39d0722c419f6784cbda24823220dfb3): - Title "Callbacks / Callables" → "Callables". - New intro paragraph with a short informalexample showing callable as a parameter type. - Section "Übergabe" renamed to "Erstellung von Callables" and reorganized around how callables are created. - New itemizedlist enumerating the four ways to create a callable (Closure object, string, array with class+method, object implementing __invoke). - New explanation of how Closure objects can be built (anonymous function, arrow function, first-class callable syntax, Closure::fromCallable) with a runnable example showing all four. - New note about scope binding (Closure is bound to creation scope, callables as string/array are resolved in the call scope). - New paragraph and note about context-dependent callables (parent::method, ["static", "method"]) deprecated since PHP 8.2.0. - Existing call_user_func example expanded with a new Type 5 case using MyClass::class and renumbered subsequent types; output is now shown via a block. - Standalone Closure example removed (content merged into the new Closure example earlier in the section). - Dropped the obsolete SVN marker. Sie-Form beibehalten, bestehender Maintainer (simp) bleibt. --- language/types/callable.xml | 317 ++++++++++++++++++++++++------------ 1 file changed, 217 insertions(+), 100 deletions(-) diff --git a/language/types/callable.xml b/language/types/callable.xml index e30c3f353..479cb9559 100644 --- a/language/types/callable.xml +++ b/language/types/callable.xml @@ -1,79 +1,214 @@ - + - Callbacks / Callables + Callables - - Callbacks können mit der Typdeklaration callable - gekennzeichnet werden. - + + Ein Callable ist eine Referenz auf eine Funktion oder Methode, die einer + anderen Funktion als Argument übergeben wird. + Sie werden durch die Typdeklaration callable repräsentiert. + + + + +]]> + + - - Einige Funktionen wie call_user_func oder - usort akzeptieren eine benutzerdefinierte - Callback-Funktion als Argument. Callback-Funktionen können nicht nur - einfache Funktionen sein, sondern auch Methoden eines - Objects, inklusive statischer Klassenmethoden. - + + Einige Funktionen akzeptieren Callback-Funktionen als Parameter, zum + Beispiel array_map, usort oder + preg_replace_callback. + - Übergabe + Erstellung von Callables + + + Ein Callable ist ein Typ, der etwas repräsentiert, das aufgerufen werden + kann. Callables können als Argumente an Funktionen oder Methoden übergeben + werden, die einen Callback-Parameter erwarten, oder sie können direkt + aufgerufen werden. Der Typ callable kann nicht als + Typdeklaration für Klasseneigenschaften verwendet werden. Verwenden Sie + stattdessen eine Closure-Typdeklaration. + + + + Callables können auf verschiedene Arten erstellt werden: + + + + + Closure-Objekt + + + &string;, der den Namen einer Funktion oder Methode enthält + + + + &array;, das einen Klassennamen oder ein Object an + Index 0 und den Methodennamen an Index 1 enthält + + + + + &object;, das die magische Methode + __invoke() implementiert + + + + + + Ein Closure-Objekt kann mit der Syntax für + anonyme Funktionen, der Syntax + für Pfeilfunktionen, der + Syntax für + Callbacks als Objekte erster Klasse oder mit der Methode + Closure::fromCallable erstellt werden. + + + + + Die Syntax für + Callbacks als Objekte erster Klasse ist erst ab PHP 8.1.0 + verfügbar. + + + + + + Callback-Beispiel mit einem <classname>Closure</classname> + + + $a * 2; + +// Verwendung von Closure::fromCallable +$double4 = Closure::fromCallable('double_function'); + +// Hier wird das Closure als Callback verwendet, um +// die Größe jedes Elements unseres Bereichs zu verdoppeln +$new_numbers = array_map($double1, range(1, 5)); +print implode(' ', $new_numbers) . PHP_EOL; + +$new_numbers = array_map($double2, range(1, 5)); +print implode(' ', $new_numbers) . PHP_EOL; + +$new_numbers = array_map($double3, range(1, 5)); +print implode(' ', $new_numbers) . PHP_EOL; + +$new_numbers = array_map($double4, range(1, 5)); +print implode(' ', $new_numbers); + +?> +]]> + + &example.outputs.81; + + + + - - Eine PHP-Funktion wird anhand ihres Namens als String - übergeben. Jede eingebaute oder benutzerdefinierte Funktion kann - verwendet werden, außer Sprachkonstrukten wie: + + Ein Callable kann auch ein String sein, der den Namen einer Funktion oder + einer statischen Methode enthält. Jede eingebaute oder benutzerdefinierte + Funktion kann verwendet werden, außer Sprachkonstrukten wie: array, echo, empty, eval, - exit, isset, + isset, list, print oder unset. - - - - Eine Methode eines instantiierten Objects wird - übergeben als Array mit dem Object - an Index-Position 0 und dem Methodennamen an Position 1. Der Zugriff - auf als protected oder private markierte Methoden von innerhalb - der Klasse ist erlaubt. - - - - Statische Klassenmethoden können auch übergeben werden, ohne dass ein - Object dieser Klasse instantiiert werden muss, indem - man entweder den Namen der Klasse statt eines Objects als - Index 0 übergibt oder indem man 'ClassName::methodName' - übergibt. - - - - Neben den üblichen benutzerdefinierten Funktionen können auch - anonyme Funktionen - oder Pfeilfunktionen - als Callback-Argumente übergeben werden. - + + + + Statische Klassenmethoden können verwendet werden, ohne dass ein + Object dieser Klasse instantiiert werden muss, indem entweder + ein Array mit dem Klassennamen an Index 0 und dem Methodennamen an Index 1 + erstellt wird, oder indem die spezielle Syntax mit dem + Bereichsauflösungsoperator ::, wie in + 'ClassName::methodName', verwendet wird. + + + + Eine Methode eines instantiierten Objects kann ein Callable + sein, wenn sie als Array mit dem Object an Index 0 und dem + Methodennamen an Index 1 angegeben wird. + + + + Der Hauptunterschied zwischen einem Closure-Objekt + und dem Typ callable besteht darin, dass ein + Closure-Objekt unabhängig vom Geltungsbereich ist + und immer aufgerufen werden kann, während ein Callable-Typ vom + Geltungsbereich abhängig sein und möglicherweise nicht direkt aufgerufen + werden kann. Closure ist die bevorzugte Art, + Callables zu erstellen. + + + + + Während Closure-Objekte an den Geltungsbereich + gebunden sind, in dem sie erstellt werden, werden Callables, die + Klassenmethoden als Strings oder Arrays referenzieren, in dem + Geltungsbereich aufgelöst, in dem sie aufgerufen werden. Um aus einer + privaten oder geschützten Methode ein Callable zu erstellen, das dann + von außerhalb des Klassengeltungsbereichs aufgerufen werden kann, + verwenden Sie Closure::fromCallable oder die + Syntax für + Callbacks als Objekte erster Klasse. + + + + + PHP erlaubt die Erstellung von Callables, die als Callback-Argument + verwendet, aber nicht direkt aufgerufen werden können. Dabei handelt es + sich um kontextabhängige Callables, die eine Klassenmethode in der + Vererbungshierarchie einer Klasse referenzieren, zum Beispiel + 'parent::method' oder + ["static", "method"]. + - - Seit PHP 8.1.0 können anonyme Funktionen auch mit der Syntax für - Callback-Funktionen als Objekte erster Klasse - erstellt werden. - + + Seit PHP 8.2.0 sind kontextabhängige Callables veraltet. Entfernen Sie + die Kontextabhängigkeit, indem Sie + 'parent::method' durch + parent::class . '::method' ersetzen, oder verwenden + Sie die Syntax für + Callbacks als Objekte erster Klasse. + - - Generell kann jedes Objekt, welches - __invoke() implementiert, als - Callback-Argument übergeben werden. - - - - - - Beispiele für Callback-Funktionen - - + + + Verschiedene Arten von Callables mit + <function>call_user_function</function> aufrufen + + ]]> - - - - - - - Callback-Beispiel mit einem Closure - - + + &example.outputs; + +Deprecated: Callables of the form ["B", "parent::who"] are deprecated in script on line 41 +A +Hello PHP! ]]> - - &example.outputs; - - - - - + + ¬e.func-callback-exceptions; -