functions.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: dd87866772c31671146ff778140dc0955c55005c Maintainer: PhilDaiguille Status: ready -->
<!-- Reviewed: no -->
<chapter xml:id="language.functions" xmlns="http://docbook.org/ns/docbook">
 <title>Las funciones</title>

 <sect1 xml:id="functions.user-defined">
  <title>Las funciones definidas por el usuario</title>

  <para>
   Una función se define utilizando el operador <literal>function</literal>,
   un nombre, una lista de argumentos (que pueden estar vacíos) separados por comas
   (<literal>,</literal>) entre paréntesis, seguidos del cuerpo de
   la función entre llaves, como sigue:
  </para>
  <example>
   <title>Declaración de una nueva función llamada <literal>foo</literal></title>
   <programlisting role="php">
<![CDATA[
<?php
function foo($arg_1, $arg_2, /* ..., */ $arg_n)
{
    echo "Ejemplo de función.\n";
    return $retval;
}
?>
]]>
   </programlisting>
  </example>
  <note>
   <para>
    A partir de PHP 8.0.0, la lista de argumentos puede tener una coma final:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
function foo($arg_1, $arg_2,) { }
?>
]]>
     </programlisting>
    </informalexample>
   </para>
  </note>

  <simpara>
   Todo código PHP válido puede aparecer dentro del cuerpo de una función, incluso otras
   funciones y definiciones de
   <link linkend="language.oop5.basic.class">clase</link>.
  </simpara>
  <para>
   Los nombres de funciones siguen las mismas reglas que otros identificadores en PHP.
   Un nombre de función válido comienza con una letra o un subrayado, seguido
   por cualquier número de letras, números o subrayados.
   Estas reglas pueden representarse mediante la expresión regular siguiente:
   <code>^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$</code>
  </para>
  &tip.userlandnaming;
  <simpara>
   Las funciones no necesitan ser definidas antes de ser utilizadas,
   <emphasis>SALVO</emphasis> cuando una función es definida
   condicionalmente, como se muestra en los dos ejemplos siguientes.
  </simpara>
  <para>
   Cuando una función es definida de manera condicional, como en
   los ejemplos siguientes, su definición debe <emphasis>preceder</emphasis>
   su utilización.
  </para>
  <para>
   <example>
    <title>Funciones condicionales</title>
    <programlisting role="php">
<![CDATA[
<?php

$makefoo = true;

/* No es posible llamar a foo() aquí,
   ya que esta función no existe.
   Pero podemos utilizar bar() */

bar();

if ($makefoo) {
  function foo()
  {
    echo "No existo hasta que el programa pase por aquí.\n";
  }
}

/* Ahora podemos llamar a foo()
   ya que $makefoo se evalúa como verdadero */

if ($makefoo) foo();

function bar()
{
  echo "Existo desde el principio del programa.\n";
}

?>
]]>
    </programlisting>
   </example>
  </para>
  <para>
   <example>
    <title>Funciones dentro de otra función</title>
    <programlisting role="php">
<![CDATA[
<?php
function foo()
{
  function bar()
  {
    echo "No existo hasta que foo() sea llamado.\n";
  }
}

/* No es posible llamar a bar() aquí
   ya que no existe. */

foo();

/* Ahora podemos llamar a bar(),
   ya que la utilización de foo() la ha hecho
   accesible. */

bar();

?>
]]>
    </programlisting>
   </example>
  </para>
  <para>
   Todas las funciones y clases en PHP tienen un ámbito global - pueden ser llamadas
   fuera de una función si han sido definidas dentro y viceversa.
  </para>
  <simpara>
   PHP no soporta la sobrecarga, la destrucción y la redefinición de
   funciones ya declaradas.
  </simpara>
  <note>
   <simpara>
    Los nombres de funciones son insensibles a mayúsculas/minúsculas para los caracteres ASCII
    <literal>A</literal> a <literal>Z</literal>,
    y es generalmente aceptado que las funciones deben
    ser llamadas con el nombre utilizado en su declaración,
    incluyendo la mayúscula/minúscula.
   </simpara>
  </note>
  <simpara>
   Las <link linkend="functions.variable-arg-list">
   listas de argumentos de función variables</link> y los
   <link linkend="functions.arguments.default">valores por defecto
    de argumentos</link> son soportados: ver
   las funciones de referencia que son
   <function>func_num_args</function>,
   <function>func_get_arg</function>, y
   <function>func_get_args</function> para más información.
  </simpara>
  <para>
   Es posible llamar a funciones recursivas en PHP.
   <example>
    <title>Funciones recursivas</title>
    <programlisting role="php">
<![CDATA[
<?php
function recursion($a)
{
    if ($a < 20) {
        echo "$a\n";
        recursion($a + 1);
    }
}
?>
]]>
    </programlisting>
   </example>
   <note>
    <simpara>
     Las llamadas de métodos/funciones recursivas con 100-200 niveles de
     recursividad pueden llenar la pila y así, terminar el script actual.
     Se debe notar que una recursión infinita es considerada un error de
     programación.
    </simpara>
   </note>
  </para>

 </sect1>

 <sect1 xml:id="functions.arguments">
  <title>Parámetros y argumentos de función</title>
  <simpara>
   Los parámetros de la función se declaran en la firma de la función.
   Información puede ser pasada a
   una función utilizando una lista de argumentos, donde cada
   expresión está separada por una coma. Los argumentos serán
   evaluados de izquierda a derecha, y el resultado es asignado a los parámetros de
   la función, antes de que la función sea efectivamente llamada
   (evaluación <emphasis>inmediata</emphasis>).
  </simpara>
  <!-- Note: this paragraph feels like it should be moved to the syntax part? -->
  <para>
   PHP soporta el paso de argumentos por valor (comportamiento por defecto), <link
   linkend="functions.arguments.by-reference">el paso por referencia</link>, y <link
   linkend="functions.arguments.default">valores por defecto de argumentos</link>.
   Una <link linkend="functions.variable-arg-list">lista de argumentos variable</link>,
   así como los <link linkend="functions.named-arguments">Argumentos Nombrados</link>
   también son soportados.
  </para>
  <note>
   <para>
    A partir de PHP 7.3.0, es posible tener una coma final en la lista de argumentos
    para las llamadas de función:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$v = foo(
    $arg_1,
    $arg_2,
);
?>
]]>
      </programlisting>
     </informalexample>
    </para>
   </note>

   <para>
    A partir de PHP 8.0.0, la lista de argumentos de función puede incluir una
    coma final, que será ignorada. Esto es particularmente útil en
    los casos donde la lista de argumentos es larga o contiene nombres de variables
    largos, haciendo práctico listar los argumentos verticalmente.
   </para>
   <example>
    <title>Lista de parámetros de función con una coma final</title>
    <programlisting role="php">
<![CDATA[
<?php
function takes_many_args(
    $first_arg,
    $second_arg,
    $a_very_long_argument_name,
    $arg_with_default = 5,
    $again = 'a default string', // Esta coma final no era permitida antes de 8.0.0.
)
{
    // ...
}
?>
]]>
    </programlisting>
   </example>

  <sect2 xml:id="functions.arguments.by-reference">
   <title>Paso de argumentos por referencia</title>

   <simpara>
    Por defecto, los argumentos son pasados
    a la función por valor (también, cambiar el valor de un argumento en la función no
    cambia su valor fuera de la función). Si se desea que las funciones
    puedan cambiar los valores de los argumentos, estos argumentos deben ser pasados por referencia.
   </simpara>
   <para>
    Si se desea que un argumento sea siempre pasado
    por referencia, se puede añadir un '<literal>&amp;</literal>'
    delante del parámetro en la declaración de la función:
   </para>
   <para>
    <example>
     <title>Paso de argumentos de función por referencia</title>
     <programlisting role="php">
<![CDATA[
<?php
function add_some_extra(&$string)
{
    $string .= ', y un poco más.';
}
$str = 'Esto es un string';
add_some_extra($str);
echo $str; // Muestra: 'Esto es un string, y un poco más.'
?>
]]>
     </programlisting>
    </example>
   </para>
   <para>
    Es incorrecto pasar una expresión constante como argumento a un parámetro
    que espera ser pasado por referencia.
   </para>
  </sect2>

  <sect2 xml:id="functions.arguments.default">
   <title>Valores por defecto de parámetros</title>

   <para>
    Una función puede definir valores por defecto para los parámetros utilizando una sintaxis similar
    a la de la asignación de una variable. El valor por defecto es utilizado únicamente cuando el argumento del parámetro no es
    pasado. Tenga en cuenta que pasar &null; no <emphasis>define</emphasis>
    el valor por defecto.
   </para>
   <para>
    <example>
     <title>Valor por defecto de argumentos de funciones</title>
     <programlisting role="php">
<![CDATA[
<?php
function servir_cafe ($type = "cappuccino")
{
    return "Servir un $type.\n";
}
echo servir_cafe();
echo servir_cafe(null);
echo servir_cafe("espresso");
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
Servir un cappuccino.
Servir un .
Servir un espresso.
]]>
     </screen>
    </example>
   </para>
   <para>
    Los valores por defecto de parámetros pueden ser valores escalares,
    &array;s, el tipo especial &null;, y a partir de PHP 8.1.0,
    objetos utilizando la sintaxis <link linkend="language.oop5.basic.new">new ClassName()</link>.
   </para>
   <para>
    <example>
     <title>Uso de tipo no escalar como valor por defecto</title>
     <programlisting role="php">
<![CDATA[
<?php
function servir_cafe($types = array("cappuccino"), $coffeeMaker = NULL)
{
    $device = is_null($coffeeMaker) ? "las manos" : $coffeeMaker;
    return "Preparación de una taza de ".join(", ", $types)." con $device.\n";
}
echo servir_cafe();
echo servir_cafe(array("cappuccino", "lavazza"), "una cafetera");
?>
]]>
     </programlisting>
     &example.outputs;
      <screen>
<![CDATA[
Preparación de una taza de cappuccino con las manos.
Preparación de una taza de cappuccino, lavazza con una cafetera.
]]>
      </screen>
    </example>
   </para>
    <para>
      <example>
        <title>Uso de objetos como valores por defecto (a partir de PHP 8.1.0)</title>
        <programlisting role="php">
<![CDATA[
<?php
class DefaultCoffeeMaker {
    public function brew() {
        return 'Hacer café.\n';
    }
}
class FancyCoffeeMaker {
    public function brew() {
        return 'Crear un café bonito solo para usted.\n';
    }
}
function makecoffee($coffeeMaker = new DefaultCoffeeMaker)
{
    return $coffeeMaker->brew();
}
echo makecoffee();
echo makecoffee(new FancyCoffeeMaker);
?>
]]>
        </programlisting>

      &example.outputs;
      <screen>
<![CDATA[
Hacer café.
Crear un café bonito solo para usted.
]]>
      </screen>
      </example>
    </para>
   <simpara>
    El valor por defecto de un argumento debe
    ser obligatoriamente una constante, y no puede ser
    ni una variable, ni un miembro de clase, ni una llamada de función.
   </simpara>
   <para>
    Tenga en cuenta que todos los parámetros opcionales deben ser especificados después de los
    parámetros obligatorios, de lo contrario no pueden ser omitidos en las llamadas.
    Considere el siguiente código:
   </para>
   <para>
    <example>
     <title>Uso incorrecto de parámetros de función por defecto</title>
     <programlisting role="php">
<![CDATA[
<?php
function hacerunyaourt ($container = "bol", $flavour)
{
    return "Preparar un $container de yogur a la $flavour.\n";
}

echo hacerunyaourt("framboise");   // "framboise" es $container, no $flavour
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function hacerunyaourt(), 1 passed in example.php on line 42
]]>
     </screen>
    </example>
   </para>
   <para>
    Ahora comparemos el ejemplo anterior con el siguiente:
   </para>
   <para>
    <example>
     <title>Uso correcto de parámetros de función por defecto</title>
     <programlisting role="php">
<![CDATA[
<?php
function hacerunyaourt ($flavour, $container = "bol")
{
    return "Preparar un $container de yogur a la $flavour.\n";
}

echo hacerunyaourt ("framboise");   // "framboise" es $flavour
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
Preparar un bol de yogur a la framboise.
]]>
     </screen>
    </example>
   </para>
    <para>
      A partir de PHP 8.0.0, los <link linkend="functions.named-arguments">argumentos nombrados</link>
      pueden ser utilizados para pasar por alto varios parámetros opcionales.
    </para>
    <para>
     <example>
      <title>Uso correcto de parámetros de función por defecto</title>
      <programlisting role="php">
<![CDATA[
<?php
function hacerunyaourt($container = "bol", $flavour = "framboise", $style = "Grec")
{
    return "Preparar un $container de yogur $style a la $flavour.\n";
}
echo hacerunyaourt(style: "natural");
?>
]]>
      </programlisting>
      &example.outputs;
      <screen>
<![CDATA[
Preparar un bol de yogur natural a la framboise.
]]>
      </screen>
     </example>
    </para>
    <para>
      A partir de PHP 8.0.0, declarar parámetros obligatorios después de argumentos opcionales es <emphasis>obsoleto</emphasis>.
      Este problema puede generalmente resolverse abandonando el valor por defecto, ya que nunca será utilizado.
      Una excepción a esta regla concierne a los parámetros de la forma <code>Type $param = null</code>,
      donde el &null; por defecto hace el tipo implicitamente nullable.
      Este uso está deprecado desde PHP 8.4.0, y un
      <link linkend="language.types.declarations.nullable">tipo nullable</link>
      explícito debe ser utilizado en su lugar.
      <example>
       <title>Declaración de parámetros opcionales después de parámetros obligatorios</title>
        <programlisting role="php">
<![CDATA[
<?php

function foo($a = [], $b) {}     // Valor por defecto no utilizado; desaconsejado a partir de PHP 8.0.0
function foo($a, $b) {}          // Funcionalmente equivalente, sin advertencia de deprecación

function bar(A $a = null, $b) {} // A partir de PHP 8.1.0, $a es implicitamente requerido
                                 // (ya que precede a un parámetro requerido),
                                 // pero implicitamente nullable (desaconsejado a partir de PHP 8.4.0),
                                 // ya que el valor por defecto del parámetro es null
function bar(?A $a, $b) {}       // Recomendado

?>
]]>
        </programlisting>
      </example>
    </para>
    <note>
      <simpara>
        A partir de PHP 7.1.0, la omisión de un parámetro que no especifica un valor por defecto lanza
        un <classname>ArgumentCountError</classname>;
        en versiones anteriores, esto generaba una advertencia.
      </simpara>
    </note>
   <note>
    <simpara>
     Los argumentos pasados por referencia pueden tener
     un valor por defecto.
    </simpara>
   </note>
  </sect2>

  <sect2 xml:id="functions.variable-arg-list">
   <title>Lista de argumentos de número variable</title>

   <simpara>
    PHP soporta argumentos de número variable en las
    funciones definidas por el usuario utilizando el token
    <literal>...</literal>.
   </simpara>

   <para>
    La lista de argumentos puede incluir el
    token <literal>...</literal> para indicar que esta función acepta
    un número variable de argumentos. Los argumentos serán pasados a la variable
    proporcionada en forma de un &array;:

    <example>
     <title>Uso de <literal>...</literal> para acceder a argumentos variables</title>
     <programlisting role="php">
<![CDATA[
<?php
function sum(...$numbers) {
    $acc = 0;
    foreach ($numbers as $n) {
        $acc += $n;
    }
    return $acc;
}

echo sum(1, 2, 3, 4);
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
10
]]>
     </screen>
    </example>
   </para>

   <para>
    <literal>...</literal> también puede ser utilizado durante las llamadas de
    funciones para extraer el &array; o la variable
    <classname>Traversable</classname> o el literal en la lista de argumentos:

    <example>
     <title>Uso de <literal>...</literal> para proporcionar argumentos</title>
     <programlisting role="php">
<![CDATA[
<?php
function add($a, $b) {
    return $a + $b;
}

echo add(...[1, 2])."\n";

$a = [1, 2];
echo add(...$a);
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
3
3
]]>
     </screen>
    </example>
   </para>

   <para>
    Se pueden especificar parámetros clásicos antes de la palabra clave
    <literal>...</literal>. En este caso, solo los argumentos finales
    que no coincidan con un argumento clásico serán añadidos
    al array generado por <literal>...</literal>.
   </para>

   <para>
    También es posible añadir una
    <link linkend="language.types.declarations">declaración de tipo</link>
    antes del token <literal>...</literal>. Si esto está presente,
    entonces todos los argumentos capturados por <literal>...</literal>
    deben coincidir con el tipo de parámetro.

    <example>
     <title>Conversión de argumentos variables</title>
     <programlisting role="php">
<![CDATA[
<?php
function total_intervals($unit, DateInterval ...$intervals) {
    $time = 0;
    foreach ($intervals as $interval) {
        $time += $interval->$unit;
    }
    return $time;
}

$a = new DateInterval('P1D');
$b = new DateInterval('P2D');
echo total_intervals('d', $a, $b).' días';

// Esto fallará, ya que null no es un objeto DateInterval.
echo total_intervals('d', null);
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
3 días
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2
]]>
     </screen>
    </example>
   </para>

   <para>
    Finalmente, se pueden pasar argumentos variables
    <link linkend="functions.arguments.by-reference">por referencia</link>
    prefijando la palabra clave <literal>...</literal> con un comercial
    (<literal>&amp;</literal>).
   </para>

  </sect2>

  <sect2 xml:id="functions.named-arguments">
   <title>Argumentos Nombrados</title>

   <para>
    PHP 8.0.0 introduce los argumentos nombrados como extensión a los parámetros
    posicionales existentes. Los argumentos nombrados permiten pasar los
    argumentos a una función basándose en el nombre del parámetro, en lugar de
    la posición del parámetro. Esto documenta automáticamente el significado
    del argumento, hace que el orden de los argumentos sea independiente y permite
    omitir valores por defecto arbitrariamente.
   </para>

   <para>
    Los argumentos nombrados se pasan prefijando el valor con el nombre del
    parámetro seguido de dos puntos. Utilizar palabras clave reservadas como
    nombre de parámetro está permitido. El nombre del parámetro debe ser un identificador,
    no se permite especificarlo de forma dinámica.
   </para>

   <example>
    <title>Sintaxis de argumentos nombrados</title>
    <programlisting role="php">
<![CDATA[
<?php
myFunction(paramName: $value);
array_foobar(array: $value);

// NO soportado.
function_name($variableStoringParamName: $value);
?>
]]>
    </programlisting>
   </example>

   <example>
    <title>Argumentos posicionales comparados con argumentos nombrados</title>
    <programlisting role="php">
<![CDATA[
<?php
// Utilizando argumentos posicionales:
array_fill(0, 100, 50);

// Utilizando argumentos nombrados:
array_fill(start_index: 0, count: 100, value: 50);
?>
]]>
    </programlisting>
   </example>

   <para>
    El orden en el que se pasan los argumentos nombrados no importa.
   </para>

   <example>
    <title>Mismo ejemplo que arriba, pero con un orden de parámetro diferente</title>
    <programlisting role="php">
<![CDATA[
<?php
array_fill(value: 50, count: 100, start_index: 0);
?>
]]>
    </programlisting>
   </example>

   <para>
    Los argumentos nombrados pueden ser combinados con los argumentos posicionales.
    En este caso, los argumentos nombrados deben venir después de los argumentos posicionales.
    También es posible especificar solo algunos de los argumentos opcionales
    de una función, independientemente de su orden.
   </para>

   <example>
    <title>Combinar argumentos nombrados con argumentos posicionales</title>
    <programlisting role="php">
<![CDATA[
<?php
htmlspecialchars($string, double_encode: false);
// Igual que
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>
]]>
    </programlisting>
   </example>

   <para>
    Pasar el mismo argumento varias veces resulta en una
    <classname>Error</classname> excepción.
   </para>

   <example>
    <title>Error lanzado cuando un argumento es pasado varias veces al mismo parámetro nombrado</title>
    <programlisting role="php">
<![CDATA[
<?php
function foo($param) { ... }

foo(param: 1, param: 2);
// Error: Named parameter $param overwrites previous argument

foo(1, param: 2);
// Error: Named parameter $param overwrites previous argument

?>
]]>
    </programlisting>
   </example>

    <para>
      A partir de PHP 8.1.0, es posible utilizar argumentos nombrados después de descomponer los argumentos.
      Un argumento nombrado <emphasis>no debe</emphasis> sobrescribir un argumento ya descompuesto.
    </para>

    <example>
      <title>Utilizar argumentos nombrados después de la descomposición</title>
      <programlisting role="php">
<![CDATA[
<?php
function foo($a, $b, $c = 3, $d = 4) {
  return $a + $b + $c + $d;
}
var_dump(foo(...[1, 2], d: 40)); // 46
var_dump(foo(...['b' => 2, 'a' => 1], d: 40)); // 46
var_dump(foo(...[1, 2], b: 20)); // Error fatal. El parámetro nombrado $b sobrescribe el argumento anterior.
?>
]]>
      </programlisting>
    </example>

  </sect2>
 </sect1>

 <sect1 xml:id="functions.returning-values">
  <title>Los valores de retorno</title>

  <para>
   Los valores son devueltos utilizando una
   instrucción de retorno opcional. Todos los tipos de variables
   pueden ser devueltos, incluyendo arrays y objetos. Esto hace
   que la función termine su ejecución inmediatamente y pase
   el control a la línea llamante. Ver
   <function>return</function>
   para más información.
  </para>
  <note>
   <para>
    Si <function>return</function>
    es omitido, el valor &null; será devuelto.
   </para>
  </note>

  <sect2>
   <title>Uso de return</title>
   <para>
    <example>
     <title>Uso de <function>return</function></title>
     <programlisting role="php">
<![CDATA[
<?php
function cuadrado($num)
{
    return $num * $num;
}
echo cuadrado(4); // Muestra '16'
?>
]]>
     </programlisting>
    </example>
   </para>

   <para>
    Una función no puede devolver varios valores a la vez, pero
    puede obtenerse el mismo resultado devolviendo un array.
   </para>
   <para>
    <example>
     <title>Devolver un array de una función</title>
     <programlisting role="php">
<![CDATA[
<?php
function pequeño_numero()
{
    return [0, 1, 2];
}
// La descomposición de un array recolectará cada miembro del array individualmente
[$zero, $one, $two] = pequeño_numero();

// Anterior a PHP 7.1, la única alternativa equivalente es utilizando la estructura de lenguaje list()
list ($zero, $un, $deux) = pequeño_numero();
?>
]]>
     </programlisting>
    </example>
   </para>
   <para>
    Para devolver una referencia de una función, utilice
    el operador &amp; tanto en la declaración de la función como en
    la asignación del valor de retorno.
   </para>
   <para>
    <example>
     <title>Devolver una referencia de una función</title>
     <programlisting role="php">
<![CDATA[
<?php
function &devolver_referencia()
{
    return $uneref;
}

$newref =& devolver_referencia();
?>
]]>
     </programlisting>
    </example>
   </para>
   <simpara>
    Para más información sobre referencias, véase <link
    linkend="language.references">la explicación sobre referencias</link>.
   </simpara>
  </sect2>
 </sect1>

 <sect1 xml:id="functions.variable-functions">
  <title>Funciones variables</title>

  <para>
   PHP soporta el concepto de funciones variables.
   Esto significa que si el nombre de una variable es seguido de paréntesis,
   PHP buscará una función de mismo nombre y intentará ejecutarla.
   Esto puede servir, entre otras cosas, para hacer funciones de devolución de llamada, tablas de funciones...
  </para>
  <para>
   Las funciones variables no pueden funcionar con los
   elementos de lenguaje como los
   <function>echo</function>, <function>print</function>,
   <function>unset</function>, <function>isset</function>,
   <function>empty</function>, <function>include</function>,
   <function>require</function> etc. Se debe utilizar
   su propia gestión de funciones para utilizar uno de estos elementos
   de lenguaje como funciones variables.
  </para>
  <para>
   <example>
    <title>Ejemplo de función variable</title>
    <programlisting role="php">
<![CDATA[
<?php
function foo() {
    echo "en foo()<br />\n";
}

function bar($arg = '')
{
    echo "En bar(); el argumento era '$arg'.<br />\n";
}

// Esto es una función desviada de echo
function echoit($string)
{
    echo $string;
}

$func = 'foo';
$func();        // Llama a foo()

$func = 'bar';
$func('test');  // Llama a bar()

$func = 'echoit';
$func('test');  // Llama a echoit()
?>
]]>
    </programlisting>
   </example>
  </para>
  <para>
   También se pueden llamar los métodos de un objeto utilizando el sistema de
   funciones variables.
   <example>
    <title>Ejemplo de método variable</title>
    <programlisting role="php">
<![CDATA[
<?php
class Foo
{
    function Variable()
    {
        $name = 'Bar';
        $this->$name(); // Llama al método Bar()
    }

    function Bar()
    {
        echo "Es Bar";
    }
}

$foo = new Foo();
$funcname = "Variable";
$foo->$funcname();  // Llama a $foo->Variable()

?>
]]>
    </programlisting>
   </example>
  </para>
  <para>
   Al llamar a métodos estáticos, la llamada de función es mejor que
   el operador de propiedad estática:
   <example>
    <title>Ejemplo de método variable con propiedades estáticas</title>
    <programlisting role="php">
<![CDATA[
<?php
class Foo
{
    static $variable = 'propiedad estática';
    static function Variable()
    {
        echo 'Método Variable llamado';
    }
}

echo Foo::$variable; // Esto muestra 'propiedad estática'. Es necesario tener una $variable en el contexto.
$variable = "Variable";
Foo::$variable();  // Esto llama a $foo->Variable(), leyendo así la $variable desde el contexto.

?>
]]>
    </programlisting>
   </example>
  </para>
  <para>
   <example>
    <title>callables complejo</title>
    <programlisting role="php">
<![CDATA[
<?php
class Foo
{
    static function bar()
    {
        echo "bar\n";
    }
    function baz()
    {
        echo "baz\n";
    }
}