-
Notifications
You must be signed in to change notification settings - Fork 49
/
decon.xml
323 lines (303 loc) · 11.2 KB
/
decon.xml
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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<!-- EN-Revision: 4317fec7555dd42621f88162cc5068092e5c5cfb Maintainer: seros Status: ready -->
<!-- Reviewed: no -->
<sect1 xml:id="language.oop5.decon" xmlns="http://docbook.org/ns/docbook">
<title>Constructores y destructores</title>
<sect2 xml:id="language.oop5.decon.constructor">
<title>Constructor</title>
<methodsynopsis xml:id="object.construct">
<type>void</type><methodname>__construct</methodname>
<methodparam rep="repeat"><type>mixed</type><parameter>values</parameter><initializer>""</initializer></methodparam>
</methodsynopsis>
<para>
PHP permite a los desarrolladores declarar métodos constructores para las
clases. Aquellas que tengan un método constructor lo invocarán en cada nuevo
objeto creado, lo que lo hace idóneo para cualquier inicialización que
el objeto pueda necesitar antes de ser usado.
</para>
<note>
<simpara>
Los constructores padres no son llamados implícitamente si la clase hija define
un constructor. Para ejecutar un constructor padre, se requiere invocar a
<function>parent::__construct</function> desde el constructor hijo.
Si el hijo no define un constructor, entonces se puede heredar de la clase
madre como un método de clase normal (si no fue declarada como
privada).
</simpara>
</note>
<example>
<title>Utilización de nuevos constructores unificados</title>
<programlisting role="php">
<![CDATA[
<?php
class BaseClass {
function __construct() {
print "En el constructor BaseClass\n";
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct();
print "En el constructor SubClass\n";
}
}
class OtherSubClass extends BaseClass {
// heredando el constructor BaseClass
}
// En el constructor BaseClass
$obj = new BaseClass();
// En el constructor BaseClass
// En el constructor SubClass
$obj = new SubClass();
// En el constructor BaseClass
$obj = new OtherSubClass();
?>
]]>
</programlisting>
</example>
<para>
A diferencia de otros métodos, <link linkend="object.construct">__construct()</link>
is exempt from the usual
<link linkend="language.oop.lsp">signature compatibility rules</link>
when being extended.
</para>
<para>
Constructors are ordinary methods which are called during the instantiation of their
corresponding object. As such, they may define an arbitrary number of arguments, which
may be required, may have a type, and may have a default value. Constructor arguments
are called by placing the arguments in parentheses after the class name.
</para>
<example>
<title>Using constructor arguments</title>
<programlisting role="php">
<![CDATA[
<?php
class Point {
protected int $x;
protected int $y;
public function __construct(int $x, int $y = 0) {
$this->x = $x;
$this->y = $y;
}
}
// Pass both parameters.
$p1 = new Point(4, 5);
// Pass only the required parameter. $y will take its default value of 0.
$p2 = new Point(4);
// With named parameters (as of PHP 8.0):
$p3 = new Point(y: 5, x: 4);
?>
]]>
</programlisting>
</example>
<para>
If a class has no constructor, or the constructor has no required arguments, the parentheses
may be omitted.
</para>
<sect3>
<title>Old-style constructors</title>
<para>
Prior to PHP 8.0.0, classes in the global namespace will interpret a method named
the same as the class as an old-style constructor. That syntax is deprecated,
and will result in an <constant>E_DEPRECATED</constant> error but still call that function as a constructor.
If both <link linkend="object.construct">__construct()</link> and a same-name method are
defined, <link linkend="object.construct">__construct()</link> will be called.
</para>
<para>
In namespaced classes, or any class as of PHP 8.0.0, a method named
the same as the class never has any special meaning.
</para>
<para>Always use <link linkend="object.construct">__construct()</link> in new code.
</para>
</sect3>
<sect3 xml:id="language.oop5.decon.constructor.promotion">
<title>Constructor Promotion</title>
<para>
As of PHP 8.0.0, constructor parameters may also be promoted to correspond to an
object property. It is very common for constructor parameters to be assigned to
a property in the constructor but otherwise not operated upon. Constructor promotion
provides a short-hand for that use case. The example above could be rewritten as the following.
</para>
<example>
<title>Using constructor property promotion</title>
<programlisting role="php">
<![CDATA[
<?php
class Point {
public function __construct(protected int $x, protected int $y = 0) {
}
}
]]>
</programlisting>
</example>
<para>
When a constructor argument includes a visibility modifier, PHP will interpret it as
both an object property and a constructor argument, and assign the argument value to
the property. The constructor body may then be empty or may contain other statements.
Any additional statements will be executed after the argument values have been assigned
to the corresponding properties.
</para>
<para>
Not all arguments need to be promoted. It is possible to mix and match promoted and not-promoted
arguments, in any order. Promoted arguments have no impact on code calling the constructor.
</para>
<note>
<para>
Object properties may not be typed <type>callable</type> due to engine ambiguity that would
introduce. Promoted arguments, therefore, may not be typed <type>callable</type> either. Any
other <link linkend="language.types.declarations">type declaration</link> is permitted, however.
</para>
</note>
<note>
<para>
<!-- This should be linked once attributes are documented. -->
Attributes placed on a promoted constructor argument will be replicated to both the property
and argument.
</para>
</note>
</sect3>
<sect3 xml:id="language.oop5.decon.constructor.static">
<title>Static creation methods</title>
<para>
PHP only supports a single constructor per class. In some cases, however, it may be
desirable to allow an object to be constructed in different ways with different inputs.
The recommended way to do so is by using static methods as constructor wrappers.
</para>
<example>
<title>Using static creation methods</title>
<programlisting role="php">
<![CDATA[
<?php
class Product {
private ?int $id;
private ?string $name;
private function __construct(?int $id = null, ?string $name = null) {
$this->id = $id;
$this->name = $name;
}
public static function fromBasicData(int $id, string $name): static {
$new = new static($id, $name);
return $new;
}
public static function fromJson(string $json): static {
$data = json_decode($json);
return new static($data['id'], $data['name']);
}
public static function fromXml(string $xml): static {
// Put your own logic here.
$data = convert_xml_to_array($xml);
$new = new static();
$new->id = $data['id'];
$new->name = $data['name'];
return $new;
}
}
$p1 = Product::fromBasicData(5, 'Widget');
$p2 = Product::fromJson($some_json_string);
$p3 = Product::fromXml($some_xml_string);
]]>
</programlisting>
</example>
<para>
The constructor may be made private or protected to prevent it from being called externally.
If so, only a static method will be able to instantiate the class. Because they are in the
same class definition they have access to private methods, even if not of the same object
instance. The private constructor is optional and may or may not make sense depending on
the use case.
</para>
<para>
The three public static methods then demonstrate different ways of instantiating the object.
</para>
<simplelist>
<member><code>fromBasicData()</code> takes the exact parameters that are needed, then creates the
object by calling the constructor and returning the result.</member>
<member><code>fromJson()</code> accepts a JSON string and does some pre-processing on it itself
to convert it into the format desired by the constructor. It then returns the new object.</member>
<member><code>fromXml()</code> accepts an XML string, preprocesses it, and then creates a bare
object. The constructor is still called, but as all of the parameters are optional the method
skips them. It then assigns values to the object properties directly before returning the result.</member>
</simplelist>
<para>
In all three cases, the <code>static</code> keyword is translated into the name of the class the code is in.
In this case, <code>Product</code>.
</para>
</sect3>
</sect2>
<sect2 xml:id="language.oop5.decon.destructor">
<title>Destructor</title>
<methodsynopsis xml:id="object.destruct">
<type>void</type><methodname>__destruct</methodname>
<void />
</methodsynopsis>
<para>
PHP posee un concepto de destructor similar al de otros
lenguajes orientados a objetos, tal como C++. El método destructor
será llamado tan pronto como no hayan otras referencias a un objeto
determinado, o en cualquier otra circunstancia de finalización.
</para>
<example>
<title>Ejemplo de Destructor</title>
<programlisting role="php">
<![CDATA[
<?php
class MyDestructableClass
{
function __construct() {
print "En el constructor\n";
}
function __destruct() {
print "Destruyendo " . __CLASS__ . "\n";
}
}
$obj = new MyDestructableClass();
]]>
</programlisting>
</example>
<para>
Como los constructores, los destructores padre no serán llamados
implícitamente por el motor. Para ejecutar un destructor padre, se
deberá llamar explícitamente a <function>parent::__destruct</function>
en el interior del destructor. También como los constructores, una clase child
puede heredar el destructor de los padres si no implementa uno propio.
</para>
<para>
El destructor será invocado aún si la ejecución del script es detenida
usando <function>exit</function>. Llamar a <function>exit</function> en un
destructor evitará que se ejecuten las rutinas restantes de finalización.
</para>
<note>
<para>
Los destructores invocados durante la finalización del script tienen
los headers HTTP ya enviados. El directorio de trabajo en la fase de
finalización del script puede ser diferente con algunos SAPIs (por ej., Apache).
</para>
</note>
<note>
<para>
Intentar lanzar una excepción desde un destructor (invocado en la finalización
del script) causa un error fatal.
</para>
</note>
</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
-->