В данном уроке мы подробно изучим такое понятие как функция. Функции PHP - это блок кода, который может принимать разные аргументы и обработав их возвращать измененные данные. Функции являются довольно сильным инструментом для многократного использования одного кода.
В PHP существуют следующие типы функций:
- Встроенные.
- Пользовательские.
Встроенные функции
Сильной стороной PHP является то, что в ней есть множество встроенных функций. С их помощью можно решать многие задачи. Например, в следующем примере с помощью встроенной функции «str_replace» мы уберем ненужные символы с текста.
<?php
$myText = "Этот<br> день <br>был<br> очень <br>жарким";
echo $myText;
$myText = str_replace("<br>","",$myText);
echo $myText;
?>
Если во втором параметре «str_replace» установить какой нибудь символ, то он вставится на место убираемого символа.
Пользовательские функции
Пользовательские функции - это функции, которые вы создаете сами своими руками. Далее рассмотрим его синтаксис.
Синтаксис функций
function английское_название(){
блок кода с инструкциями
}
С определения функции начинается ее создание. И первым прописывается слово «function». Далее в названии функции обязательным первым символом должна быть английская буква или нижнее подчеркивание, дальше можно прописать цифры. Название не должно совпадать с другими именами или с именами встроенных функций. После названия идут круглые скобки и в них можно прописать любое количество аргументов — локальных переменных. Затем идут фигурные скобки внутри которых устанавливается основной код.
Давайте определим простую функцию:
<?php
function myFirstFunc(){
echo "Моя первая программа";
}
?>
После написания программы, необходимо ее вызвать. Чтобы ее вызвать надо прописать название функции с круглыми скобками.
<?php
myFirstFunc(); //Вызов функции
function myFirstFunc(){
echo "Моя первая программа";
}
?>
Если на экране вы видите «Моя первая программа», значит вызов функции прошло успешно. Этот вызов можно ставить, и спереди, и позади функции. Но бывают ситуации когда спереди их нельзя ставить и сейчас разберем такие примеры.
<?php
$perem="start";
//myFirstFunc_2(); //Этот вызов приведет к ошибке. Раскомментируйте, чтобы проверить.
if($perem){
//засекреченная функция внутри условия
function myFirstFunc_2(){
echo "Моя первая программа-2<br>";
}
}
myFirstFunc_2(); //Правильный вызов
//myFirstFunc_3(); //Этот вызов приведет к ошибке. Раскомментируйте, чтобы проверить.
myFirstFunc(); //Благодаря этому вызову - определена myFirstFunc_3
myFirstFunc_3(); //Правильный вызов.
function myFirstFunc(){
//засекреченная функция внутри функции
function myFirstFunc_3(){
echo "Моя первая программа-3<br>";
}
}
?>
Функция внутри условия или другой функции является как бы засекреченной или скрытой от интерпретатора PHP. И до тех пор пока он не прочтет это условие или функцию, наша засекреченная функция ему неизвестна (значит не определена). Поэтому вызов засекреченной функции, перед условием или вызовом функции в которой она заключена, приведет к ошибке.
Аргументы функции
Аргументы - это локальные переменные внутри функции, с их помощью передают данные для обработки в функцию. Аргументы (параметры) прописываются через запятую. Параметрами могут быть разные типы данных:
- массивы;
- строки;
- цифры;
- логические значения (true или false);
- значение NULL.
<?php
$array=["Мне","исполнилось"];
$num=36;
$str_x="лет";
getData($array,$num,$str_x);
function getData($param_1,$param_2,$param_3){
echo $param_1[0]." ".$param_1[1]." ".$param_2." ".$param_3; //Выводит "Мне исполнилось 36 лет"
}
?>
Для параметров можно задавать значение по умолчанию:
<?php
$array=["Мне","исполнилось"];
getData($array);
function getData($param_1,$param_2=36,$param_3="лет"){
echo $param_1[0]." ".$param_1[1]." ".$param_2." ".$param_3; //Выводит "Мне исполнилось 36 лет"
}
?>
Как видите, задавая значения по умолчанию вы можете не указывать эти аргументы при вызове функции «getData($array)».
Если вы задаете аргументы по умолчанию, то прописывайте их после параметров у которых нет значений по умолчанию. Иначе это приведет к ошибкам.
Также в параметрах можно отправлять другие функции.
<?php
$str_x = "Сегодня";
$str_y = "прекрасная";
$str_func = "get_text"; //В переменную вложена функция
getData($str_x,$str_y,$str_func);
function getData($param_1,$param_2,$param_3){
echo $param_1." ".$param_2." ".$param_3(); //Выводит "Сегодня прекрасная погода"
}
function get_text(){
return "погода"; //Вернет "погода"
}
?>
Передача аргументов по ссылке
Для передачи параметров по ссылке нужно перед аргументом прописать ссылку «&». Чтобы понять зачем она нужна рассмотрим следующий пример:
<?php
$str_x = &$str_y;
$str_x = "Результат ссылки";
echo $str_y; //"Результат ссылки"
?>
Как видите из примера мы присвоили значение только одной переменной «$str_x», а вывели на экран другую переменную «$str_y» у которой было пустое значение. Но благодаря ссылке значение обоих переменных стало общим и при изменении значения одной переменной изменяется значение другой.
Другой пример с функцией:
<?php
function getSymma(&$num_x) {
$num_x+=5;
//Без «return $num_x;»
}
$number = 10;
getSymma($number);
echo $number; //Выводит 15, без ссылки "&" выводит 10
?>
Здесь для получения результата (15) нужен «return» в функции «getSymma» и присвоение «getSymma($number)» переменной «$number», но с ссылкой «&» все это не нужно прописывать. В итоге получается более короткий код.
Объявление типов
С помощью объявления типов можно задавать функциям PHP типы принимаемых аргументов. И при вызове функции отправленные параметры будут автоматически приводится к указанным типам. В следующих примерах мы подробно разберем это:
<?php
function getTypeData(string $str_x, int $num_x, int $num_y) {
if(is_string($str_x)){
echo "$str_x - Это строковый тип!!!<br>"; //Выводит «Моя строка - Это строковый тип!!!»
}
if(is_int($num_x)){
echo "$num_x - Это тип целое число!!!<br>"; //Выводит «4 - Это тип целое число!!!»
}
if(is_int($num_y)){
echo "$num_y - Это тип целое число!!!"; //Выводит «2 - Это тип целое число!!!»
}
}
getTypeData("Моя строка", 4, 2.5);
?>
В этом примере было отправлено три параметра: строка, целое число и число с типом «float». Но в параметрах функции в третьем аргументе мы указали тип int (целое число), а не float (число с плавающий запятой). В итоге мы всё равно получили в третьем параметре целое число. Это происходит потому что не было задано строгая типизация и код автоматически изменил тип float на тип int. Такое автоматическое приведение типов данных происходит только с числовыми значениями.
Давайте теперь попробуем использовать строгую типизацию «declare(strict_types=1)» — оно должно быть прописано в самом начале, перед ним не должно быть других кодов:
<?php
declare(strict_types=1); //задаем строгую типизацию
//Выводит ошибку т.к. третий параметр является int, а не float
function getTypeData(string $str_x, int $num_x, int $num_y) {
if(is_string($str_x)){
echo "$str_x - Это строковый тип!!!<br>";
}
if(is_int($num_x)){
echo "$num_x - Это тип целое число!!!<br>";
}
if(is_int($num_y)){
echo "$num_y - Это тип целое число!!!";
}
}
getTypeData("Моя строка", 4, 2.5); //Третий параметр float
?>
Задав значение «strict_types=1» через функцию «declare» мы указали строгую типизацию в наших кодах (это не действует в функциях расположенных внутри других функций) и если тип переданного параметра не будет соответствовать, то это приведет к ошибке.
В итоге наш пример вывел ошибку, если хотите эту ошибку исправить измените третий параметр определения функции с int на float.
<?php
declare(strict_types=1); //задаем строгую типизацию
function getTypeData(string $str_x, int $num_x, float $num_y) {
if(is_string($str_x)){
echo "$str_x - Это строковый тип!!!<br>"; //Выводит «Моя строка - Это строковый тип!!!»
}
if(is_int($num_x)){
echo "$num_x - Это тип целое число!!!<br>"; //Выводит «4 - Это тип целое число!!!»
}
if(is_float($num_y)){
echo "$num_y - Это тип число с плавающей запятой!!!"; //Выводит «2 - Это тип число с плавающей запятой!!!»
}
}
getTypeData("Моя строка", 4, 2.5);
?>
Если в определении функции есть параметр с типом float, то для таких типов есть исключение и он вполне может принимать данные с типом int:
<?php
declare(strict_types=1); //задаем строгую типизацию
function getTypeData(float $num_y) {
if(is_float($num_y)){
echo "$num_y - Это тип число с плавающей запятой!!!"; //Выводит «2 - Это тип число с плавающей запятой!!!»
}
}
getTypeData(2);
?>
Здесь функция getTypeData не только приняло параметр с типом целого числа, но это целое число также прошла проверку на is_float (число с плавающей запятой).
Список аргументов переменной длины
Этот список параметров прописывается через многоточие и данный аргумент по сути является массивом переменных.
<?php
function myText(...$array_data) {
$str_text = "";
foreach ($array_data as $val) {
$str_text .= $val." ";
}
return $str_text;
}
echo myText("Сегодня", 21, "сентября"); //Выводит «Сегодня 21 сентября»
?>
Также эти точки можно ставить в вызове функции отправляя в параметре один массив со всеми аргументами:
<?php
function myText($str_x,$num_x,$str_y) {
return $str_x." ".$num_x." ".$str_y;
}
$array_data = ["Сегодня", "прекрасная", "погода"];
echo myText(...$array_data); //Выводит «Сегодня прекрасная погода»
?>
Возврат значений
Для возвращения значения из функции используется оператор return. После команды return выполнение кода прерывается и обработанное значение возвращается на место вызова функции.
<?php
function getReturnData() {
$num_x = 33*4;
return $num_x;
}
echo "До моего дома осталось пройти ".getReturnData()." метра"; //Выводит «До моего дома осталось пройти 132 метра»
?>
Иногда return применяют как стоп флаг, чтобы прервать работу функции.
В PHP функциях возвращаемым значениям можно указать тип возвращаемых данных. В этом случае возвращаемые данные будут приводится к указанному типу, если это возможно.
<?php
function getSymma($num_x, $num_y): int {
return $num_x * $num_y;
}
var_dump(getSymma(3.5, 6.5)); //var_dump выводит тип и значение «int(22)»
?>
В данном примере тип чисел с плавающей запятой (float) при возвращении было автоматически изменено на тип целых чисел (int). Такое возможно только с числовыми типами, с другими типами выйдет ошибка.
Можно установить строгую типизацию данных, тогда необходимо прописывать параметры которые возвращали бы соответствующие типы. Иначе выйдет ошибка.
<?php
declare(strict_types=1); //задан строгий тип
function get_data($perem_x, $perem_y): string {
$data=false;
if(is_int($perem_x) && is_int($perem_y)){
$data=$perem_x+$perem_y;
}else{
$data=$perem_x.$perem_y;
}
return $data;
}
var_dump(get_data("Это цифра ", 7)); //var_dump выводит тип и значение «string(19) "Это цифра 7"»
var_dump(get_data(6, 7)); //Выйдет ошибка Fatal error
?>
Возвращаемые типы можно обнулить установив знак «?» перед названием типа. В этом случае вызов функции вернет, или значение соответствующего типа, или обнулит в NULL.
<?php
declare(strict_types=1); //задан строгий тип
function get_data($perem_x, $perem_y): ?string {
$data=false;
if(is_string($perem_x) && is_int($perem_y)){
$data=$perem_x.$perem_y;
}else{
$data=NULL;
}
return $data;
}
var_dump(get_data("Это цифра ", 7)); //var_dump выводит тип и значение «string(19) "Это цифра 7"»
var_dump(get_data(6, 7)); //Выйдет «NULL»
?>
Если убрать символ «?» перед названием типа в данной функции, то это приведет к ошибке во втором вызове «get_data(6, 7)». Поэтому в такой ситуации применение вопросительного знака перед типом возвращаемого значения решает эту проблему.
Вызов функций через переменные
В PHP можно вызывать функцию через переменную.
<?php
function getFuncX($str_x){
echo $str_x."<br>";
}
function getFuncY($str_y){
return $str_y;
}
$perem = "getFuncX";
$perem("Вызов getFuncX"); //Выводит «Вызов getFuncX»
$perem = "getFuncY";
echo $perem("Вызов getFuncY"); //Выводит «Вызов getFuncY»
?>
Здесь оба вызова успешно выполнены и вывели данные на экран. Вызывая функцию через переменную по сути изменяется только ее название, все остальное остаётся тоже самое.
Анонимные функции PHP
Анонимными являются функции у которых нет названия, по другому они еще называются замыканиями. Их можно передавать в качестве параметров другим функциям или присваивать переменным. Далее рассмотрим следующие примеры:
<?php
$str_x=function ($str_y){return "У моей машины ".$str_y." цвет";}
echo $str_x("синий");
?>
Тут мы присвоили анонимную функцию с одним параметром "$str_y" переменной «$str_x». После этого вызвали ее через эту переменную «$str_x» прописав скобки и вложив значение.
<?php
function getMultiply($num_x, $num_y){
return $num_x * $num_y(5);
}
echo getMultiply(4, function ($num_y){return $num_y * 3;});
?>
В этом примере мы вызвали обычную функцию «getMultiply» вложив два аргумента число и анонимную функцию. Внутри «getMultiply» произошел вызов нашей анонимной функции через локальную переменную «$num_y(5)» с вложенным аргументом 5. В итоге после всех вычислений получили результат 60.
Функции function_exists и get_defined_functions
Эти встроенные функции «function_exists» и «get_defined_functions» можно использовать для проверки наличия пользовательских или встроенных функций.
- function_exists — возвращает true, если данное название функции существует иначе вернет false.
<?php
function search_function(){
return "Функция search_function существует!!!";
}
if(function_exists("search_function")){
echo search_function();
}
?>
- get_defined_functions — вернет двумерный ассоциативный массив с двумя названиями «$array_func["internal"]» и «$array_func["user"]».
<?php
$array_func=get_defined_functions();
echo implode("<br>",$array_func["internal"]); //Выводит все используемые встроенные функции
echo implode("<br>",$array_func["user"]); //Выводит все используемые пользовательские функции
?>
Для «$array_func["user"]» не забудьте прописать одну или две пользовательские функции, чтобы увидеть результат.
На этом данный урок завершается, свои вопросы по нему напишите в комментариях.