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
|
<?xml version="1.0" encoding="iso-8859-1"?>
<chapter id="language.expressions">
<title>Expresiones</title>
<simpara>
Las expresiones son la piedra angular de PHP. En PHP, casi cualquier
cosa que escribes es una expresión. La forma más simple y ajustada de
definir una expresión es "cualquier cosa que tiene un valor".</simpara>
<simpara>
Las formas más básicas de expresiones son las constantes y las variables.
Cuando escribes "$a = 5", estás asignando '5' a $a. '5', obviamente,
tiene el valor 5 o, en otras palabras '5' es una expresión con el valor 5
(en este caso, '5' es una constante entera).</simpara>
<simpara>
Después de esta asignación, esperarás que el valor de $a sea 5
también, de manera que si escribes $b = $a, esperas que se comporte
igual que si escribieses $b = 5. En otras palabras, $a es una expresión
también con el valor 5. Si todo va bien, eso es exactamente lo que pasará.
</simpara>
<para>
Las funciones son un ejemplo algo más complejo de expresiones. Por ejemplo,
considera la siguiente función:
<informalexample>
<programlisting>
function foo () {
return 5;
}
</programlisting>
</informalexample></para>
<simpara>
Suponiendo que estés familiarizado con el concepto de funciones (si no lo estás
échale un vistazo al capítulo sobre funciones), asumirás que teclear
<literal>$c = foo()</literal> es esencialmente lo mismo que escribir
<literal>$c = 5</literal>, y has acertado. Las funciones son expresiones
que valen el valor que retornan. Como foo() devuelve 5, el valor de la expresión 'foo()'
es 5. Normalmente las funciones no devuelven un valor fijo, sino que
suele ser calculado.</simpara>
<simpara>
Desde luego, los valores en PHP no se limitan a enteros, y lo más normal es
que no lo sean. PHP soporta tres tipos escalares: enteros, punto flotante y
cadenas (los tipos escalares son aquellos cuyos valores no pueden 'dividirse'
en partes menores, no como los arrays, por ejemplo).
PHP también soporta dos tipos compuestos (no escalares): arrays y objetos.
Se puede asignar cada uno de estos tipos de valor a variables o bien retornarse
de funciones, sin ningún tipo de limitación.</simpara>
<simpara>
Hasta aquí, los usuarios de PHP/FI 2 no deberían haber notado ningún cambio.
Sin embargo, PHP lleva las expresiones mucho más allá, al igual que otros lenguajes.
PHP es un lenguaje orientado a expresiones, en el sentido de que casi todo es una
expresión. Considera el ejemplo anterior '$a = 5'. Es sencillo ver que
hay dos valores involucrados, el valor de la constante entera '5', y el valor de $a
que está siendo actualizado también a 5. Pero la verdad es que hay un valor
adicional implicado aquí, y es el valor de la propia asignación.
La asignación misma se evalúa al valor asignado, en este caso 5.
En la práctica, quiere decir que '$a = 5', independientemente de lo que hace,
es una expresión con el valor 5. De esta manera, escribir algo como
'$b = ($a = 5)' es como escribir '$a = 5; $b = 5;' (un punto y coma
marca el final de una instrucción). Como las asignaciones se evalúan
de derecha a izquierda, puedes escribir también '$b = $a = 5'.</simpara>
<simpara>
Otro buen ejemplo de orientación a expresiones es el pre y post incremento
y decremento. Los usuarios de PHP/FI 2 y los de otros muchos
lenguajes les sonará la notación variable++ y variable--. Esto son las
operaciones de incremento y decremento. En PHP/FI 2, la instrucción '$a++'
no tiene valor (no es una expresión), y no puedes asignarla o usarla
de ningún otro modo.
PHP mejora las características del incremento/decremento haciéndolos también
expresiones, como en C. En PHP, como en C, hay dos tipos de incremento -
pre-incremento y post-incremento. Ambos, en esencia, incrementan la variable
y el efecto en la variable es idéntico. La diferencia radica en el valor
de la propia expresion incremento.
El preincremento , escrito '++$variable', se evalúa al valor incrementado
(PHP incrementa la variable antes de leer su valor, de ahí el nombre 'preincremento').
El postincremento, escrito '$variable++', se evalúa al valor original de
$variable antes de realizar el incremento (PHP incrementa la variable
después de leer su valor, de ahí el nombre 'postincremento').</simpara>
<simpara>
Un tipo muy corriente de expresiones son las expresiones de comparación.
Estas expresiones se evalúan a 0 o 1, significando FALSO (&false;) o
CIERTO (&true;), respectivamente. PHP soporta > (mayor que), >= (mayor
o igual que), == (igual que), != (distinto), < (menor que) y <=
(menor o igual que). Estas expresiones se usan frecuentemente dentro
de la ejecución condicional como la instrucción <literal>if</literal>.</simpara>
<simpara>
El último tipo de expresiones que trataremos, es la combinación operador-asignación.
Ya sabes que si quieres incrementar $a en 1, basta con escribir '$a++' o ++$a'.
Pero qué pasa si quieres añadir más de 1, por ejemplo 3?
Podrías escribir '$a++' múltiples veces, pero no es una forma de hacerlo
ni eficiente ni cómoda. Una práctica mucho más corriente es escribir
'$a = $a + 3'. '$a + 3' se evalúa al valor de $a más 3, y se asigna de nuevo
a $a, lo que resulta en incrementar $a en 3. En PHP, como en otros lenguajes
como C, puedes escribir esto de una forma más concisa, que con el tiempo
será más clara y también fácil de entender. Añadir 3 al valor actual
de $a se puede escribir como '$a += 3'. Esto quiere decir exactamente
"toma el valor de $a, súmale 3, y asígnalo otra vez a $a".
Además de ser más corto y claro, también resulta en una ejecución más rápida.
El valor de '$a += 3', como el valor de una asignación normal y corriente, es
el valor asignado. Ten en cuenta que NO es 3, sino el valor combinado de $a más 3
(ése es el valor asignado a $a). Cualquier operación binaria puede ser usada
en forma de operador-asignación, por ejemplo '$a -= 5' (restar 5 del valor de $a),
'$b *= 7' (multiplicar el valor de $b por 5), etc.</simpara>
<para>
Hay otra expresión que puede parecer extraña si no la has visto en otros lenguaes,
el operador condicional ternario:
<informalexample><programlisting>
$first ? $second : $third
</programlisting></informalexample>
Si el valor de la primera subexpresión es verdadero (distinto de cero),
entonces se evalúa la segunda subexpresión, si no, se evalúa la tercera y
ése es el valor.</para>
<para>
El siguiente ejemplo te ayudará a comprender un poco mejor el pre y post incremento
y las expresiones en general:
<informalexample>
<programlisting>
function double($i) {
return $i*2;
}
$b = $a = 5; /* asignar el valor cinco a las variables $a y $b */
$c = $a++; /* postincremento, asignar el valor original de $a (5) a $c */
$e = $d = ++$b; /* preincremento, asignar el valor incrementado de $b (6) a
$d y a $e */
/* en este punto, tanto $d como $e son iguales a 6 */
$f = double($d++); /* asignar el doble del valor de $d <emphasis>antes</emphasis>
del incremento, 2*6 = 12 a $f */
$g = double(++$e); /* asignar el doble del valor de $e <emphasis>después</emphasis>
del incremento, 2*7 = 14 a $g */
$h = $g += 10; /* primero, $g es incrementado en 10 y termina valiendo 24.
después el valor de la asignación (24) se asigna a $h,
y $h también acaba valiendo 24. */
</programlisting></informalexample></para>
<simpara>
Al principio del capítulo hemos dicho que describiríamos los distintos
tipos de instrucciones y, como prometimos, las expresiones pueden ser
instrucciones. Sin embargo, no todas las expresiones son instrucciones.
En este caso, una instrucción tiene la forma 'expr' ';', es decir,
una expresión seguida de un punto y coma. En '$b=$a=5;', $a=5 es una
expresión válida, pero no es una instrucción en sí misma. Por otro lado
'$b=$a=5:' sí es una instrucción válida.</simpara>
<simpara>
Una última cosa que vale la pena mencionar, es el valor booleano de las
expresiones. En muchas ocasiones, principalmente en condicionales y bucles,
no estás interesado en el valor exacto de la expresión, sino únicamente si
es CIERTA (&true;) o FALSA (&false;) (PHP no tiene un tipo booleano específico).
El valor de verdad de las expresiones en PHP se calcula de forma similar a perl.
Cualquier valor numérico distinto de cero es CIERTO (&true;), cero es FALSO (&false;).
Fíjate en que los valores negativos son distinto de cero y considerados CIERTO (&true;)!
La cadena vacía y la cadena "0" son FALSO (&false;); todas las demás cadenas son &true;.
Con los tipos no escalares (arrays y objetos) - si el valor no contiene elementos
se considera FALSO (&false;), en caso contrario se considera CIERTO (&true;).</simpara>
<simpara>
PHP te brinda una completa y potente implementación de expresiones, y
documentarla enteramente está más allá del objetivo de ete manual.
Los ejemplos anteriores, deberían darte una buena idea de qué son las
expresiones y cómo construir expresiones útiles. A lo largo del resto
del manual, escribiremos <replaceable>expr</replaceable> para indicar
una expresión PHP válida.</simpara>
</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:
-->
|
