Параметры и аргументы функции
Параметры определяют в сигнатуре функции. Информацию в параметры функции передают в списке аргументов.
Список аргументов состоит из выражений, которые разделили запятыми. Функция вычислит выражения
в списке аргументов и присвоит значения параметрам. Значения вычисляются слева направо
перед действительным вызовом функции. Такое вычисление называется энергичным.
PHP поддерживает передачу аргументов по значению (по умолчанию)
и по ссылке,
и значения по умолчанию.
Списки аргументов
переменной длины и именованные
аргументы также поддерживаются.
Пример #1 Передача массивов в функции
<?php
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0] + $input[1];
}
?>
Начиная с PHP 8.0.0 списку аргументов функции разрешается включать конечную
запятую, которую парсер проигнорирует. Это полезно, когда список аргументов
длинный или содержит длинные имена переменных, что в целях удобства подталкивает
к вертикальному перечислению аргументов.
Пример #2 Список параметров функции с запятой в конце
<?php
function takes_many_args(
$first_arg,
$second_arg,
$a_very_long_argument_name,
$arg_with_default = 5,
$again = 'a default string', // До PHP 8.0.0 указывать запятую в конце списка не разрешали
) {
// ...
}
?>
Передача аргументов по ссылке
По умолчанию аргументы передаются в функцию по значению. Поэтому
если значение параметра внутри функции изменится, значение
переменной, в которой передали аргумент, не изменится за пределами функции.
Аргументы передают по ссылке, чтобы разрешить функции изменять значения аргументов.
В описании функции перед именем параметра указывают амперсанд &,
когда требуется передача аргумента по ссылке:
Пример #3 Передача аргументов по ссылке
<?php
function add_some_extra(&$string)
{
$string .= 'и кое-что ещё.';
}
$str = 'Это строка, ';
add_some_extra($str);
echo $str; // Конструкция выведет «Это строка, и кое-что ещё.»
?>
Передача константного значения в параметр, который ожидает значение по ссылке, вызовет ошибку.
Значения по умолчанию для параметров
Функция умеет определять для параметров значения по умолчанию,
в этом помогает синтаксис, который похож на синтаксис присваивания значения переменной.
Функция присвоит параметру значение по умолчанию, только если
в параметр не передали аргумент;
обратите внимание, функция не присваивает
параметру значение по умолчанию при передаче в параметр аргумента со значением null.
Пример #4 Значения по умолчанию для параметров функций
<?php
function makecoffee($type = "капучино")
{
return "Готовим чашку $type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("эспрессо");
?>
Результат выполнения приведённого примера:
Готовим чашку капучино.
Готовим чашку .
Готовим чашку эспрессо.
Значениями по умолчанию для параметров разрешается указывать скалярные значения,
массивы (array), специальный тип null и начиная с PHP 8.1.0 объекты,
которые создают синтаксисом new ClassName().
Пример #5 Нескалярные типы как значения по умолчанию
<?php
function makecoffee($types = array("капучино"), $coffeeMaker = NULL)
{
$device = is_null($coffeeMaker)
? "вручную"
: $coffeeMaker
;
return "Готовлю чашку " . join(", ", $types) . " $device. \n";
}
echo makecoffee();
echo makecoffee(array("капучино", "лавацца"), "в чайнике");
?>
Результат выполнения приведённого примера:
Готовлю чашку капучино вручную.
Готовлю чашку капучино, лавацца в чайнике.
Пример #6
Объекты как значения по умолчанию, с PHP 8.1.0
<?php
class DefaultCoffeeMaker
{
public function brew()
{
return "Приготовление кофе.\n";
}
}
class FancyCoffeeMaker
{
public function brew()
{
return "Приготовление прекрасного кофе только для вас.\n";
}
}
function makecoffee($coffeeMaker = new DefaultCoffeeMaker())
{
return $coffeeMaker->brew();
}
echo makecoffee();
echo makecoffee(new FancyCoffeeMaker);
?>
Результат выполнения приведённого примера:
Приготовление кофе.
Приготовление прекрасного кофе только для вас.
Объект как значение по умолчанию разрешается определять только константным выражением,
а не переменной, вызовом функции или метода класса.
Обратите внимание, необязательные параметры потребуется указать
после обязательных, иначе необязательные аргументы
не получится опустить при вызове, поскольку функция рассматривает необязательные параметры,
которые указали перед обязательными, как обязательные.
Рассмотрим следующий пример:
Пример #7
Неправильное определение значений по умолчанию
для параметров функции
<?php
function makeyogurt($container = "миску", $flavour)
{
return "Делаем $container с $flavour йогуртом.\n";
}
echo makeyogurt("малиновым"); // Значение «малиновым» получит параметр $container, а не параметр $flavour
?>
Результат выполнения приведённого примера:
Fatal error: Uncaught ArgumentCountError: Too few arguments
to function makeyogurt(), 1 passed in example.php on line 42
Теперь сравним приведённый пример со следующим примером:
Пример #8
Правильное определение значений по умолчанию
для параметров функции
<?php
function makeyogurt($flavour, $container = "миску")
{
return "Делаем $container с $flavour йогуртом.\n";
}
echo makeyogurt("малиновым"); // Значение «малиновым» получит параметр $flavour
?>
Результат выполнения приведённого примера:
Делаем миску с малиновым йогуртом.
Начиная с PHP 8.0.0 для пропуска необязательных параметров
передают именованные аргументы.
Пример #9
Правильное определение значений по умолчанию
для параметров функции
<?php
function makeyogurt($container = "миску", $flavour = "малиновым", $style = "греческим")
{
return "Делаем $container с $flavour $style йогуртом.\n";
}
echo makeyogurt(style: "натуральным");
?>
Результат выполнения приведённого примера:
Делаем миску с малиновым натуральным йогуртом.
С PHP 8.0.0 объявление обязательных параметров после необязательных
устарело.
Часто из таких ситуаций выходят путём отказа от значения по умолчанию,
поскольку функция никогда не присвоит параметру, в который передали аргумент,
значение по умолчанию.
Исключение из этого правила — параметры вида Type $param = null,
где значение null по умолчанию делает тип неявно обнуляемым.
Такое определение устарело с PHP 8.4.0
и теперь обнуляемый тип
потребуется указать явно.
Пример #10
Объявление необязательных параметров после обязательных
<?php
function foo($a = [], $b) {} // Функция никогда не присвоит значение по умолчанию;
// определение значения по умолчанию для параметра, который идёт
// перед обязательным, устарело с PHP 8.0.0
function foo($a, $b) {} // Определение функционально эквивалентно, но не выдаёт уведомление об устаревании
function bar(A $a = null, $b) {} // С PHP 8.1.0 параметр $a неявно обязателен, поскольку идёт перед обязательным,
// но неявно обнуляем, поскольку для параметра определили значение по умолчанию null.
// Объявления значения по умолчанию null
// без указания обнуляемого типа устарело с PHP 8.4.0
function bar(?A $a, $b) {} // Определение, которое рекомендуют
?>
Замечание:
Начиная с PHP 7.1.0 пропуск аргумента для параметра, для которого не задали
значение по умолчанию, выбрасывает исключение
ArgumentCountError;
в предыдущих версиях выдавалось предупреждение.
Замечание:
Для параметров, которые ждут аргумент по ссылке,
разрешается устанавливать значения по умолчанию.
Списки аргументов переменной длины
В пользовательских функциях PHP поддерживает списки аргументов
переменной длины, параметры для которых определяют оператором из трёх точек
..., который называется spread-оператором.
Списку параметров разрешается содержать оператор
..., чтобы показать, что функция принимает переменное
количество аргументов. Переменная получит аргументы как массив:
Пример #11
Оператор ... для доступа к аргументам
<?php
function sum(...$numbers) {
$acc = 0;
foreach ($numbers as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
Результат выполнения приведённого примера:
Spread-оператор ... указывают также при вызове функции,
чтобы распаковать в список аргументов массив (array),
или распаковать переменную или литерал, которые принадлежат типу
Traversable:
Пример #12
Передача аргументов со spread-оператором ...
<?php
function add($a, $b) {
return $a + $b;
}
echo add(...[1, 2])."\n";
$a = [1, 2];
echo add(...$a);
?>
Результат выполнения приведённого примера:
Стандартные позиционные параметры разрешается указывать перед токеном ...,
тогда оператор ... сгенерирует и добавит в массив только конечные аргументы,
которые не соответствуют позиционным.
Перед оператором ... разрешается также добавлять
объявление типа.
Тогда функция проверит, что аргументы, которые захватил оператор ...,
соответствуют типу параметра, или выбросит ошибку.
Пример #13 Объявление типа для параметра, который ожидает аргументы переменной длины
<?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';
// Это не сработает, поскольку null — не объект класса DateInterval
echo total_intervals('d', null);
?>
Результат выполнения приведённого примера:
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
В финале добавим, что аргументы переменной длины разрешается также передавать
по ссылке,
для этого перед оператором ... указывают амперсанд
(&).
Именованные аргументы
В PHP 8.0.0 как расширение позиционных параметров появились именованные аргументы.
Именованные аргументы передаются в функцию на основе имени, а не позиции параметра.
Назначение аргумента документирует само себя, аргументы перестают зависеть от порядка,
в котором передаются, и разрешается произвольно пропускать значения по умолчанию.
Именованные аргументы передают по названию параметра, за которым идёт
двоеточие и значение аргумента.
Зарезервированные ключевые слова разрешается указывать как имена параметров.
Название параметра потребуется указать как идентификатор, нельзя указывать динамические имена
параметров.
Пример #14 Синтаксис именованного аргумента
<?php
myFunction(paramName: $value);
array_foobar(array: $value);
// НЕ поддерживается
function_name($variableStoringParamName: $value);
?>
Пример #15
Сравнение позиционных и именованных аргументов
<?php
// Передача позиционных аргументов:
array_fill(0, 100, 50);
// Передача именованных аргументов:
array_fill(start_index: 0, count: 100, value: 50);
?>
Порядок передачи именованных аргументов неважен.
Пример #16
Тот же пример, но с другим порядком аргументов
<?php
array_fill(value: 50, count: 100, start_index: 0);
?>
Именованные аргументы разрешается комбинировать с позиционными.
Тогда именованные аргументы потребуется передать после позиционных.
Разрешается также передавать только часть необязательных аргументов
функции в произвольном порядке.
Пример #17
Объединение именованных аргументов с позиционными аргументами
<?php
htmlspecialchars($string, double_encode: false);
// То же самое
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>
Передача одного и того же аргумента больше одного раза
выбросит ошибку Error.
Пример #18
Ошибка, которая возникает при передаче одного и того же параметра
больше одного раза
<?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
?>
Начиная с PHP 8.1.0 разрешается передавать именованные аргументы
после распаковки аргументов. Именованный аргумент не должен
переопределять распакованный аргумент.
Пример #19
Передача именованных аргументов после распаковки
<?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)); // Fatal error: Named parameter $b overwrites previous argument
?>
