Parámetros y argumentos de función

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 inmediata).

PHP soporta el paso de argumentos por valor (comportamiento por defecto), el paso por referencia, y valores por defecto de argumentos. Una lista de argumentos variable, así como los Argumentos Nombrados también son 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:

<?php
$v
= foo(
$arg_1,
$arg_2,
);
?>

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.

Ejemplo #1 Lista de parámetros de 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 los valores de los argumentos, estos argumentos deben ser pasados por referencia.

Si se desea que un argumento sea siempre pasado por referencia, se puede añadir un '&' delante 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 un string';
add_some_extra($str);
echo
$str; // Muestra: 'Esto es un string, y un poco más.'
?>

Es incorrecto pasar una expresión constante como argumento a un parámetro que espera ser pasado por referencia.

Valores por defecto de parámetros

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 define el valor por defecto.

Ejemplo #3 Valor por defecto de 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 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 café bonito 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 café bonito solo para usted.

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.

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 parámetros de función por defecto

<?php
function hacerunyaourt ($container = "bol", $flavour)
{
return
"Preparar un $container de yogur 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 comparemos el ejemplo anterior con el siguiente:

Ejemplo #7 Uso correcto de parámetros de función por defecto

<?php
function hacerunyaourt ($flavour, $container = "bol")
{
return
"Preparar un $container de yogur a la $flavour.\n";
}

echo
hacerunyaourt ("framboise"); // "framboise" es $flavour
?>

El resultado del ejemplo sería:

Preparar un bol de yogur 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 parámetros de función por defecto

<?php
function hacerunyaourt($container = "bol", $flavour = "framboise", $style = "Grec")
{
return
"Preparar un $container de yogur $style a la $flavour.\n";
}
echo
hacerunyaourt(style: "natural");
?>

El resultado del ejemplo sería:

Preparar un bol de yogur natural 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 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 Type $param = null, donde el null por defecto hace el tipo implicitamente nullable. Este uso está 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; 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

?>

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 generaba una advertencia.

Nota: Los argumentos pasados por referencia pueden tener un valor por defecto.

Lista de argumentos de número variable

PHP soporta 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 a la variable proporcionada en forma de un array:

Ejemplo #10 Uso de ... para acceder a 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:

10

... también puede 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:

3
3

Se pueden especificar parámetros clásicos antes de la palabra clave .... En este caso, solo los argumentos finales que no coincidan con 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 coincidir con el tipo de parámetro.

Ejemplo #12 Conversión 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á, ya que 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 ... con un comercial (&).

Argumentos Nombrados

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.

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.

Ejemplo #13 Sintaxis de 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 argumentos posicionales:
array_fill(0, 100, 50);

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

El orden en el que se pasan los argumentos nombrados no importa.

Ejemplo #15 Mismo ejemplo que arriba, 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 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.

Ejemplo #16 Combinar argumentos nombrados con argumentos posicionales

<?php
htmlspecialchars
($string, double_encode: false);
// Igual que
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 descomponer los argumentos. Un argumento nombrado no debe sobrescribir un argumento ya descompuesto.

Ejemplo #18 Utilizar argumentos nombrados después de la descomposició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.
?>
add a note

User Contributed Notes 8 notes

up
134
php at richardneill dot org
10 years ago
To experiment on performance of pass-by-reference and pass-by-value, I used this script. Conclusions are below.

#!/usr/bin/php
<?php
function sum($array,$max){ //For Reference, use: "&$array"
$sum=0;
for (
$i=0; $i<2; $i++){
#$array[$i]++; //Uncomment this line to modify the array within the function.
$sum += $array[$i];
}
return (
$sum);
}

$max = 1E7 //10 M data points.
$data = range(0,$max,1);

$start = microtime(true);
for (
$x = 0 ; $x < 100; $x++){
$sum = sum($data, $max);
}
$end = microtime(true);
echo
"Time: ".($end - $start)." s\n";

/* Run times:
# PASS BY MODIFIED? Time
- ------- --------- ----
1 value no 56 us
2 reference no 58 us

3 valuue yes 129 s
4 reference yes 66 us

Conclusions:

1. PHP is already smart about zero-copy / copy-on-write. A function call does NOT copy the data unless it needs to; the data is
only copied on write. That's why #1 and #2 take similar times, whereas #3 takes 2 million times longer than #4.
[You never need to use &$array to ask the compiler to do a zero-copy optimisation; it can work that out for itself.]

2. You do use &$array to tell the compiler "it is OK for the function to over-write my argument in place, I don't need the original
any more." This can make a huge difference to performance when we have large amounts of memory to copy.
(This is the only way it is done in C, arrays are always passed as pointers)

3. The other use of & is as a way to specify where data should be *returned*. (e.g. as used by exec() ).
(This is a C-like way of passing pointers for outputs, whereas PHP functions normally return complex types, or multiple answers
in an array)

4. It's unhelpful that only the function definition has &. The caller should have it, at least as syntactic sugar. Otherwise
it leads to unreadable code: because the person reading the function call doesn't expect it to pass by reference. At the moment,
it's necessary to write a by-reference function call with a comment, thus:
$sum = sum($data,$max); //warning, $data passed by reference, and may be modified.

5. Sometimes, pass by reference could be at the choice of the caller, NOT the function definitition. PHP doesn't allow it, but it
would be meaningful for the caller to decide to pass data in as a reference. i.e. "I'm done with the variable, it's OK to stomp
on it in memory".
*/
?>
up
12
Simmo at 9000 dot 000
3 years ago
For anyone just getting started with php or searching, for an understanding, on what this page describes as a "... token" in Variable-length arguments:
https://www.php.net/manual/en/functions.arguments.php#functions.variable-arg-list
<?php

func
($a, ...$b)

?>
The 3 dots, or elipsis, or "...", or dot dot dot is sometimes called the "spread operator" in other languages.

As this is only used in function arguments, it is probably not technically an true operator in PHP. (As of 8.1 at least?).

(With having an difficult to search for name like "... token", I hope this note helps someone).
up
19
LilyWhite
3 years ago
It is worth noting that you can use functions as function arguments

<?php
function run($op, $a, $b) {
return
$op($a, $b);
}

$add = function($a, $b) {
return
$a + $b;
};

$mul = function($a, $b) {
return
$a * $b;
};

echo
run($add, 1, 2), "\n";
echo
run($mul, 1, 2);
?>

Output:
3
2
up
28
gabriel at figdice dot org
8 years ago
A function's argument that is an object, will have its properties modified by the function although you don't need to pass it by reference.

<?php
$x
= new stdClass();
$x->prop = 1;

function
f ( $o ) // Notice the absence of &
{
$o->prop ++;
}

f($x);

echo
$x->prop; // shows: 2
?>

This is different for arrays:

<?php
$y
= [ 'prop' => 1 ];

function
g( $a )
{
$a['prop'] ++;
echo
$a['prop']; // shows: 2
}

g($y);

echo
$y['prop']; // shows: 1
?>
up
13
Hayley Watson
7 years ago
There are fewer restrictions on using ... to supply multiple arguments to a function call than there are on using it to declare a variadic parameter in the function declaration. In particular, it can be used more than once to unpack arguments, provided that all such uses come after any positional arguments.

<?php

$array1
= [[1],[2],[3]];
$array2 = [4];
$array3 = [[5],[6],[7]];

$result = array_merge(...$array1); // Legal, of course: $result == [1,2,3];
$result = array_merge($array2, ...$array1); // $result == [4,1,2,3]
$result = array_merge(...$array1, $array2); // Fatal error: Cannot use positional argument after argument unpacking.
$result = array_merge(...$array1, ...$array3); // Legal! $result == [1,2,3,5,6,7]
?>

The Right Thing for the error case above would be for $result==[1,2,3,4], but this isn't yet (v7.1.8) supported.
up
14
boan dot web at outlook dot com
7 years ago
Quote:

"The declaration can be made to accept NULL values if the default value of the parameter is set to NULL."

But you can do this (PHP 7.1+):

<?php
function foo(?string $bar) {
//...
}

foo(); // Fatal error
foo(null); // Okay
foo('Hello world'); // Okay
?>
up
6
Luna
2 years ago
When using named arguments and adding default values only to some of the arguments, the arguments with default values must be specified at the end or otherwise PHP throws an error:

<?php

function test1($a, $c, $b = 2)
{
return
$a + $b + $c;
}

function
test2($a, $b = 2, $c)
{
return
$a + $b + $c;
}

echo
test1(a: 1, c: 3)."\n"; // Works
echo test2(a: 1, c: 3)."\n"; // ArgumentCountError: Argument #2 ($b) not passed

?>

I assume that this happens because internally PHP rewrites the calls to something like test1(1, 3) and test2(1, , 3). The first call is valid, but the second obviously isn't.
up
5
Hayley Watson
7 years ago
If you use ... in a function's parameter list, you can use it only once for obvious reasons. Less obvious is that it has to be on the LAST parameter; as the manual puts it: "You may specify normal positional arguments BEFORE the ... token. (emphasis mine).

<?php
function variadic($first, ...$most, $last)
{
/*etc.*/}

variadic(1, 2, 3, 4, 5);
?>
results in a fatal error, even though it looks like the Thing To Do™ would be to set $first to 1, $most to [2, 3, 4], and $last to 5.
To Top