-
Notifications
You must be signed in to change notification settings - Fork 50
Expand file tree
/
Copy pathcallable.xml
More file actions
192 lines (165 loc) · 4.81 KB
/
callable.xml
File metadata and controls
192 lines (165 loc) · 4.81 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: simp Status: ready -->
<!-- Reviewed: no -->
<sect1 xml:id="language.types.callable">
<title>Callbacks / Callables</title>
<para>
Callbacks können mit der Typdeklaration <type>callable</type>
gekennzeichnet werden.
</para>
<para>
Einige Funktionen wie <function>call_user_func</function> oder
<function>usort</function> akzeptieren eine benutzerdefinierte
Callback-Funktion als Argument. Callback-Funktionen können nicht nur
einfache Funktionen sein, sondern auch Methoden eines
<type>Object</type>s, inklusive statischer Klassenmethoden.
</para>
<sect2 xml:id="language.types.callable.passing">
<title>Übergabe</title>
<para>
Eine PHP-Funktion wird anhand ihres Namens als <type>String</type>
übergeben. Jede eingebaute oder benutzerdefinierte Funktion kann
verwendet werden, außer Sprachkonstrukten wie:
<function>array</function>, <function>echo</function>,
<function>empty</function>, <function>eval</function>,
<function>exit</function>, <function>isset</function>,
<function>list</function>, <function>print</function> oder
<function>unset</function>.
</para>
<para>
Eine Methode eines instantiierten <type>Object</type>s wird
übergeben als <type>Array</type> mit dem <type>Object</type>
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.
</para>
<para>
Statische Klassenmethoden können auch übergeben werden, ohne dass ein
<type>Object</type> dieser Klasse instantiiert werden muss, indem
man entweder den Namen der Klasse statt eines <type>Object</type>s als
Index 0 übergibt oder indem man <literal>'ClassName::methodName'</literal>
übergibt.
</para>
<para>
Neben den üblichen benutzerdefinierten Funktionen können auch
<link linkend="functions.anonymous">anonyme Funktionen</link>
oder <link linkend="functions.arrow">Pfeilfunktionen</link>
als Callback-Argumente übergeben werden.
</para>
<note>
<para>
Seit PHP 8.1.0 können anonyme Funktionen auch mit der Syntax für
<link linkend="functions.first_class_callable_syntax">Callback-Funktionen als Objekte erster Klasse</link>
erstellt werden.
</para>
</note>
<para>
Generell kann jedes Objekt, welches
<link linkend="object.invoke">__invoke()</link> implementiert, als
Callback-Argument übergeben werden.
</para>
<para>
<example>
<title>
Beispiele für Callback-Funktionen
</title>
<programlisting role="php">
<![CDATA[
<?php
// Eine Beispiel-Callback-Funktion
function my_callback_function() {
echo 'hello world!', PHP_EOL;
}
// Eine Beispiel-Callback-Methode
class MyClass {
static function myCallbackMethod() {
echo 'Hello World!', PHP_EOL;
}
}
// Typ 1: Einfaches Callback
call_user_func('my_callback_function');
// Typ 2: Statischer Methodenaufruf
call_user_func(array('MyClass', 'myCallbackMethod'));
// Typ 3: Aufruf einer Objektmethode
$obj = new MyClass();
call_user_func(array($obj, 'myCallbackMethod'));
// Typ 4: Statischer Methodenaufruf
call_user_func('MyClass::myCallbackMethod');
// Typ 5: Relativer statischer Methodenaufruf
class A {
public static function who() {
echo 'A', PHP_EOL;
}
}
class B extends A {
public static function who() {
echo 'B', PHP_EOL;
}
}
call_user_func(array('B', 'parent::who')); // A, seit PHP 8.2.0 veraltet
// Typ 6: Objekte die __invoke implementieren können als Callable verwendet werden
class C {
public function __invoke($name) {
echo 'Hello ', $name, PHP_EOL;
}
}
$c = new C();
call_user_func($c, 'PHP!');
?>
]]>
</programlisting>
</example>
</para>
<para>
<example>
<title>
Callback-Beispiel mit einem Closure
</title>
<programlisting role="php">
<![CDATA[
<?php
// Unser Closure
$double = function($a) {
return $a * 2;
};
// Dies ist unsere Menge an Zahlen
$numbers = range(1, 5);
// Hier verwenden wir das Callback, um
// den Wert jedes Elements in unserer
// Menge zu verdoppeln
$new_numbers = array_map($double, $numbers);
print implode(' ', $new_numbers);
?>
]]>
</programlisting>
&example.outputs;
<screen>
<![CDATA[
2 4 6 8 10
]]>
</screen>
</example>
</para>
¬e.func-callback-exceptions;
</sect2>
</sect1>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->