PHP  
downloads | documentation | faq | getting help | | php.net sites | links 
search for in the  
previousConstantes PredefinidasOperadoresnext
Last updated: Thu, 18 Jul 2002
view this page in Printer friendly version | English | Chinese | Czech | Dutch | Finnish | French | German | Hungarian | Italian | Japanese | Korean | Polish | Romanian | Russian | Spanish | Turkish

Cap�tulo 10. Express�es

Express�es s�o as pe�as de constru��o mais importantes do PHP. No PHP, quase tudo o que voc� escreve s�o express�es. A maneira mais simples e ainda mais precisa de definir uma express�o � "tudo o que tem um valor".

As formas mais b�sicas de express�es s�o constantes e vari�veis. Quando voc� digita "$a = 5", voc� est� atribuindo '5' para $a. '5', obviamente, tem o valor 5, ou, em outras palavras, '5' � uma express�o com o valor 5 (neste caso, '5' � uma constante inteira).

Depois desta atribui��o, voc� pode esperar que o valor de $a seja 5 tamb�m, assim se voc� escrever $b = $a, voc� pode esperar que $b se comporte da mesma forma que se voc� escrevesse $b = 5. Em outras palavras, $a � uma express�o com valor 5 tamb�m. Se tudo funcionou bem, isto � exatamente o que acontecer�.

Exemplos ligeiramente mais complexos para express�es s�o as fun��es. Por exemplo, considere a seguinte fun��o:

function foo ()
{
    return 5;
}

Assumindo que voc� est� familiarizado com o conceito de fun��es (se n�o estiver, d� uma olhada no cap�tulo sobre fun��es), voc� pode assumir que digitar $c = foo() � essencialmente a mesma coisa que escrever $c = 5, e voc� est� certo. Fun��es s�o express�es com o valor igual ao seu valor de retorno. Como foo() retorna 5, o valor da express�o 'foo()' � 5. Geralmente, as fun��es n�o retornam apenas um valor est�tico, mas computam algo.

Obviamente, os valores em PHP n�o t�m que ser inteiros, e muito freq�entemente eles n�o s�o. O PHP suporta tr�s tipos de valores escalares: valores inteiros, valores de ponto flutuante e valores de string (valores escalares s�o valores que voc� n�o pode quebrar em peda�os menores, diferente de matrizes, por exemplo). O PHP tamb�m suporta dois tipos compostos (n�o-escalares): matrizes e objetos. Cada um destes tipos de valor podem ser atribu�dos a vari�veis ou retornadas de fun��es.

At� agora, os usu�rios de PHP/FI 2 n�o sentiriam qualquer mudan�a. Por�m, o PHP traz express�es bem mais novas, da mesma forma que muitas outras linguagens. O PHP � uma linguagem orientada a express�es, no sentido de que quase tudo s�o express�es. Considere o exemplo com o qual j� lidamos, '$a = 5'. � f�cil ver que h� dois valores envolvidos aqui, o valor da constante inteira '5', e o valor de $a que est� sendo atualizado para 5 tamb�m. Mas a verdade � que h� um valor adicional envolvido, e que � o pr�prio valor da atribui��o. A pr�pria atribui��o � avaliada com o valor atribu�do, neste caso 5. Na pr�tica, significa que '$a = 5', independente do que fa�a, � uma express�o com o valor 5. Portanto, escrever algo como '$b = ($a = 5)' � como escrever '$a = 5; $b = 5;' (um ponto-e-v�rgula marca o fim do comando). Como atribui��es s�o analisadas da direita para a esquerda, voc� tamb�m pode escrever '$b = $a = 5'.

Outro bom exemplo de orienta��o de express�o � o pr� e o p�s-incremento e decremento. Usu�rios de PHP/FI 2 e muitas outras linguagens podem estar familiarizados com a nota��o de vari�vel++ e vari�vel--. Estes s�o os operadores de incremento e decremento. No PHP/FI 2, o comando '$a++' n�o tem valor (n�o � uma express�o), e portanto voc� n�o pode atribuir desta forma ou us�-la de jeito nenhum. O PHP evoluiu a capacidade de incremento/decremento criando estas express�es tamb�m, como em C. Em PHP, como em C, h� dois tipos de incremento - pr�-incremento e p�s-incremento. Tanto o pr�-incremento quanto o p�s-incremento, essencialmente, incrementam vari�veis, e o efeito sobre a vari�vel � id�ntico. A diferen�a � com o valor da express�o de incremento. O pr�-incremento, que � escrito '++$variavel', � avaliado como o valor de incremento (o PHP incrementa a vari�vel antes de ler seu valor, por isso o nome pr�-incremento). O p�s-incremento, que � escrito '$variavel++' � avaliado como o valor original da vari�vel, antes de ser incrementada (o PHP incrementa a vari�vel depois de ler seu valor, por isso o nome 'p�s-incremento').

Um tipo muito comum de express�o s�o express�es de compara��o. Estas express�es s�o avaliadas como 0 ou 1, significando FALSE ou TRUE, respectivamente. O PHP suporta > (maior que), >= (maior ou igual), == (igual), != (diferente), < (menor que) e <=(menor ou igual). Estas express�es s�o usadas mais freq�entemente dentro de instru��es condicionais, como em comandos if.

O �ltimo exemplo de express�es com que n�s vamos lidar aqui s�o as express�es combinadas operador-atribui��o. Voc� j� sabe que se voc� quer incrementar $a de 1, voc� s� precisa escrever '$a++' ou '++$a'. Mas e se voc� quiser somar mais que um a ele, por exemplo 3? Voc� poderia escrever '$a++' v�rias vezes, mas esta obviamente n�o � uma forma muito eficiente ou confort�vel. Uma pr�tica muito mais comum � escrever '$a = $a + 3'. '$a + 3' � avaliada como o valor de $a mais 3, e � atribu�do de volta a $a, que resulta em incrementar $a de 3. Em PHP, como em v�rias outras linguagens como o C, voc� pode escrever isto de uma forma mais curta, que com o tempo se torna mais limpa e r�pida de se entender, tamb�m. Somar 3 ao valor corrente de $a pode ser escrito '$a +=3'. Isto significa exatamente "pegue o valor de $a, some 3 a ele, e atribua-o de volta a $a." Al�m de ser mais curto e mais limpo, isto tamb�m resulta em execu��o mais r�pida. O valor de '$a += 3', como o valor de uma atribui��o regular, � o valor atribu�do. Note que N�O � 3, mas o valor combinado de $a mais 3 (este � o valor que � atribu�do a $a). Qualquer operador de dois par�metros pode ser usado neste modo operador-atribui��o, por exemplo '$a -= 5' (subtrai 5 do valor de $a), '$b *= 7' (multiplica o valor de $b por 7), etc.

H� mais uma express�o que podem parecer estranha se voc� n�o a viu em outras linguagens, o operador condicional tern�rio:

$primeira ? $segunda : $terceira

Se o valor da primeira sub-express�o � verdadeiro (TRUE, n�o-zero), ent�o a segunda sub-express�o � avaliada, e este � o resultado da express�o condicional. Caso contr�rio, a terceira sub-express�o � avaliada e este � o valor.

O seguinte exemplo deve ajud�-lo a entender um pouco melhor pr� e p�s-incremento e express�es em geral:

function double($i)
{
    return $i*2;
}
$b = $a = 5;        /* atribui o valor cinco �s vari�veis $a e $b */
$c = $a++;          /* p�s-incremento, atribui o valor original de $a
                       (5) para $c */
$e = $d = ++$b;     /* pr�-incremento, atribui o valor incrementado de
                       $b (6) a $d e $e */

/* neste ponto, tanto $d quanto $e s�o iguais a 6 */

$f = double($d++);  /* atribui o dobro do valor de $d <emphasis>antes</emphasis>
                       do incremento, 2*6 = 12 a $f */
$g = double(++$e);  /* atribui o dobro do valor de $e <emphasis>depois</emphasis>
                       do incremento, 2*7 = 14 a $g */
$h = $g += 10;      /* primeiro, $g � incrementado de 10 e termina com o valor
                       24. o valor da atribui��o (24) � ent�o atribu�do
                       a $h, e $h termina com o valor 24 tamb�m. */

No come�o do cap�tulo, n�s dissemos que descrever�amos os v�rios tipos de comandos, e como prometido, express�es podem ser comandos. Por�m, nem toda express�o � um comando. Neste caso, um comando tem a forma 'expr' ';', ou seja, uma express�o seguida de ponto-e-v�rgula. E '$b=$a=5;', $a=5 � uma express�o v�lida, mas n�o � um comando por si s�. '$b=$a=5;' por�m � um comando v�lido.

Uma �ltima coisa que vale mencionar � o valor-verdade de express�es. Em muitos eventos, principalmente em instru��es condicionais e loops, voc� n�o est� interessado no valor espec�fico da express�o, mas somente se ela significa TRUE ou FALSE (o PHP n�o tem um tipo booleano dedicado). As constantes TRUE e FALSE (insensitivas ao caso) s�o seus dois valores booleanos poss�veis. As vezes uma express�o � automaticamente convertida para um booleano. Veja a se��o sobre type-casting para detalhes de como isso � feito.

O PHP fornece uma implementa��o completa e poderosa de express�es, e a completa documenta��o dela vai al�m do escopo deste manual. Os exemplos acima devem dar a voc� uma boa id�ia sobre o que s�o as express�es e como voc� pode construir express�es �teis. Atrav�s do restante do manual n�s escreveremos expr ou expressao para indicar qualquer express�o PHP v�lida.

User Contributed Notes
Express�es
add a note about notes

29-Sep-1999 08:43

boolean expressions short-circuit, currently.
If boolean expression short-circuiting is a feature rather than a
coincidence, it should probably be added here... Unless I missed it.


24-Nov-2000 05: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' ) ;


23-Jan-2001 06:23

try this

$a = "-1";
$a++;
echo $a;

this prints -2 as a result

to be sure you get what you wanted to get just do this

$a = "-2"
$b = (integer)($a)
and now $b will behave

somebody mentioning strict typing?


12-Mar-2001 05: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.


13-Sep-2001 05:57

As reported previously, PHP boolean operators seem to short-circuit. What
if you want them to do not short-circuit?

Exemple:
$result_of = f1() and f2() and f3()

suppose you want to run f3 even when f1 already returned false.

If you perform some silly tests such as:
echo true + true;
you'll see that indeed, true=1 and false=0 and true+true = 2 (ok. this
_is_ silly!)

Anyway, the point is: you could use * (multiplication) instead of 'and',
to get a not short-circuiting 'and' and + (sum) to get a not
short-circuiting or.


[]s
MaCa

08-Mar-2002 07:20
I found this worked nicely:

echo $var ? "yup" : "nope";

This doesnt work:

echo $var ? "yup";

you need to go:

echo $var ? "yup" : "";

-- there is not space in "", but it may appear that way above


25-May-2002 09: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.


27-May-2002 08:30

I actually find the short-circuit aspect of expressions useful.  As in:
if ($foo AND Bar()) { echo "OK"; }

where Bar() should only be run if $foo is set, and OK should only be
printed if both evaluate to TRUE.

My only concern is if this is the intended result in PHP.  In other words,
if I code this way will it fail under later releases of PHP?


30-May-2002 01:30

Regarding short-circuit expression, it is a frozen feature, not a
coincidence. At least, that's what I read from the URL below.



Now, I sometimes feel the need for BNF-written document to explain PHP
syntax to others...does anyone know where I can find one?


16-Jul-2002 07:47

If you need to do something like make sure you dont say '1 days' try this

echo $being-$today.' day'.($begin-$today===1?'':'s').' untill XYZ';


17-Jul-2002 05: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!).

add a note about notes
previousConstantes PredefinidasOperadoresnext
Last updated: Thu, 18 Jul 2002
show source | credits | stats | mirror sites:  
Copyright © 2001, 2002 The PHP Group
All rights reserved.
This mirror generously provided by:
Last updated: Sat Jul 20 20:16:23 2002 CEST