Parámetros y argumentos de función
Los parámetros de la función son declarados en la firma de la función.
La información puede ser pasada a
una función utilizando una lista de argumentos, cada
expresión 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 inmediata).
PHP soporta el paso de argumentos por valor (comportamiento por defecto), el paso por referencia, y valores de argumentos por defecto.
Una lista variable de argumentos,
así como los Argumentos Nominados
son también soportados.
Nota:
A partir de PHP 7.3.0, es posible tener una coma final en la lista de argumentos
para las llamadas de función:
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 práctico en
los casos donde la lista de argumentos es larga o contiene nombres de variables
largos, haciéndolo práctico para listar los argumentos verticalmente.
Ejemplo #1 Lista de parámetros de la función con una coma final
<?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.
)
{
// ...
}
?>
Paso de argumentos por referencia
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 el valor de los argumentos, se deben pasar estos argumentos por referencia.
Si se desea que un argumento sea siempre pasado
por referencia, se puede añadir un '&'
antes del parámetro en la declaración de la función:
Ejemplo #2 Paso de argumentos de función por referencia
<?php
function add_some_extra(&$string)
{
$string .= ', y un poco más.';
}
$str = 'Esto es una cadena';
add_some_extra($str);
echo $str; // Muestra: 'Esto es una cadena, y un poco más.'
?>
No es correcto pasar una expresión constante como argumento a un parámetro que espera ser pasado por referencia.
Valores por defecto de los parámetros
Una función puede definir valores por defecto para los parámetros utilizando una sintaxis similar
a 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 define
el valor por defecto.
Ejemplo #3 Valor por defecto de los argumentos de funciones
<?php
function servir_cafe ($type = "cappuccino")
{
return "Servir un $type.\n";
}
echo servir_cafe();
echo servir_cafe(null);
echo servir_cafe("espresso");
?>
El resultado del ejemplo sería:
Servir un cappuccino.
Servir un .
Servir un espresso.
Los valores por defecto de los parámetros pueden ser valores escalares,
arrays, el tipo especial null, y a partir de PHP 8.1.0,
objetos utilizando la sintaxis new ClassName().
Ejemplo #4 Uso de tipo no escalar como valor por defecto
<?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");
?>
El resultado del ejemplo sería:
Preparación de una taza de cappuccino con las manos.
Preparación de una taza de cappuccino, lavazza con una cafetera.
Ejemplo #5 Uso de objetos como valores por defecto (a partir de PHP 8.1.0)
<?php
class DefaultCoffeeMaker {
public function brew() {
return 'Hacer café.\n';
}
}
class FancyCoffeeMaker {
public function brew() {
return 'Crear un bonito café solo para usted.\n';
}
}
function makecoffee($coffeeMaker = new DefaultCoffeeMaker)
{
return $coffeeMaker->brew();
}
echo makecoffee();
echo makecoffee(new FancyCoffeeMaker);
?>
El resultado del ejemplo sería:
Hacer café.
Crear un bonito café solo para usted.
El valor por defecto de un argumento debe
obligatoriamente ser una constante, y no puede ser
ni una variable, ni un miembro de clase, ni un llamado de función.
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:
Ejemplo #6 Uso incorrecto de los parámetros de función por defecto
<?php
function hacerunyaourt ($container = "bol", $flavour)
{
return "Preparar un $container de yaourt a la $flavour.\n";
}
echo hacerunyaourt("framboise"); // "framboise" es $container, no $flavour
?>
El resultado del ejemplo sería:
Fatal error: Uncaught ArgumentCountError: Too few arguments
to function hacerunyaourt(), 1 passed in example.php on line 42
Ahora compare el ejemplo anterior con el siguiente ejemplo:
Ejemplo #7 Uso correcto de los parámetros de función por defecto
<?php
function hacerunyaourt ($flavour, $container = "bol")
{
return "Preparar un $container de yaourt a la $flavour.\n";
}
echo hacerunyaourt ("framboise"); // "framboise" es $flavour
?>
El resultado del ejemplo sería:
Preparar un bol de yaourt a la framboise.
A partir de PHP 8.0.0, los argumentos nombrados
pueden ser utilizados para pasar por alto varios parámetros opcionales.
Ejemplo #8 Uso correcto de los parámetros de función por defecto
<?php
function hacerunyaourt($container = "bol", $flavour = "framboise", $style = "Grec")
{
return "Preparar un $container de yaourt $style a la $flavour.\n";
}
echo hacerunyaourt(style: "naturel");
?>
El resultado del ejemplo sería:
Preparar un bol de yaourt naturel a la framboise.
A partir de PHP 8.0.0, declarar parámetros obligatorios después de argumentos opcionales es obsoleto.
Este problema puede generalmente ser resuelto abandonando el valor por defecto, ya que nunca será utilizado.
Una excepción a esta regla concierne a los parámetros de la forma Type $param = null,
donde el null por defecto hace el tipo implícitamente nullable.
Este uso es deprecado desde PHP 8.4.0, y un
tipo nullable
explícito debe ser utilizado en su lugar.
Ejemplo #9 Declaración de parámetros opcionales después de parámetros obligatorios
<?php
function foo($a = [], $b) {} // Valor por defecto no utilizado; deprecado 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 implícitamente requerido
// (porque precede a un parámetro requerido),
// pero implícitamente nullable (deprecado a partir de PHP 8.4.0),
// porque el valor por defecto del parámetro es null
function bar(?A $a, $b) {} // Recomendado
?>
Nota:
A partir de PHP 7.1.0, la omisión de un parámetro que no especifica un valor por defecto lanza
un ArgumentCountError;
en versiones anteriores, esto levantaba una advertencia.
Nota:
Los argumentos pasados por referencia pueden tener
una valor por defecto.
Lista de argumentos de número variable
PHP soporta los argumentos de número variable en las
funciones definidas por el usuario utilizando el token
....
La lista de argumentos puede incluir el
token ... para indicar que esta función acepta
un número variable de argumentos. Los argumentos serán pasados en la variable
proporcionada en forma de un array:
Ejemplo #10 Uso de ... para acceder a los argumentos variables
<?php
function sum(...$numbers) {
$acc = 0;
foreach ($numbers as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
El resultado del ejemplo sería:
... puede también ser utilizado durante las llamadas de
funciones para extraer el array o la variable
Traversable o el literal en la lista de argumentos:
Ejemplo #11 Uso de ... 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:
Se pueden especificar parámetros clásicos antes de la palabra clave
.... En este caso, solo los argumentos finales
que no corresponden a un argumento clásico serán añadidos
al array generado por ....
También es posible añadir una
declaración de tipo
antes del token .... Si esto está presente,
entonces todos los argumentos capturados por ...
deben corresponder al tipo de parámetro.
Ejemplo #12 Transtipado de argumentos variables
<?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á, porque null no es un objeto DateInterval.
echo total_intervals('d', null);
?>
El resultado del ejemplo sería:
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
Finalmente, se pueden pasar argumentos variables
por referencia
prefijando la palabra clave ... de un ET comercial
(&).
Argumentos Nominados
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 el orden de los argumentos independiente y permite omitir
los valores por defecto arbitrariamente.
Los argumentos nombrados son pasados 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,
especificarlo de manera dinámica no está permitido.
Ejemplo #13 Sintaxis de los argumentos nombrados
<?php
myFunction(paramName: $value);
array_foobar(array: $value);
// NO soportado.
function_name($variableStoringParamName: $value);
?>
Ejemplo #14 Argumentos posicionales comparados con argumentos nombrados
<?php
// Utilizando los argumentos posicionales:
array_fill(0, 100, 50);
// Utilizando los argumentos nombrados:
array_fill(start_index: 0, count: 100, value: 50);
?>
El orden en el que los argumentos nombrados son pasados no importa.
Ejemplo #15 Mismo ejemplo que el anterior, pero con un orden de parámetro diferente
<?php
array_fill(value: 50, count: 100, start_index: 0);
?>
Los argumentos nombrados pueden ser combinados con los argumentos posicionales.
En cuyo 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.
Ejemplo #16 Combinar los argumentos nombrados con los argumentos posicionales
<?php
htmlspecialchars($string, double_encode: false);
// Same as
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>
Pasar el mismo argumento varias veces resulta en una
Error excepción.
Ejemplo #17 Error lanzado cuando un argumento es pasado varias veces al mismo parámetro nombrado
<?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
?>
A partir de PHP 8.1.0, es posible utilizar argumentos nombrados después de haber descomprimido los argumentos.
Un argumento nombrado no debe sobrescribir un argumento ya descomprimido.
Ejemplo #18 Uso de argumentos nombrados después de la descompresión
<?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.
?>
