CapÃtulo 14. Expresiones

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".

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 Ã³, en otras palabras '5' es una expresiÃ³n con el valor 5 (en este caso, '5' es una constante entera).

DespuÃ©s de esta asignaciÃ³n, se espera que el valor de $a sea 5 tambiÃ©n, de manera que si escribes $b = $a, se espera tambiÃ©n 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Ã¡.

Las funciones son un ejemplo algo mÃ¡s complejo de expresiones. Por ejemplo, considera la siguiente funciÃ³n:


<?php

function foo () {

    return 5;

}

?>

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 $c = foo() es esencialmente lo mismo que escribir $c = 5, 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.

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.

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'.

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').

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 VERDADERO (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 if.

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 7), etc.

Hay otra expresiÃ³n que puede parecer extraÃ±a si no la has visto en otros lenguaes, el operador condicional ternario:


<?php

$first ? $second : $third

?>

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.

El siguiente ejemplo te ayudarÃ¡ a comprender un poco mejor el pre y post incremento y las expresiones en general:


<?php

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 antes

                       del incremento, 2*6 = 12 a $f */

$g = double(++$e);  /* asignar el doble del valor de $e despu&eacute;s

                       del incremento, 2*7 = 14 a $g */

$h = $g += 10;      /* primero, $g es incrementado en 10 y termina valiendo 24.

                       despu&eacute;s el valor de la asignaci&oacute;n (24) se asigna a $h, 

                       y $h tambi&eacute;n acaba valiendo 24. */

?>

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.

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 TRUE Ã³ FALSE Las constantes TRUE y FALSE son los dos posibles valores booleanos. Cuando es necesario, una expresiÃ³n se puede transformar automÃ¡ticamente al tipo booleano. Consultar la secciÃ³n sobre type-casting para obtener detalles de como se hace.

PHP brinda una completa y potente implementaciÃ³n de expresiones, y documentarla enteramente estÃ¡ mÃ¡s allÃ¡ del objetivo de este 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 expr para indicar una expresiÃ³n PHP vÃ¡lida.

add a note User Contributed Notes
Expresiones

richard at phase4 dot ie
19-Jan-2006 12:00


Follow up on Martin K. There are no hard and fast rules regarding operator precedence. Newbies should definitely learn them, but if their use results in code that is not easy to read you should use parentheses. The two important things are that it works properly AND is maintainable by you and others.

Martin K
20-Oct-2005 06:28


At 04-Feb-2005 05:13, tom at darlingpet dot com said:

> It's also a good idea to use parenthesis when using something SIMILAR to:

> 

> <?php

> echo (trim($var)=="") ? "empty" : "not empty";

> ?>



No, it's a BAD idea.



All the short-circuiting operators, including the ternary conditional operator, have LOWER precedence than the comparison operators, so they almost NEVER need parentheses around their subexpressions.



Inserting the parentheses suggested above does not change the meaning of the code, but their use misleads inexperienced programmers to expect that things like this will work in a similar manner:



<?php

function my_print($a) { print($a); }

my_print (trim($var)=="") ? "empty" : "not empty";

?>



when of course it doesn't.



Rather than worrying that code doesn't work as expected, simply learn the precedence rules (http://www.php.net/manual/en/http://indices.com.es/language.operators.html) so that one expects the right things.

stochnagara at hotmail dot com
19-Aug-2005 05:06


12345alex at gmx dot net 's case is actually handled by the === operator. That's what he needs.



There is also another widely used function. I call it myself is_nil which is true for NULL,FALSE,array() and '', but not for 0 and "0".



function is_nil ($value) {

 return !$value && $value !== 0 && $value !== '0';

}



Another useful function is "get first argument if it is not empty or get second argument otherwise". The code is:



function def ($value, $defaultValue) {

 return is_nil ($value) ? $defaultValue : $value;

}

12345alex at gmx dot net
14-Aug-2005 07:00


this code:

    print array() == NULL ? "True" : "False";

    print " (" . (array() == NULL) . ")\n";



    $arr = array();

    print array() == $arr ? "True" : "False";

    print " (" . (array() == $arr) . ")\n";



    print count(array()) . "\n";

    print count(NULL) . "\n";



will output (on php4 and php5):

    True (1)

    True (1)

    0

    0



so to decide wether i have NULL or an empty array i will also have to use gettype(). this seems some kind of weird for me, although if is this is a bug, somebody should have noticed it before.



alex

sabinx at gmail dot com
26-Jun-2005 11:25


Pre- and Post-Incrementation, I believe, are important to note and in the correct place. The section deals with the value of an expression. ++$a and $a++ have different values, and both forms have valid uses.



And, because it can be confusing, it is that much more important to note. Although it could be worded better, it does belong.

31-May-2005 12:07


I don't see why it is necessary here to explain pre- and post- incrementing.



This is something that will confuse new users of PHP, even longer time programmers will sometimes miss a the fine details of a construct like that.



If something has a side-effect it should be on a line of it's own, or at least be an expression of it's own and not part of an assignment, condition or whatever.

27-Apr-2005 07:40


($bb || !$bb) 



....2 Be or not 2 to be thats the question ;-)

tom at darlingpet dot com
04-Feb-2005 02:13


Something I've noticed with ternary expressions is if you do something like :



<?= $var=="something" ? "is something" : "not something"; ?>



It will give wacky results sometimes...



So be sure to enclose the ternary expression in parenthesis when ever necessary (such as having multiple expressions or nested ternary expressions)



The above could look like:



<?= ($var=="something") ? "is something" : "not something"; ?>



It's also a good idea to use parenthesis when using something SIMILAR to:



<?php

echo (trim($var)=="") ? "empty" : "not empty";

?>



In some cases other than the <?= ?> example, not placing the entire expression in appropriate parenthesis might yield undesirable results as well.. but I'm not quite sure.

stian at datanerd dot net
25-Feb-2003 02:37


The short-circuit feature is indeed intended, and there are two types of evaluators, those who DO short-circuit, and those who DON'T, || / && and | / & respectively.

The latter method is the bitwise operators, but works great with the usual boolean values ( 0/1 )



So if you don't want short-circuiting, try using the | and & instead.



Read more about the bitwise operators here:

http://www.php.net/manual/en/language.operators.bitwise.php

oliver at hankeln-online dot de
07-Aug-2002 06:06


The short-circuiting IS a feature. It is also available in C, so I suppose the developers won´t remove it in future PHP versions.



It is rather nice to write:



$file=fopen("foo","r") or die("Error!");



Greets,

Oliver

php at cotest dot com
17-Jul-2002 11:08


It should probably be mentioned that the short-circuiting of expressions (mentioned in some of the comments above) is often called "lazy evaluation" (in case someone else searches for the term "lazy" on this page and comes up empty!).

Mattias at mail dot ee
25-May-2002 03:29


A note about the short-circuit behaviour of the boolean operators.



1. if (func1() || func2())

Now, if func1() returns true, func2() isn't run, since the expression

will be true anyway.



2. if (func1() && func2())

Now, if func1() returns false, func2() isn't run, since the expression

will be false anyway.



The reason for this behaviour comes probably from the programming

language C, on which PHP seems to be based on. There the

short-circuiting can be a very useful tool. For example:



int * myarray = a_func_to_set_myarray(); // init the array

if (myarray != NULL && myarray[0] != 4321) // check

    myarray[0] = 1234;



Now, the pointer myarray is checked for being not null, then the

contents of the array is validated. This is important, because if

you try to access an array whose address is invalid, the program

will crash and die a horrible death. But thanks to the short

circuiting, if myarray == NULL then myarray[0] won't be accessed,

and the program will work fine.

yasuo_ohgaki at hotmail dot com
11-Mar-2001 11:14


Manual defines "expression is anything that has value", Therefore, parser will give error for following code.





($val) ? echo('true') : echo('false');


Note: "? : " operator has this syntax  "expr ? expr : expr;"





since echo does not have(return) value and ?: expects expression(value).





However, if function/language constructs that have/return value, such as include(), parser compiles code.





Note: User defined functions always have/return value without explicit return statement (returns NULL if there is no return statement). Therefore, user defined functions are always valid expressions. 


[It may be useful to have VOID as new type to prevent programmer to use function as RVALUE by mistake]





For example,





($val) ? include('true.inc') : include('false.inc');





is valid, since "include" returns value.





The fact "echo" does not return value(="echo" is not a expression), is less obvious to me. 





Print() and Echo() is NOT identical since print() has/returns value and can be a valid expression.

anthony at n dot o dot s dot p dot a dot m dot trams dot com
24-Nov-2000 11:01


The ternary conditional operator is a useful way of avoiding inconvenient if statements.  They can even be used in the middle of a string concatenation, if you use parentheses.  





Example:





if ( $wakka ) {


  $string = 'foo' ;


} else {


  $string = 'bar' ;


}





The above can be expressed like the following:





$string = $wakka ? 'foo' : 'bar' ;





If $wakka is true, $string is assigned 'foo', and if it's false, $string is assigned 'bar'.





To do the same in a concatenation, try:





$string = $otherString . ( $wakka ? 'foo' : 'bar' ) ;

add a note

MANUAL DE PHP

windsurf mercedes camper

CapÃtulo 14. Expresiones

MANUAL DE PHP

windsurf mercedes camper

CapÃ­tulo 14. Expresiones

CapÃtulo 14. Expresiones