archived-doc-es/language/expressions.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<!-- EN-Revision: f4f96ef8b2a95283c92ea2183fe1dedf06f3ad22 Maintainer: Marqitos Status: ready -->
<!-- Reviewed: no Maintainer: seros -->
 <chapter xml:id="language.expressions" xmlns="http://docbook.org/ns/docbook">
   <title>Expresiones</title>
   <simpara>
    La expresiones son los bloques de construcción más importantes de PHP. En PHP
    casi todo lo que se escribe es una expresión. La manera más simple
    y acertada de definir lo que es 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 se escribe "<varname>$a</varname> = 5", se está asignando '5' a
    <varname>$a</varname>. '5', obviamente,
    tiene el valor 5, o en otras palabras, '5' es una expresión con el
    valor de 5 (en este caso, '5' es una constante entera).
   </simpara>
   <simpara>
    Después de esta asignación, se espera que el valor de <varname>$a</varname> sea 5
    también, por lo que si se escribe <varname>$b</varname> = <varname>$a</varname>, se espera que esto
    se comporte tal como si se escribiera <varname>$b</varname> = 5. En otras palabras,
    <varname>$a</varname> es también una expresión con el valor 5. Si todo funciona bien,
    esto es exactamente lo que sucederá.
   </simpara>
   <para>
    Un ejemplo de expresiones algo más complejo son las funciones. Por
    ejemplo, considere la siguiente función:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

function foo ()
{
    return 5;
}

?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    Asumiendo que está familiarizado con el concepto de función (si no lo está,
    échele una ojeada al capítulo sobre <link
    linkend="language.functions">funciones</link>), asumirá
    que escribir <code>$c = foo()</code> es esencialmente igual que
    escribir <code>$c = 5</code>. Y está en lo cierto. Las funciones
    son expresiones con el valor de sus valores devueltos. Ya que <code>foo()</code>
    devuelve 5, el valor de la expresión '<code>foo()</code>' es 5. Normalmente
    las funciones no sólo devuelven un valor estático, sino que computan algo.
   </simpara>
   <simpara>
    Por supuesto, los valores en PHP no tienen que ser enteros, y con frecuencia
    no lo son. PHP soporta cuatro tipos de valores escalares: valores enteros (<type>integer</type>),
    valores de coma (punto) flotante (<type>float</type>), valores de cadena (<type>string</type>)
    y valores booleanos (<type>boolean</type>) - (valores escalares son aquellos que no se
    pueden descomponer en piezas más pequeñas, a diferencia de las matrices, por ejemplo). PHP también
    soporta dos tipos compuestos (no escalares): matrices (arrays) y objetos. Cada uno
    de estos tipos de valores pueden ser asignados a variables o devueltos desde funciones.
   </simpara>
   <simpara>
    PHP lleva las expresiones mucho más allá, de la misma manera que lo hacen otros
    lenguajes. PHP es un lenguaje orientado a expresiones, en el
    sentido de que casi todo es una expresión. Considere el
    ejemplo que ya hemos tratado, <code>$a = 5</code>. Es fácil de ver que
    aquí hay dos valores involucrados, el valor de la constante
    entera <code>5</code>, y el valor de <varname>$a</varname> que ha sido actualizado a 5
    también. Aunque la verdad es que existe aquí un valor adicional
    involucrado, que es el valor de la asignación misma. La
    asignación evalúa al valor asignado, en este caso 5.
    En la práctica, esto significa que <code>$a = 5</code>, sin importar lo que haga,
    es una expresión con el valor 5. De este modo, escribir algo como
    <code>$b = ($a = 5)</code> es igual que escribir
    <code>$a = 5; $b = 5;</code> (el punto y coma
    marca el final de una sentencia). Ya que las asignaciones se analizan de
    derecha a izquierda, también se puede escribir <code>$b = $a = 5</code>.
   </simpara>
   <simpara>
    Otro buen ejemplo de orientación a expresiones es el pre- y
    post-incremento y decremento. Los usuarios de PHP y de otros muchos
    lenguajes pueden estar familiarizados con la notación <code>variable++</code> y
    <code>variable--</code>. Éstos son los <link linkend="language.operators.increment">
    operadores de incremento y decremento</link>. En PHP, al igual que en C, hay
    dos tipos de incrementos - pre-incremento y post-incremento.
    Ambos esencialmente incrementan la
    variable, y el efecto sobre la variable es idéntico. La
    diferencia está con el valor de la expresión de incremento.
    Pre-incremento, que se escribre <code>++$variable</code>, evalúa al
    valor incrementado (PHP incrementa la variable antes de leer su
    valor, de ahí el nombre de 'pre-incremento'). Post-incremento, que se
    escribe <code>$variable++</code> evalúa el valor original de
   <varname>$variable</varname>, antes de que sea incrementado (PHP incrementa la variable
    después de leer su valor, de ahí el nombre de 'post-incremento').
   </simpara>
   <simpara>
    Un tipo de expresiones muy comunes son las expresiones de <link
    linkend="language.operators.comparison">comparación</link>.
    Estas expresiones evalúan si algo es &false; (falso) o &true; (verdadero). PHP
    soporta &gt; (mayor que), &gt;= (mayor o igual que), == (igual),
    != (distinto), &lt; (menor que) y &lt;= (menor o igual que).
    El lenguaje también soporta un conjunto de operadores de equivalencia estricta: ===
    (igual y del mismo tipo) y !== (diferente o de distinto tipo).
    Estas expresiones se usan mayormente dentro de ejecuciones condicionales,
    tales como la sentencia <code>if</code>.
   </simpara>
   <simpara>
    El último ejemplo de expresiones que trataremos aquí es una combinación
    de expresiones operador-asignación. Ya sabe que si
    quiere incrementar <varname>$a</varname> en 1, puede simplemente escribir
    <code>$a++</code> o <code>++$a</code>.
    Pero si lo que quiere es añadirle más de uno, por ejemplo 3,
    podría escribir <code>$a++</code> varias veces, pero esto,
    obviamente, no es una manera muy eficiente o cómoda. Una práctica
    mucho más común es escribir <code>$a =
    $a + 3</code>. <code>$a + 3</code> evalúa
    al valor de <varname>$a</varname> más 3, y se vuelve a asignar
    a <varname>$a</varname>, lo que resulta en incrementar <varname>$a</varname>
    en 3. En PHP, como en otros lenguajes como C, se puede escribir esto
    de una manera más abreviada, lo que con el tiempo se podría convertir en una forma más clara y rápida
    de entenderlo. Añadir 3 al valor actual de <varname>$a</varname>
    puede ser escrito <code>$a += 3</code>. Esto significa exactamente
    "toma el valor de <varname>$a</varname>, añádele 3 y asígnalo
    de nuevo a <varname>$a</varname>". Además de ser más corto y
    claro, también resulta en una ejecución más rápida. El valor de
    <code>$a += 3</code>, al igual que el valor de una asignación normal, es
    el valor asignado. Observe que NO es 3, sino el valor combinado
    de <varname>$a</varname> más 3 (éste es el valor que es
    asignado a <varname>$a</varname>). Se puede usar cualquier operador compuesto de dos partes
    en este modo de operador-asignación, por ejemplo <code>$a -= 5</code>
    (restar 5 del valor de <varname>$a</varname>), <code>$b *= 7</code>
    (multiplicar el valor de <varname>$b</varname> por 7), etc.
   </simpara>
   <para>
    Existe una expresión más que le puede parecer rara si no la ha visto
    en otros lenguajes, el operador condicional ternario:
   </para>
   <para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$primero ? $segundo : $tercero
?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <para>
    Si el valor de la primera subexpresión es &true; (no es cero),
    se evalúa la segunda subexpresión, y ése será el resultado de
    la expresión condicional. Si no, se evalúa la tercera
    subexpresión, y ése será el valor.
   </para>
   <para>
    El siguiente ejemplo debería ayudarle a comprender un poco mejor el pre- y
    post-incremento y las expresiones en general:
   </para>
   <para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
function double($i)
{
    return $i*2;
}
$b = $a = 5;        /* asignar el valor cinco a la variable $a y $b */
$c = $a++;          /* post-incremento, asignar el valor original de $a
                       (5) a $c */
$e = $d = ++$b;     /* pre-incremento, asignar el valor incrementado de
                       $b (6) a $d y $e */

/* en este punto, $d y $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és
                       del incremento, 2*7 = 14, a $g */
$h = $g += 10;      /* primero, $g es incrementado en 10 y finaliza con el
                       valor 24. El valor de la asignación (24) es
                       asignado después a $h, y $h finaliza también con el
                       valor 24. */
?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    Algunas expresiones pueden considerarse como sentencias. En
    este caso, una sentencia tiene la forma '<code>expr ;</code>', es decir, una
    expresión seguida de un punto y coma. En <code>$b = $a = 5;</code>,
    <code>$a = 5</code> es una expresión válida, pero no es una sentencia
    en sí. Sin embargo, <code>$b = $a = 5;</code> es una sentencia válida.
   </simpara>
   <simpara>
    Lo último que vale la pena mencionar es el valor verdadero de las expresiones.
    En muchos casos, principalmente en ejecuciones condicionales y bucles, no
    interesa saber el valor específico de la expresión, sino sólo
    si el valor significa &true; o &false;.

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

    Las constantes &true; y &false; (insensible a mayúsculas-minúsculas) son los
    dos valores booleanos posibles. Cuando es necesario, una expresión es
    convertida automáticamente al tipo boolean. Véase la
    <link linkend="language.types.typecasting">sección sobre
    conversión de tipos</link> para más detalles.
   </simpara>
   <simpara>
    PHP proporciona una implementación completa y potente de expresiones, y
    documentarla por completo va más allá del ámbito de este manual. Los
    ejemplos de arriba deberían darle una buena idea de lo que son las expresiones
    y cómo construir expresiones útiles. Durante el
    resto de este manual se escribirá <varname>expr</varname>
    para indicar cualquier expresión de 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
-->