expressions.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: f4f96ef8b2a95283c92ea2183fe1dedf06f3ad22 Maintainer: leonardolara Status: ready --><!-- CREDITS: mauricio,geekcom,gabrielsanva,leonardolara -->
 <chapter xml:id="language.expressions" xmlns="http://docbook.org/ns/docbook">
   <title>Expressões</title>
   <simpara>
    Expressões são os blocos 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".
   </simpara>
   <simpara>
    As formas mais básicas de expressões são constantes e variáveis.
    Quando você digita <code>$a = 5</code>, você está atribuindo <code>5</code> dentro de
    <varname>$a</varname>. <code>5</code> obviamente
    tem o valor 5, ou em outras palavras <code>5</code> é uma expressão com o
    valor de 5 (nesse caso <code>5</code> é uma constante inteira).
   </simpara>
   <simpara>
    Depois desta atribuição, você pode esperar que o valor de <varname>$a</varname> seja 5
    também, assim se você escrever <code>$b = $a</code>, você pode esperar que ele se comporte
    da mesma forma que se você escrevesse <code>$b = 5</code>. Em outras palavras, <varname>$a</varname> é uma expressão com
    valor 5 também. Se tudo funcionou bem isto é
    exatamente o que aconteceu.
   </simpara>
   <para>
    Exemplos ligeiramente mais complexos para expressões são as funções. Por exemplo,
    considere a seguinte função:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
function foo ()
{
    return 5;
}
?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    Assumindo que você está familiarizado com o conceito de funções (se não estiver,
    dê uma olhada no capítulo sobre <link
    linkend="language.functions">funções</link>), você pode assumir que digitar
    <code>$c = foo()</code> é essencialmente a mesma coisa que escrever
    <code>$c = 5</code>, e você está certo. Funções são expressões com o valor
    igual ao seu valor de retorno. Como <code>foo()</code>
    retorna 5, o valor da expressão '<code>foo()</code>' é 5. Geralmente,
    as funções não retornam apenas um valor estático, mas computam algo.
   </simpara>
   <simpara>
    Claro, valores em PHP não tem que ser inteiros, e muito comumente
    eles não são. O PHP suporta quatro tipos de valores escalares: valores <type>int</type>
    (inteiros), valores de ponto flutuante (<type>float</type>), valores <type>string</type>
    (caracteres) e valores <type>bool</type> (booleano) (valores escalares são valores que
    você não pode partir em peças menores, diferentemente de matrizes, por exemplo). O PHP também
    suporta dois tipos compostos (não escalar): matrizes e objetos. Cada um desses
    valores podem ser definidos em uma variável ou retornados de uma função.
   </simpara>
   <simpara>
    O PHP leva as expressões muito além, da mesma maneira que muitas outras linguagens
    fazem. 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, <code>$a = 5</code>. É fácil ver que
    há dois valores envolvidos aqui, o valor da constante inteira
    <code>5</code>, e o valor de <varname>$a</varname> que está sendo atualizado para 5
    também. Mas a verdade é que há um valor adicional envolvido
    aqui, 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 <code>$a = 5</code>, independente do que faça,
    é uma expressão com o valor 5. Portanto, escrever algo como
    <code>$b = ($a = 5)</code> é como escrever
    <code>$a = 5; $b = 5;</code> (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 <code>$b = $a = 5</code>.
   </simpara>
   <simpara>
    Outro bom exemplo de orientação de expressão é o pré e
    o pós-incremento e decremento. Usuários de PHP 2 e muitas outras
    linguagens podem estar familiarizados com a notação de <code>variable++</code> e
    <code>variable--</code>. Este são <link linkend="language.operators.increment">
    operadores de incremento e decremento</link>. 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
    as 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 <code>++$variable</code>', é 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 <code>$variable++</code> é avaliado como o valor original de
    <varname>$variable</varname>, antes de ser incrementada (o PHP incrementa a variável
    depois de ler seu valor, por isso o nome 'pós-incremento').
   </simpara>
   <simpara>
    Um tipo muito comum de expressões são expressões de <link
    linkend="language.operators.comparison">comparação</link>.
    Estas expressões avaliam para ser &false; ou &true;. O PHP
    suporta &gt; (maior que), &gt;= (maior ou igual a), == (igual),
    != (diferente), &lt; (menor que) e &lt;= (menor ou igual a).
    A linguagem também suporta um conjunto de operador de equivalência estrita: ===
    (igual a e do mesmo tipo) e !== (diferente de ou não do mesmo tipo).
    Estas expressões são mais comumente usada dentro de execução condicional
    como comandos <code>if</code>.
   </simpara>
   <simpara>
    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 <varname>$a</varname> de 1, você só precisa escrever
    <code>$a++</code> ou <code>++$a</code>.
    Mas e se você quiser somar mais que um a ele, por exemplo 3?
    Você poderia escrever <code>$a++</code> várias vezes, mas esta
    obviamente não é uma forma muito eficiente ou confortável. Uma prática muito
    mais comum é escrever <code>$a =
    $a + 3</code>. <code>$a + 3</code> é avaliada
    como o valor de <varname>$a</varname> mais 3, e é atribuído de volta
    a <varname>$a</varname>, que resulta em incrementar <varname>$a</varname>
    em 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. Somar 3 ao valor corrente de <varname>$a</varname>
    pode ser escrito <code>$a += 3</code>. Isto significa exatamente
    "pegue o valor de <varname>$a</varname>, some 3 a ele, e atribua-o
    de volta a <varname>$a</varname>." Além de ser mais curto e mais
    limpo, isto também resulta em execução mais rápida. O valor de
    <code>$a += 3</code>, como o valor de uma atribuição regular, é
    o valor atribuído. Note que NÃO é 3, mas o valor combinado de
    <varname>$a</varname> mais 3 (este é o valor que
    é atribuído a <varname>$a</varname>). Qualquer operador de dois parâmetros pode ser usado
    neste modo operador-atribuição, por exemplo <code>$a -= 5</code>
    (subtrai 5 do valor de <varname>$a</varname>), <code>$b *= 7</code>
    (multiplica o valor de <varname>$b</varname> por 7), etc.
   </simpara>
   <para>
    Há mais uma expressão que podem parecer estranha se você não a viu em outras linguagens,
    o operador condicional ternário:
   </para>
   <para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$primeira ? $segunda : $terceira
?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <para>
    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.
   </para>
   <para>
    O seguinte exemplo deve ajudá-lo a entender um pouco melhor pré e
    pós-incremento e expressões em geral:
   </para>
   <para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
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 antes
                       do incremento, 2*6 = 12 a $f */
$g = double(++$e);  /* atribui o dobro do valor de $e depois
                       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. */
?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    Algumas expressões podem ser consideradas instruções. Neste
    caso, uma instrução na forma '<code>expr ;</code>' ou seja, uma
    expressão seguida de um ponto e vírgula. Em <code>$b = $a = 5;</code>,
    <code>$a = 5</code> é uma expressão válida, mas não é um comando
    por si só. <code>$b = $a = 5;</code> porém é um comando válido.
   </simpara>
   <simpara>
    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).

    <!-- (PHP doesn't have a
    dedicated boolean type) : WRONG, PHP does. -->

    As constantes &true; e &false; (insensitivas ao caso) são seus dois
    valores booleanos possíveis. Às vezes uma expressão é
    automaticamente convertida para um booleano. Veja a
    <link linkend="language.types.typecasting">seção sobre
    type-casting</link> para detalhes de como isso é feito.
   </simpara>
   <simpara>
    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 ideia 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
    <varname>expr</varname> (ou expressão)
    para indicar qualquer expressão 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:"~/.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
-->