## Argumentos de funciones

Cualquier información puede ser pasada a las funciones mediante la lista de argumentos, la cual es una lista de expresiones delimitadas por comas. Los argumentos son evaluados de izquierda a derecha.

PHP admite el paso de argumentos por valor (lo predeterminado), el paso por referencia, y valores de argumentos predeterminados. Las Listas de argumentos de longitud variable también están soportadas.

Ejemplo #1 Pasar arrays a funciones

`<?php
function tomar_array($entrada)
{
echo "$entrada[0] + $entrada[1] = ".$entrada[0]+$entrada[1];
}
?>`

### Paso de argumentos por referencia

Por defecto, los argumentos de las funciones son pasados por valor (así, si el valor del argumento dentro de la función cambia, este no cambia fuera de la función). Para permitir a una función modificar sus argumentos, éstos deben pasarse por referencia.

Para hacer que un argumento a una función sea siempre pasado por referencia hay que anteponer al nombre del argumento el signo 'et' (&) en la definición de la función:

Ejemplo #2 Paso de parámetros de una función por referencia

`<?php
function añadir_algo(&$cadena)
{
$cadena .= 'y algo más.';
}
$cad = 'Esto es una cadena, ';
añadir_algo($cad);
echo $cad; // imprime 'Esto es una cadena, y algo más.'
?>`

### Valores de argumentos predeterminados

Una función puede definir valores predeterminados al estilo de C++ para argumentos escalares como sigue:

Ejemplo #3 Uso de parámetros predeterminados en funciones

`<?php
function hacer_café($tipo = "capuchino")
{
return "Hacer una taza de $tipo.\n";
}
echo hacer_café();
echo hacer_café(null);
echo hacer_café("espresso");
?>`

El resultado del ejemplo sería:

    Hacer una taza de capuchino.
    Hacer una taza de .
    Hacer una taza de espresso.

PHP también permite el uso de arrays y del tipo especial `null` como valores predeterminados, por ejemplo:

Ejemplo #4 Usar tipos no escalares como valores predeterminados

`<?php
function hacer_café($tipos = array("capuchino"), $fabricanteCafé = NULL)
{
$aparato = is_null($fabricanteCafé) ? "las manos" : $fabricanteCafé;
return "Hacer una taza de ".join(", ", $tipos)." con $aparato.\n";
}
echo hacer_café();
echo hacer_café(array("capuchino", "lavazza"), "una tetera");
?>`

El valor predeterminado debe ser una expresión constante, no (por ejemplo) una variable, un miembro de una clase o una llamada a una función.

Obsérvese que cuando se emplean argumentos predeterminados, cualquiera de ellos debería estar a la derecha de los argumentos no predeterminados; si no, las cosas no funcionarán como se esperaba. Considérese el siguiente trozo de código:

Ejemplo #5 Uso incorrecto de argumentos predeterminados en una función

`<?php
function hacer_yogur($tipo = "acidófilo", $sabor)
{
return "Hacer un tazón de yogur $tipo de $sabor.\n";
}
echo hacer_yogur("frambuesa"); // no funcionará como se esperaba
?>`

El resultado del ejemplo sería:

    Warning: Missing argument 2 in call to hacer_yogur() in
    /usr/local/etc/httpd/htdocs/phptest/functest.html on line 41
    Hacer un tazón de yogur frambuesa de .

Ahora, compare el ejemplo de arriba con este:

Ejemplo #6 Uso correcto de argumentos predeterminados en una función

`<?php
function hacer_yogur($sabor, $tipo = "acidófilo")
{
return "Hacer un tazón de yogur $tipo de $sabor.\n";
}
echo hacer_yogur("frambuesa"); // funciona como se esperaba
?>`

El resultado del ejemplo sería:

    Hacer un tazón de yogur acidófilo de frambuensa.

> Nota: A partir de PHP 5, los argumentos pasados por referencia pueden tener un valor predeterminado.

### Declaraciones de tipo

> Nota:

> La declaración de tipos también se conoce como 'Determinación de tipos' en PHP 5.

Las declaraciones de tipo permiten a las funciones requerir que los parámetros sean de cierto tipo durante una llamada. Si el valor dado es de un tipo incorrecto, se generará un error: en PHP 5, este error es un error fatal recuperable, mientras que PHP 7 lanzará una excepción TypeError.

Para especificar una declaración de tipo, debe anteponerse el nombre del tipo al nombre del parámetro. Se puede hacer que una declaración acepte valores `null` si el valor predeterminado del parámetro se establece a `null`.

#### Tipos válidos

Tipo | Descripción | Versión de PHP mínima
--- | --- | ---
nombre de clase/interfaz | El parámetro debe ser una `instanceof` del nombre de la clase o interfaz dada. | PHP 5.0.0
`self` | El parámetro debe ser una `instanceof` de la misma clase donde está definido el método. Esto solamente se puede utilizar en clases y métodos de instancia. | PHP 5.0.0
array | El parámetro debe ser un array. | PHP 5.1.0
callable | El parámetro debe ser un callable válido. | PHP 5.4.0
bool | El parámetro debe ser un valor de tipo boolean. | PHP 7.0.0
float | El parámetro debe ser un número de tipo float. | PHP 7.0.0
int | El parámetro debe ser un valor de tipo integer. | PHP 7.0.0
string | El parámetro debe ser un string. | PHP 7.0.0
`iterable` | El parámetro debe ser un array o una `instanceof` Traversable. | PHP 7.1.0
`object` | El parámetro debe ser un object. | PHP 7.2.0

Advertencia

Los alias de los tipos escalares anteriores no están admitidos. En su lugar, son tratados como nombres de clases o de interfaces. Por ejemplo, el empleo de `boolean` como parámetro o como tipo devuelto requerirá un argumento o un valor devuelto que sea unaan `instanceof` de la clase o interfaz `boolean`, más que el tipo bool:

`<?php
function prueba(boolean $param) {}
prueba(true);
?>`

El resultado del ejemplo sería:

     Fatal error: Uncaught TypeError: Argument 1 passed to test() must be an instance of boolean, boolean given, called in - on line 1 and defined in -:1

#### Ejemplos

Ejemplo #7 Declaración básica de tipo clase

`<?php
class C {}
class D extends C {}
// Esta no extiende a C.
class E {}
function f(C $c) {
echo get_class($c)."\n";
}
f(new C);
f(new D);
f(new E);
?>`

El resultado del ejemplo sería:

    C
    D

    Fatal error: Uncaught TypeError: Argument 1 passed to f() must be an instance of C, instance of E given, called in - on line 14 and defined in -:8
    Stack trace:
    #0 -(14): f(Object(E))
    #1 {main}
      thrown in - on line 8

Ejemplo #8 Declaración básica de tipo interfaz

`<?php
interface I { public function f(); }
class C implements I { public function f() {} }
// Esta no implementa I.
class E {}
function f(I $i) {
echo get_class($i)."\n";
}
f(new C);
f(new E);
?>`

El resultado del ejemplo sería:

    C

    Fatal error: Uncaught TypeError: Argument 1 passed to f() must implement interface I, instance of E given, called in - on line 13 and defined in -:8
    Stack trace:
    #0 -(13): f(Object(E))
    #1 {main}
      thrown in - on line 8

Ejemplo #9 Tipos de parámetros pasados por referencia

Los tipos declarados de parámetros de referencia se comprueban en la entrada de la función, pero no cuando la función vuelve, así que después de que la función haya vuelto, el el tipo de argumento puede haber cambiado.

`<?php
function array_baz(array &$param)
{
$param = 1;
}
$var = [];
array_baz($var);
var_dump($var);
array_baz($var);
?>`

El resultado del ejemplo sería algo similar a:

    int(1)

    Fatal error: Uncaught TypeError: Argument 1 passed to array_baz() must be of the type array, int given, called in %s on line %d

Ejemplo #10 Declaración de tipo nulo

`<?php
class C {}
function f(C $c = null) {
var_dump($c);
}
f(new C);
f(null);
?>`

El resultado del ejemplo sería:

    object(C)#1 (0) {
    }
    NULL

#### Tipificación estricta

Por defecto, PHP fuerza a los valores de un tipo erróneo a ser del tipo escalar esperado si es posible. Por ejemplo, una función a la que se le pasa un integer para un parámetro que se prevé sea un string obtendrá una variable de tipo string.

Es posible habilitar el modo estricto en función de cada fichero. El el modo estricto solamente será aceptada una variable del tipo exacto de la declaración de tipo, o será lanzada una TypeError. La única excepción a esta regla es que se podría proporcionar un integer a una función que espere un float. Las llamadas a funciones desde dentro de funciones internas no se verán afectadas por la declaración `strict_types`.

Para habilitar el modo escricto se emplea la sentencia `declare` con la declaración `strict_types`:

Precaución

Habilitar el modo esctricto también afectará a las declaraciones de tipo de devolución.

> Nota:

> La tipificación estricta se aplica a las llamadas a funciones hechas desde dentro del fichero con la tipificación estricta habilitada, no a las funciones declaradas dentro del fichero. Si un fichero sin la tipificación estricta habilitada realiza una llamada a una función definida en un fichero con tipificación estricta, será respetada la preferencia del llamador (tipificación débil), y se forzará el valor.

> Nota:

> La tipificación estricta solamente se define para declaraciones de tipos escalares, y como tal, requiere PHP 7.0.0 o posterior, ya que las declaraciones de tipo escalar fueron añadidas en esta versión.

Ejemplo #11 Tipificación estricta

`<?php
declare(strict_types=1);
function sum(int $a, int $b) {
return $a + $b;
}
var_dump(sum(1, 2));
var_dump(sum(1.5, 2.5));
?>`

El resultado del ejemplo sería:

    int(3)

    Fatal error: Uncaught TypeError: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 9 and defined in -:4
    Stack trace:
    #0 -(9): sum(1.5, 2.5)
    #1 {main}
      thrown in - on line 4

Ejemplo #12 Tipificación débil

`<?php
function sum(int $a, int $b) {
return $a + $b;
}
var_dump(sum(1, 2));
// Estos números serán forzados a ser enteros: ¡observe la salida de abajo!
var_dump(sum(1.5, 2.5));
?>`

El resultado del ejemplo sería:

    int(3)
    int(3)

Ejemplo #13 Capturar la excepción TypeError

`<?php
declare(strict_types=1);
function sum(int $a, int $b) {
return $a + $b;
}
try {
var_dump(sum(1, 2));
var_dump(sum(1.5, 2.5));
} catch (TypeError $e) {
echo 'Error: '.$e->getMessage();
}
?>`

El resultado del ejemplo sería:

    int(3)
    Error: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 10

### Listas de argumentos de longitud variable

PHP tiene soporte para listas de argumentos de longitud variable en funciones definidas por el usuario. Esto se implementa utilizando el token `...` en PHP 5.6 y posteriores, y utilizando las funciones func_num_args(), func_get_arg(), y func_get_args() en PHP 5.5 y anteriores.

#### `...` en PHP 5.6+

En PHP 5.6 y posteriores, las listas de argumentos pueden incluir el token `...` para denotar que la función acepta un número variable de argumentos. Los argumentos serán pasados a la variable dada como un aryay, por ejemplo:

Ejemplo #14 Usando `...` para acceder a argumentos variables

`<?php
function sum(...$números) {
$acc = 0;
foreach ($números as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>`

El resultado del ejemplo sería:

    10

También se puede emplear `...` al llamar a funciones para convertir un array o variable Traversable o literal en una lista de argumentos:

Ejemplo #15 Usar `...` para proporcionar argumentos

`<?php
function add($a, $b) {
return $a + $b;
}
echo add(...[1, 2])."\n";
$a = [1, 2];
echo add(...$a);
?>`

El resultado del ejemplo sería:

    3
    3

Se puede especifcar argumentos posicionales normales antes del token `...`. En este caso, solamente los argumentos al final que no coincidan con un argumento posicional serán añadidos al array generado por `...`.

También es posible añadir una declaración de tipo antes del símbolo `...`. Si está presente, todos los argumentos capturados por `...` deben ser objetos de la clase implicada.

Ejemplo #16 Argumentos variables de declaración de tipo

`<?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).' days';
// Esto fallará, debido a que null no es un objeto de DateInterval.
echo total_intervals('d', null);
?>`

El resultado del ejemplo sería:

    3 days
    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

Por último, también es pueden pasar argumentos variables por referencia prefijando `...` con el signo (`&`).

#### Versiones antiguas de PHP

No se requiere una sintaxis especial para señalar que una función es varíadica; sin embargo, para acceder a los argumentos de la función se debe usar func_num_args(), func_get_arg() y func_get_args().

El primer ejemplo de antes se implementaría en PHP 5.5 y anteriores como sigue:

Ejemplo #17 Acceder a argumentos variables en PHP 5.5 y anteriores

`<?php
function sum() {
$acc = 0;
foreach (func_get_args() as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>`

El resultado del ejemplo sería:

    10

### Named Arguments

PHP 8.0.0 introduced named arguments as an extension of the existing positional parameters. Named arguments allow passing arguments to a function based on the parameter name, rather than the parameter position. This makes the meaning of the argument self-documenting, makes the arguments order-independent and allows skipping default values arbitrarily.

Named arguments are passed by prefixing the value with the parameter name followed by a colon. Using reserved keywords as parameter names is allowed. The parameter name must be an identifier, specifying dynamically is not allowed.

Ejemplo #18 Named argument syntax

`<?php
myFunction(paramName: $value);
array_foobar(array: $value);
// NOT supported.
function_name($variableStoringParamName: $value);
?>`

Ejemplo #19 Positional arguments versus named arguments

`<?php
// Using positional arguments:
array_fill(0, 100, 50);
// Using named arguments:
array_fill(start_index: 0, count: 100, value: 50);
?>`

The order in which the named arguments are passed does not matter.

Ejemplo #20 Same example as above with a different order of parameters

`<?php
array_fill(value: 50, num: 100, start_index: 0);
?>`

Named arguments can be combined with positional arguments. In this case, the named arguments must come after the positional arguments. It is also possible to specify only some of the optional arguments of a function, regardless of their order.

Ejemplo #21 Combining named arguments with positional arguments

`<?php
htmlspecialchars($string, double_encode: false);
// Same as
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
?>`

Passing the same parameter multiple times results in an Error exception.

Ejemplo #22 Error exception when passing the same parameter multiple times

`<?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
?>`