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
|
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision: 1.8 $ -->
<chapter id="language.references">
<title>Les références</title>
<sect1 id="language.references.whatare">
<title>Qu'est ce qu'une référence?</title>
<simpara>
En PHP, les références sont destinées à
appeler le contenu d'une variable avec un autre nom. Ce n'est pas
comme en C : ici, les références sont des alias dans
la table des symboles. Le nom de la variable et son contenu ont des
noms différents, ce qui fait que l'on peut donner
plusieurs noms au même contenu. On peut faire
l'analogie avec les fichiers sous Unix, et leur nom de
fichier : les noms des variables sont les entrées dans un
repertoire, tandis que le contenu de la variable est le contenu
même du fichier. Faire des références en PHP
revient alors à faire des liens sous Unix.
</simpara>
</sect1>
<sect1 id="language.references.whatdo">
<title>Que font les références ?</title>
<para>
Les références vous permettent de faire pointer
deux variables sur le même contenu. Par exemple, lorsque
vous faites :
<informalexample>
<programlisting role="php">
<?php
$a =& $b
?>
</programlisting>
</informalexample>
cela signifie que <varname>$a</varname> et <varname>$b</varname>
pointent sur la même variable.
<note>
<para>
<varname>$a</varname> et <varname>$b</varname> sont complètement
égales ici : ce n'est pas <varname>$a</varname> qui pointe sur
<varname>$b</varname>, ou vice versa. C'est bien <varname>$a</varname>
et <varname>$b</varname> qui pointent sur le même contenu.
</para>
</note>
La même syntaxe peut être utilisée avec les fonctions qui
retournent des références, et avec l'opérateur
<literal>new</literal> (PHP 4.0.4 et plus récent):
<informalexample>
<programlisting role="php">
<?php
$bar =& new fooclass();
$foo =& find_var ($bar);
?>
</programlisting>
</informalexample>
</para>
<note>
<para>
A moins d'utiliser la syntaxe ci-dessus, le résultat de
<literal>$bar = new fooclass()</literal> ne sera pas la même
variable que <literal>$this</literal> dans le constructeur, ce qui
signifie que si vous avez utilisé la référence
<literal>$this</literal> dans le constructeur, vous devez assigner la
référence, ou bien obtenir deux objets différents.
</para>
</note>
<para>
Le deuxième intérêt des références est de
pouvoir passer des variables par référence. On
réalise ceci en faisant pointer des variables locales vers
le contenu des variables de fonction. Exemple :
<informalexample>
<programlisting role="php">
<?php
function foo(&$var) {
$var++;
}
$a=5;
foo($a);
?>
</programlisting>
</informalexample>
<varname>$a</varname> vaut 6. Cela provient du fait que dans la fonction
<varname>foo</varname>, la variable <varname>$var</varname> pointe sur
le même contenu que <varname>$a</varname>. Voir aussi les explications
détaillées dans
<link linkend="language.references.pass">passage par
référence</link>.
</para>
<simpara>
Le troisième intérêt des références est de
<link linkend="language.references.return">retourner des valeurs par
référence</link>.
</simpara>
</sect1>
<sect1 id="language.references.arent">
<title>Ce que les références ne sont pas</title>
<para>
Comme précisé ci-dessus, les références ne
sont pas des pointeurs. Cela signifie que le script suivant ne fera pas
ce à quoi on peut s'attendre :
<informalexample>
<programlisting role="php">
<?php
function foo(&$var) {
$var =& $GLOBALS["baz"];
}
foo($bar);
?>
</programlisting>
</informalexample>
</para>
<simpara>
Il va se passer que <varname>$var</varname> dans foo() sera lié
à <varname>$bar</varname>, mais il sera aussi relié à
<varname>$GLOBALS["baz"]</varname>. Il n'y a pas moyen de lier
<varname>$bar</varname> à quelque chose d'autre en utilisant
le mécanisme de référence, car <varname>$bar</varname>
n'est pas accessible dans la fonction foo() (certes, il est
représenté par <varname>$var</varname> et
<varname>$var</varname> possède la même valeur, mais n'est pas
relié par la table des symboles).
</simpara>
</sect1>
<sect1 id="language.references.pass">
<title>Passage par référence</title>
<para>
Vous pouvez passer des variables par référence, de
manière à ce que la fonction modifie ses arguments. La
syntaxe est la suivante :
<informalexample>
<programlisting role="php">
<?php
function foo(&$var) {
$var++;
}
$a=5;
foo ($a);
// $a vaut 6 maintenant
?>
</programlisting>
</informalexample>
Notez qu'il n'y a pas de signe de référence dans l'appel de la
fonction, uniquement sur sa définition. La définition de la
fonction est suffisante pour passer correctement des arguments par
référence.
</para>
<para>
Les objets suivants peuvent être passés par
référence :
<itemizedlist>
<listitem>
<simpara>
Une variable, i.e. <literal>foo($a)</literal>
</simpara>
</listitem>
<listitem>
<simpara>
Un nouvel objet, i.e. <literal>foo(new foobar())</literal>
</simpara>
</listitem>
<listitem>
<para>
Une référence, retournée par une fonction :
<informalexample>
<programlisting role="php">
<?php
function &bar() {
$a = 5;
return $a;
}
foo(bar());
?>
</programlisting>
</informalexample>
Voir aussi des détails dans
<link linkend="language.references.return">retourner des
références</link>.
</para>
</listitem>
</itemizedlist>
</para>
<para>
Toutes les autres expressions ne doivent pas être passées par
référence, car le résultat sera indéfini. Par
exemple, les passages par référence suivants sont invalides :
<informalexample>
<programlisting role="php">
<?php
function bar() // Notez l'absence de &
{
$a = 5;
return $a;
}
foo(bar);
foo($a = 5) // Expression, pas une variable
foo(5) // Constante, pas une variable
?>
</programlisting>
</informalexample>
Ces fonctionnalités sont valables à partir de PHP 4.0.4.
</para>
</sect1>
<sect1 id="language.references.return">
<title>Retourner des références</title>
<para>
Retourner des références est toujours utile lorsque vous
voulez utiliser une fonction pour savoir à quoi est liée
une variable. Lorsque vous retournez une variable par paramètre,
utilisez le code suivant
<informalexample>
<programlisting role="php">
<?php
function &find_var($param) {
// ...code...
return $found_var;
}
$foo =& find_var ($bar);
$foo->x = 2;
?>
</programlisting>
</informalexample>
Dans cet exemple, la propriété de l'objet est retournée
dans <varname>find_var</varname> et lui sera affectée, et non
pas à la copie, comme cela sera le cas avec une syntaxe par
référence.
</para>
<note>
<simpara>
Contrairement au passage de paramètre, vous devez utiliser
<literal>&</literal> aux deux endroits, à la fois pour
indiquer que vous retournez par référence (pas une
copie habituelle), et pour indiquer que vous assignez aussi par
référence (pas la copie habituelle).
</simpara>
</note>
</sect1>
<sect1 id="language.references.unset">
<title>Détruire une référence</title>
<para>
Lorsque vous détruisez une référence, vous ne
faites que casser le lien entre le nom de la variable et son contenu.
Cela ne signifie pas que le contenu est détruit. Par exemple,
<informalexample>
<programlisting role="php">
<?php
$a = 1;
$b =& $a;
unset ($a);
?>
</programlisting>
</informalexample>
Cet exemple ne détruira pas <varname>$b</varname>, mais juste
<varname>$a</varname>.
</para>
<simpara>
Encore une fois, on peut comparer cette action avec la fonction
unlink d'Unix.
</simpara>
</sect1>
<sect1 id="language.references.spot">
<title>Repérer une référence</title>
<simpara>
De nombreuses syntaxes de PHP sont implémentées via le
mécanisme de référence, et tout ce qui a
été vu concernant les liaisons entre variables
s'applique à ces syntaxes. Par exemple, le passage et
le retour d'arguments par référence.
Quelques autres exemples de syntaxes :
</simpara>
<sect2 id="references.global">
<title>Références globales</title>
<para>
Lorsque vous déclarez une variable <command>global $var</command>,
vous créez en fait une référence sur une variable
globale. Ce qui signifie que
<informalexample>
<programlisting role="php">
<?php
$var =& $GLOBALS["var"];
?>
</programlisting>
</informalexample>
</para>
<simpara>
Et que, si vous détruisez la variable <varname>$var</varname>,
la variable globale ne sera pas détruite.
</simpara>
</sect2>
<sect2 id="references.this">
<title><literal>$this</literal></title>
<simpara>
Dans une méthode d'objet <varname>$this</varname> est
toujours une référence sur l'objet courant.
</simpara>
</sect2>
</sect1>
</chapter>
<!-- 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:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->
|
