Как написать функцию на php - Правописание и грамматика

Функции

Содержание

Функции, определяемые пользователем
Аргументы функции
Возврат значений
Обращение к функциям через переменные
Встроенные функции
Анонимные функции
Стрелочные функции
Callback-функции как объекты первого класса

There are no user contributed notes for this page.

loader

Всем привет! В этом уроке мы познакомимся с таким понятием как функции в языке PHP. Функции – вещь довольно простая. Она представляет собой кусок кода, который принимает определенные параметры и на выходе возвращает какой-либо результат. Можно написать функцию один раз, а затем использовать её в различных местах. Таким образом вам не нужно будет дублировать код, если что-то нужно сделать дважды, или трижды, или сколько угодно раз. Вообще, функции в PHP можно сравнить с функциями в математике.

В PHP изначально содержится огромное число встроенных функций. Это очень сильная сторона этого языка – почти под любую вашу потребность имеется уже готовая функция. Давайте попробуем несколько функций на практике.

Например, нам нужен косинус числа 3.14. Легко! Для этого в PHP есть функция cos.

<?php

echo cos(3.14);

Результат:

-0.99999873172754

Есть очень много функций для работы со строками. Например, можно в строке заменить одни символы другими, для этого есть функция str_replace. Например, давайте в строке “abracadabra” заменим все буквы “a” на “o”.

<?php

$string = 'abracadabra';

echo str_replace('a', 'o', $string);

Результат:

obrocodobro

Документация по стандартной библиотеке функций (SPL) доступна на официальном сайте — http://php.net/manual/ru/funcref.php. Большинство из них имеет описание на русском языке. Разумеется, все их запомнить невозможно, однако нужно уметь их находить. И это, как правило, не составляет труда. Например, если вбить в google “заменить символы в строке php” то в выдаче будет ссылка на официальную документацию, там и смотрите.

Вообще, гуглить и брать уже готовый код – это хороший подход, который экономит ваше время. В этом нет ничего плохого – скорее всего вы найдёте лучшее решение задачи, чем то, которое бы написали сами. Научитесь на готовых примерах, а со временем запомните наиболее частые подходы для разных случаев. Здесь главное – постоянная практика.

Пользовательские функции: пишем свою первую функцию

Думаю, о том, что такое функции и где найти уже готовые, я объяснил. Но самое крутое то, что функции можно определять самому! В целом определение любой функции выглядит следующим образом:

function имяФункции (аргумент1, аргумент2)
{
    какие-то действия;
    return результат;
}

У функции обязательно должно быть имя. У всех функций должны быть разные имена и имя вашей функции не может называться так же, как и встроенная в PHP функция. Аргументов может быть сколько угодно, в том числе и 0. Функция может что-то возвращать, для этого перед результатом пишется слово return. После него функция завершает свою работу. А может и не возвращать, а, например, изменять свои аргументы, или выводить информацию на экран. Именуются функции так же, как и переменные — camelCase`ом. Подробнее об этом я писал тут — https://php.zone/post/726. Именовать их нужно так же осмысленно – то что функция делает, то и нужно писать в имени.

Давайте рассмотрим пример создания простейшей функции в PHP. Пусть она принимает на вход два числа и возвращает их сумму.

<?php

function getSum($x, $y)
{
    return $x + $y;
}

Окей, функцию написали, теперь можно её вызвать и посмотреть на результат её работы.

<?php

function getSum($x, $y)
{
    return $x + $y;
}

$a = 5;
$b = 10;

echo getSum($a, $b) . '<br>';
echo getSum(-3, 4);

Результат:

15
1

Как мы видим, функция успешно отработала. Вот так, написав её лишь один раз мы можем передавать в неё разные аргументы, и получать разные значения. Использовать функцию можно только после кода её определения!

Области видимости

Давайте теперь поговорим об области видимости функции. Тут на самом деле всё просто, и всё сводится к тому, что переменные внутри функции недоступны извне и называются локальными. После завершения работы функции все объявленные внутри неё переменные перестанут существовать. При этом переменные за пределами функции называются глобальными и недоступны внутри функции. Таким образом, можно внутри функции использовать такие же имена переменных, как и снаружи, но при этом это будут совершенно разные переменные.

<?php

function getSum($x, $y)
{
    return $x + $y;
}

$x = 3;
$y = 5;

echo getSum($x, $y);

Данный код абсолютно рабочий. Здесь переменные $x и $y внутри функции getSum живут сами по себе, а переменные с такими же именами за пределами функции – отдельно, и они ничего друг о друге не знают. При вызове функции значение передаваемого аргумента будет скопировано в локальную переменную, а после выхода из функции это значение будет удалено. То есть здесь при вызове getSum мы просто копируем значения 3 и 5 в локальные переменные $x и $y. С этого момента внутри функции внешние переменные перестают существовать, и она знает только о своих переменных.

Параметры функции: передача аргументов по ссылке и по значению

До сих пор в рассматриваемых нами случаях аргументы в функцию передавались по значению. Это значит, что при вызове функции, значение, передаваемое в качестве аргумента, просто копировалось в локальную переменную.

Передача параметров по ссылке

Однако можно передать аргумент по ссылке. Делается это при помощи знака & перед именем аргумента.

function func(&$x)

При этом не происходит копирования значения в локальную переменную. Появляется ещё одна связь для этого же значения, но с другим именем. И теперь, изменяя значение этой переменной внутри функции, мы будем изменять исходное, переданное значение. Давайте рассмотрим пример передачи значения по ссылке.

<?php

function plus5(&$x)
{
    $x = $x + 5;
}

$a = 3;

plus5($a);

echo $a;

Результат:

То есть для значения переменной $a внутри функции появилось ещё одно имя — $x. Сейчас оба этих имени указывают на одно и то же значение. И если мы изменим значение переменной внутри функции, то оно изменится также и снаружи!

А если бы мы передали переменную в функцию по значению, без использования знака &, то получили бы другой результат.

<?php

function plus5($x)
{
    $x = $x + 5;
}

$a = 3;

plus5($a);

echo $a;

Будет выведено:

Здесь при вызове функции значение переменной $a было просто скопировано в локальную переменную $x. Внутри функции мы изменили $x, прибавив к нему число 5, а затем работа функции была завершена. Локальная переменная $x перестала существовать, а мы никак не повлияли на переменную $a.

Функции, в которых все аргументы передаются по значению, называются чистыми. Стоит по возможности использовать их, так как в абсолютном большинстве случаев передача значений по ссылкам не требуется и приводит к запутанности кода.

Начинаем использовать тайп-хинтинг (type hinting) в PHP

В PHP 7 в функциях появилась возможность указывать типы аргументов, в том числе для скалярных типов (строки, числа). При этом при передаче аргумента в функцию, передаваемое значение будет автоматически приведено к нужному типу. Давайте перепишем нашу функцию, учитывая современные возможности PHP.

<?php

function getSum(int $x, int $y)
{
    return $x + $y;
}

Вот так, теперь при передаче любых значений в функцию, они автоматически будут приведены к числам. Давайте это проверим – вставим вызов функции var_dump внутри нашей функции, и посмотрим, что получится.

<?php

function getSum(int $x, int $y)
{
    var_dump($x);
    var_dump($y);

    return $x + $y;
}

echo getSum(5, 10);

Результат:

int 5
int 10
15

Вполне ожидаемо, скажете вы. Мы ведь передали в функцию целые числа, и даже если бы у аргументов не было приведения типов, то там точно так же были бы целые числа. И будете правы. Но давайте попробуем в качестве одного из аргументов передать число с плавающей запятой.

<?php

function getSum(int $x, int $y)
{
    var_dump($x);
    var_dump($y);

    return $x + $y;
}

echo getSum(12.5, 10);

После выполнения мы увидим следующее:

int 12
int 10
22

То есть в тот момент, когда аргумент пришёл в функцию, он был уже нужного типа. Давайте попробуем убрать указание типа из аргумента:

<?php

function getSum($x, $y)
{
    var_dump($x);
    var_dump($y);

    return $x + $y;
}

echo getSum(12.5, 10);

Теперь дробное число не будет приведено к целому, и мы получим другой результат:

float 12.5
int 10
22.5

В этом курсе мы всегда будем использовать указание типов. Это помогает писать более строгий код и позволяет допускать меньше ошибок. Посудите сами – если мы работаем с конкретным типом, мы более уверены в том, как будет работать тот или иной код.

Строгая типизация

Как я уже сказал, по умолчанию значение аргумента будет автоматически приведено к указанному типу. Однако в PHP есть возможность указать явно, что аргумент, передаваемый в функцию, будет иметь конкретный тип. Это делается с помощью директивы:

declare(strict_types=1);

Она указывается в начале PHP-файла. Наш код примет следующий вид:

<?php
declare(strict_types=1);

function getSum(int $x, int $y)
{
    var_dump($x);
    var_dump($y);

    return $x + $y;
}

echo getSum(12.5, 10);

При этом, если его сейчас запустить, то произойдёт ошибка с типом TypeError.

Как тут написано, первый аргумент, переданный в getSum() обязан быть типа integer, а передан с типом float. Это и есть строгая типизация в PHP. Использовать её в рамках данного курса мы не будем, да и в профессиональной разработке на PHP этот функционал пока не используют. Но не рассказать о ней я не мог, вполне возможно, что это могут спросить при собеседовании на работу. А сейчас убираем строку declare(strict_types=1); из нашего кода и идём дальше.

Функции без аргументов

Как я говорил, функция может вообще не иметь аргументов. Таковой, например, является стандартная функция rand() – она просто возвращает случайное число.

Давайте её попробуем в действии:

<?php

echo 'Случайное число: ' . rand();

Результат:

Случайное число: 9582

Давайте запустим ещё раз этот же самый код:

Случайное число: 7324

Работает. А давайте теперь напишем свою функцию, которая тоже не принимает аргументов, и возвращает синус случайного числа:

<?php

function getSinOfRandom()
{
    return sin(rand());
}

echo 'Синус случайного числа: ' . getSinOfRandom();

Результат:

Синус случайного числа: 0.6586666790617

Функция внутри функции

Давайте теперь рассмотрим, что ещё позволяют нам делать функции. Функции в PHP можно вызывать внутри других функций. Давайте приведём абсолютно простейший пример. Например, нам нужно найти сумму косинусов двух чисел. Напишем для этого функцию:

<?php

function getSumOfCos(float $x, float $y)
{
    $cosX = cos($x);
    $cosY = cos($y);
    return $cosX + $cosY;
}

echo getSumOfCos(1.44, 2);

Здесь мы использовали функцию cos() из стандартной библиотеки внутри нашей собственной функции. А можно ли вызывать свои же функции из других своих функций? Да легко!

<?php

function getSum(float $x, float $y)
{
    return $x + $y;
}

function getSumOfCos(float $x, float $y)
{
    $cosX = cos($x);
    $cosY = cos($y);
    return getSum($cosX, $cosY);
}

echo getSumOfCos(1.44, 2);

Здесь мы определили 2 разные функции, и во второй начали использовать первую. Разумеется, эти примеры довольно искусственны. И вы можете подумать, что использовать здесь функции излишне. Ведь можно же просто заменить этот код следующим выражением:

<?php

echo cos(1.44) + cos(2);

И вы будете совершенно правы. Но я привожу такие лёгкие примеры специально, чтобы вам было проще понять, как вообще писать функции. Давайте рассмотрим более реальный пример. Напишем функцию, которая будет возвращать большее из двух переданных чисел.

<?php

function getMax(int $x, int $y)
{
    if ($x > $y) {
        return $x;
    } else {
        return $y;
    }
}

$a = 5;
$b = 8;

echo 'Наибольшее число: ' . getMax($a, $b);

Результат:

Наибольшее число:8

Код данной функции можно упростить, так как если $x не больше $y, то мы в любом случае вернём $y. Поэтому можно убрать блок else:

<?php

function getMax(int $x, int $y)
{
    if ($x > $y) {
        return $x;
    }

    return $y;
}

$a = 5;
$b = 8;

echo 'Наибольшее число:' . getMax($a, $b);

Результат будет таким же. Так происходит, как я уже говорил, что как только в функции выполнится return, значение будет тут же возвращено, а функция завершит свою работу.

Давайте передадим первым аргументом большее число:

<?php

function getMax(int $x, int $y)
{
    if ($x > $y) {
        return $x;
    }

    return $y;
}

$a = 10;
$b = 8;

echo 'Наибольшее число: ' . getMax($a, $b);

Результат:

Наибольшее число: 10

Выполнилось первое условие и вызвался return $x. Всё, до return $y дело не дошло.
Упрощение заключается в том, что чем меньше уровней вложенности в коде, тем проще его читать и понимать. Видите, как плотно пересекается весь изученный материал? В данном случае с темой условий в PHP.

Рекурсивные функции

Ох, чувствую, сейчас повеселимся. Осторожно! Если при чтении этого раздела у вас начнут закипать мозги — переходите к следующему уроку, рекурсию можно освоить и в конце курса. Не парьтесь, в общем, если не будет получаться, вы такие не одни =)

Вот мы узнали, что можно вызывать одну функцию внутри другой. Однако бывают ситуации, когда нужно вызвать одну и ту же функцию внутри себя самой.

Например, нам нужно возвести число в степень. Предположим, у нас для этого есть определённая функция. Назовём её power. И пусть она принимает 2 аргумента:

число, которое нужно возвести;
степень, в которую нужно возвести.

То есть, для того, чтобы возвести число 2 в третью степень, нам нужно вызвать эту функцию следующим образом:

power(2, 3)

Согласитесь, что power(2, 3) равносильно 2 * power(2, 3 — 1). То есть мы можем умножить число, возводимое в степень, на вызов этой функции, и уменьшить при этом степень на единицу.

Таким образом, получается, что мы можем вызывать эту же функцию с некоторыми дополнительными операциями.

Получаем, что

power($x, $n) = $x * power($x, $n – 1)

Тогда для возведения 2 в степень 3 получим:

power(2, 3) = 2 * power(2, 2)
power(2, 2) = 2 * power(2, 1)
power(2, 1) = 2 * power(2, 0)

Число в нулевой степени равно единице. Здесь нам нужно остановиться.

Давайте реализуем это с помощью кода:

<?php

function power(int $x, int $n)
{
    // Если сейчас степень равна нулю, то возвращаем единицу
    if ($n === 0) {
        return 1;
    }

    // В остальных случаях - умножаем число на возведённое в степень n - 1 и возвращаем его
    return $x * power($x, $n - 1);
}

echo power(2, 3);

Да, функция будет вызывать сама себя. Таким образом, можно прийти к тому, что рекурсия полезна, когда вычисление функции можно свести к её более простому вызову, а его – ещё к более простому, и так далее, пока мы не достигнем в аргументах какого-то конечного значения (в нашем примере — число 0). Чтобы понять, как всё работает пошагово, можно добавить вызов var_dump в начале функции и посмотреть, какие аргументы ей передаются на каждом из шагов.

<?php

function power(int $x, int $n)
{
    var_dump($x, $n);
    // Если сейчас степень равна нулю, то возвращаем единицу
    if ($n === 0) {
        return 1;
    }

    // В остальных случаях - умножаем число на возведённое в степень n - 1 и возвращаем его
    return $x * power($x, $n - 1);
}

echo 'Результат: ' . power(2, 3);

Вывод получится следующим:

int 2 int 3
int 2 int 2
int 2 int 1
Результат: 8

Таким образом, мы видим, что функция была вызвана трижды, и мы видим, какими были значения аргументов на каждом вызове. Надеюсь, тут всё понятно. Если же нет (а при изучении рекурсии это происходит довольно часто) – пишите ваши вопросы в комментариях, помогу. А ещё можете пошагово разбирать ход программы на листочке – тоже часто помогает.

Давайте для закрепления разберём ещё один пример с рекурсией. Например, мы будем передавать в функцию какое-то число $n, а она будет считать сумму всех чисел от единицы до этого числа. Назовём эту функцию getSumOfNumbersFromZero($n).

Предположим, нам нужно посчитать сумму всех чисел от 1 до 5. Тогда вызов функции будет следующим:

getSumOfNumbersFromZero(5);

Как можно догадаться, этот вызов можно представить как

5 + getSumOfNumbersFromZero(4)

Или в общем случае

getSumOfNumbersFromZero($n) = $n + getSumOfNumbersFromZero($n - 1)

И так до тех пор, пока $n не станет равен 1.

Давайте реализуем это с помощью рекурсивной функции:

<?php

function getSumOfNumbersFromZero(int $n)
{
    // Если сейчас 1, то просто возвращаем 1
    if ($n == 1) {
        return 1;
    }

    // В остальных случаях - прибавляем текущее число к сумме всех предыдущих
    return $n + getSumOfNumbersFromZero($n - 1);
}

echo 'Результат: ' . getSumOfNumbersFromZero(5);

Запускаем:

Результат: 15

Всё верно! Ну, хватит рекурсии, а то я уже слышу, как у вас закипают мозги.
Очень надеюсь, что вам понравился урок. Если это так – буду рад, если вы поделитесь им в социальных сетях или расскажете друзьям. Это лучшая поддержка проекта. Спасибо тем, кто это делает. Если у вас возникли какие-то вопросы или замечания – напишите об этом в комментариях. А сейчас – делаем домашнее задание, варианты ваших решений можете писать в комментариях, я их проверю и скажу, всё ли правильно. Всем пока!

loader

Источник

Это уже последняя часть учебника, про основы программирования на PHP, тут будет рассказываться про создания функции в PHP, и вообще как с ними работать, также затрону работу со статичными и глобальными переменными.

Что такое функция:

Для начала надо понять что такое функция вообще, если кратко говоря, то это просто кусок куда, который можно вызвать (запустить) в любой точке кода программы.

Это нужно для того, что бы не повторять постоянно код программы, потому что в программирования считается плохим тоном, повторять код, ну и на мой взгляд это ещё удобнее.

Создания функции в PHP:

В PHP объявление функции очень простое, вам просто надо написать слово function, после него название функции, круглы скобки, фигурные скобки и уже в них писать код.

Вызвать её тоже очень просто, пишем название функции и круглые скобки.

// Объявление (создание) функции с названием hello_world

function hello_world () {

echo ‘Hello World’;

}

// Вызов (запуск) функции hello_world

hello_world();

Как видите всё очень просто, вот что она выводит.

Также, если мы её визовым несколько раз, то получим несколько предложений «Hello World».

// Объявление функции с названием hello_world

function hello_world () {

echo ‘Hello World’;

}

// Вызов несколько раз функции hello_world

hello_world();

Вот как то так.

Как видите это достаточно удобно и просто.

Параметры в функции:

Также в PHP есть передача параметров в функции, это очень полезно, к примеру когда вам нужно сравнить два числа, вы просто передаёте эти числа в функцию и она уже сравнивает.

// Объявление функции с названием num_top

function num_top ($a, $b) {

if ($a > $b) {

echo ‘$a > $b, $a = ‘ . $a . ‘’;

} elseif ($a < $b) {

echo ‘$a < $b, $b = ‘ . $b . ‘’;

} else {

echo ‘$a = $b, $b и $a = ‘ . $a . ‘’;

}

// Вызов несколько раз функции num_top с разными параметрами

num_top(3, 1); // параметр $a = 3, параметр $b = 1

num_top(2, 9); // параметр $a = 2, параметр $b = 9

num_top(5, 5); // параметр $a = 5, параметр $b = 5

Вот результат.

Также в качестве параметра можно передавать переменную, при чём, вообще без разницы какую, тут всё зависит от того, что вам нужно делать в функции, можно даже передавать массивы.

Возврат значения в функции:

Также функция может возвращать разные значения, это нужно, к примеру, если нам не надо, чтобы функция выводила на экран, какое значение больше, а только давала нам это значение, для дальнейшей работы с ним.

Для этого, внутри функции используется ключевое слово return.

// Объявление функции с названием num_top

function num_top ($a, $b) {

if ($a >= $b) {

// Возвращает $a, если $a больше или равно $b

return $a;

} elseif ($a < $b) {

// Возвращает $b, если $a меньше $b

return $b;

}

// Вызов несколько раз функции num_top с разными параметрами

$a = num_top(3, 1); // Переменная $a равна 3

$b = num_top(5, 10); // Переменная $a равна 10

// выводим на экран, чему равны переменные

echo ‘$a = ‘ . $a . ‘, $b = ‘ . $b . ‘’;

// Складываем их и выводим на экран

echo $a + $b;

Вот результат.

Как видите всё работает, сначала сравниваем три и один, получается три больше чем один, число возвращается и присваивается переменной $a, точно также с переменной $b, после этого складываем эти две переменный и получается 13.

Ещё в PHP можно передать функцию как параметр, это иногда бывает полезно, что бы не создавать отдельную переменную.

// Объявление функции с названием num_top

function num_top ($a, $b) {

if ($a >= $b) {

// Возвращает $a, если $a больше или равно $b

return $a;

} elseif ($a < $b) {

// Возвращает $b, если $a меньше $b

return $b;

}

// Вызываем функцию, и передаём другую функцию

echo num_top(num_top(3, 2), num_top(1, 4)); // Выведет 4

Как видите всё просто, это пожалуй всё основное что нужно знать о функциях, единственное, примеры были достаточно однообразны.

Глобальные и статические переменные:

Это часть не очень сильно относится к функциям, но тем не менее её надо знать.

Глобальные переменные:

Для начала рассмотрим глобальные переменные, это переменные которые объявлены вне какой функции, то есть внутри функции их нет, их называют глобальными, а те которые объявлены внутри функции, называются локальными.

В том дела, что если вы в функции хотите использовать глобально переменную, то вы не сможете это так просто сделать.

Объявление глобальной переменной в PHP, очень простое, просто объявляете её вне функции, вот получить её будет тоже очень просто, для этого надо использовать ключевое слово global или массив $GLOBALS, рассмотрим оба эти варианта.

$a = 10; // Объявление глобальной переменной

// Объявление функции с названием plus

function plus () {

$b = 5; // Объявление локальной переменной

global $a; // Получение глобальной переменной

echo $a + $b; // Складываем и выводим на экран

}

// Вызываем функцию plus

plus();

Вот результат.

Как видите функция взяла переменную $a, которая равна 10, и сложила её с внутренний переменной $b, которая равна 5, вывела на экран 15.

Теперь рассмотрим массив $GLOBALS, но это просто массив, который хранит в себе все глобальные переменные.

Важно: для названия переменной, внутри квадратных скобок, используется строка названия переменной без знака доллара в начале.

$a = 10; // Объявление глобальной переменной

// Объявление функции с названием plus

function plus () {

$b = 5; // Объявление локальной переменной

echo $GLOBALS[‘a’] + $b; // Складываем и выводим на экран

}

// Вызываем функцию plus

plus();

Вывод будет точно такой же, как из первого примера,

Ну а что если мы просто напишем $a + $b?

То тогда он просто выведет 5, так как, PHP создаёт новую локальную переменную $a, которая равна нулю, потому что ей не чего не присваивается.

Статические переменные:

Статичная переменная в PHP, это ещё очередной тип переменной, как глобальная или локальная.

По сути это локальная переменная, но различие в том, что если создаём её, то она не удаляется, после того как функция закончит свою работу.

Что бы создать статичную переменную, надо перед её объявлением использовать ключевое слово static.

// Объявление функции с названием plus_one

function plus_one () {

static $a = 0; // Объявление статичной переменной $a

$a++; // увеличение переменной на один

echo $a . » «; // Вывод переменной на экран

}

// вызываем функцию plus_one

for ($i = 0; $i < 10; $i++) {

plus_one();

}

Вот результат.

Как видите получается счёт, от нуля до десяти, если мы уберём static, то вот что получится.

Просто выводит единицы, потому что при каждом вызови функции, переменная $a, удаляется и создаётся заново, статичная переменная нет.

Вывод:

В этой части вы узнали о том как происходит создания функции в PHP 7 и вообще что это такое, также, узнали о глобальных и статичных переменных.

Это была последняя часть из учебника, основы программирования на PHP, теперь вы можете начать изучать ООП на PHP.

Подписываетесь на соц-сети:

Оценка:

Загрузка…

Дополнительно:

Источник

Функция — это блок кода, который может быть именован и вызван повторно. Иногда функцию ещё называют подпрограммой.

Обычной переменной присваивают число, строку или массив, а затем получают его обратно, обратившись к значению по имени переменной. Функции устроены похожим образом. Это тоже переменная, только вместо строки или числа в функции хранится блок кода, который вызывается при использовании этой «переменной».

Функция — очень мощный инструмент повторного использования кода. Создав свою функцию и записав туда необходимый код, вы сможете вызывать и использовать его столько раз, сколько необходимо. В противном случае пришлось бы копировать и вставлять фрагмент кода каждый раз, когда он понадобится.

Чтобы упростить себе работу, оформите в виде функции часть кода, используемую в сценарии несколько раз. Затем, вместо копирования и вставки этой части, нужно будет только вызывать функцию, как если бы мы обращались к переменной.

Типы функций

Разделяют два типа функций — встроенные и пользовательские.

Встроенные функции — функции, которые за нас уже написали создатели языка программирования, можем просто брать их и использовать. В PHP существуют тысячи готовых функций на все случаи жизни!

Одна из хорошо знакомых функций — функция, которая выводит переданный ей текст на экран — print().

Пользовательские функции программист создаёт самостоятельно. Эти функции используются только внутри одного проекта или сценария.

Анатомия функций

Работа с функциями состоит из объявления и использования.

Перед тем как использовать новую функцию, следует её объявить:

<?php
function <имя функции>(<аргумент функции>) {
    <тело функции>
    return <результат выполнения функции>;
}

Пояснить все составные части функции проще всего на примере.

Допустим, на своём сайте мы хотим показывать, является ли выбранный пользователем год високосным. Для этого напишем функцию, в которую передаётся год. В результате работы функции мы хотим получить значение «истина», если год високосный, и «ложь» — если нет.

Определение такой функции:

<?php
function is_leap_year($year) {
    if ($year % 4 != 0) {
        return false;
    }
    elseif ($year % 100 == 0) {
        if ($year % 400 == 0) {
            return true;
        }
        else {
            return false;
        }
    }
    else {
        return true;
    }
}

Пример использования функции:

<?php
$year = 2034;

if (!is_leap_year($year)) {
    print("2034 год - простой");
}
else {
    print ("2034 год - високосный");
}

Потренироваться использовать функции в PHP можно в этом тренажёре.

Аргументы функции и область видимости

Наша функция умеет вычислять, является ли переданный год високосным.

Так как функция — это программа в программе, то внутри неё не будут доступны переменные, которые определялись за её пределами. Чтобы передать внутрь функции информацию извне, нужно использовать аргументы функции.

Аргументы функции — это переменные, которые функция может получить из внешнего кода. В примере с is_leap_year такая переменная была только одна — $year.

Верно и обратное — переменные, определённые внутри функции, не будут доступны извне. Такие переменные называются локальными, потому что они локальны по отношению к функции.

В отличие от аргументов, которых может быть несколько, вернуть во внешний код функция может только одно значение — с помощью инструкции return (возврат). Возвращаемое значение называют результатом работы функции.

Источник

В PHP пользовательские функции создаются с помощью ключевого словаfunction, за которым следует имя функции, перечень её аргументов (количество которых может быть нулевым) и тело самой функции. Назначение функций очень широкое. Если вам приходится неоднократно выполнять какой-то один и тот же код, вам следует поместить его в свою функцию, и затем просто вызывать её там, где вам нужно. Имя функции должно начинаться с символа латинского алфавита, может содержать цифры и символ нижнего почеркивания. По принятому соглашению имена функций в PHP начинаются со строчных букв, а если в имени используетя не одно слово, то каждое новое начинается с заглавной буквы либо сразу, либо после символа нижнего подчеркивания.

/**
  * Объявляем простую пользовательскую функцию
  */
function userFunction() {

}

Если в теле функции присутствует более одной инструкции, все инструкции должны быть помещены внутрь фигурных скобок {}. Если у функции есть только одна инструкция, фигурные скобки не обязательны. Но я рекомендую вам всегда их использовать.

В PHPесть стандартные функции, имена которых вам нельзя будет использовать в своих. Если вы захотите создать функцию с именемdate()илиtime(), вы получите сообщение об ошибке, связанное с попыткой переопределения функции. В PHP функции можно объявлять только один раз. Переопределение функций запрещено. Обычно функции определяются в самом начале скрипта (чаще в отдельных файлах, подключаемых к основному сценарию) до начала основного сценария. Создадим функцию для вывода на экран IP-адреса пользователя.

/**
  * Функция вывода IP-адреса пользователя.
  * IP-адрес берется из суперглобального массива PHP $_SERVER
  * который содержит важные данные о соединении и сервере
  */
function userIP() {
	print "<p>" . $_SERVER['REMOTE_ADDR'] . "</p>";
}

Функция определена. Для того, чтобы вызвать её, в сценарии в нужном месте достаточно указать имя функции и передать ей необходимые параметры (если это требуется).

userIP();	// Выведет на экран IP-адрес пользователя вида 127.0.0.1

Область видимости переменных

При работе с функциями следует изучить понятие области видимости переменных. Заключается оно в том, в каких местах сценария какие из объявленных переменных могут быть использованы. Переменные, которые были объявлены внутри функции, являются локальными переменными. Внутри тела функции к ним обращаться можно, а за пределами функции к ним уже обратиться не получится. И наоборот, переменные, объявленные вне тела функции, не доступны в самой функции. Но существуют данные, которые доступны в любом месте сценария.

Суперглобальные массивы

$_SERVER,$_SESSION,$_COOKIEи другие — это суперглобальные массивы. Их данные доступны в любом месте сценария. Вот лишь несколько из них:

$_SERVER[‘REMOTE_ADDR’]— IP-адрес пользователя;
$_SERVER[‘SERVER_NAME’]— имя сервера;
$_SERVER[‘DOCUMENT_ROOT’]— корневой каталог сайта;
$_SERVER[‘REQUEST_URI’]— запрошенный адрес документа.

Аргументы функции

Если функция должна иметь доступ к данным переменной или константы, объявленных вне её тела, эти данные ей можно передавать в виде аргументов. Каждая функция может принимать любое количество аргументов (параметров), в том числе и нулевое. В приведенном примере мы не передавали функции никакие аргументы. Рассмотрим другой пример.

/**
  * Объявляем пользовательскую функцию для суммирования двух произвольных значений
  */
function amount($value_1, $value_2) {	// Функция должна принять 2 обязательных аргумента
	print $value_1 + $value_2;			// И вывести на экран сумму этих аргументов
}
$green_apples = 10;		// У нас есть 10 зеленых яблок
$red_apples = 4;		// И еще есть 4 красных яблока

// Общее количество яблок мы можем узнать с помощью вызова функции amount()
// Функция amount() должна принять два аргумента, которыми будут являться количества яблок
amount($green_apples, $red_apples);		// Выведет на экран 14

Необязательные параметры (параметры по умолчанию) функции

У функции может иметься неограниченное количество аргументов (параметров), среди которых могут быть необязательные (в том числе и все). Для того, чтобы сделать аргумент функции необязательным, ему нужно присвоить значение по умолчанию при объявлении функции.

/**
  * Объявляем функцию со значениями по умолчанию
  */
function amount($value_1, $value_2, $value_3 = 0) {
	print $value_1 + $value_2 + $value_3;
}

Теперь, если мы захотим подсчитать общее количество яблок, мы можем вызвать фукнцию как и в прошлый раз.

/**
  * Подсчитываем общее количество яблок
  * На этот раз функция amount() принимает три аргумента,
  * но третий является необязательным, так как его значение
  * было определено при объявлении функции, если мы третий
  * аргумент не укажем, он останется равным нулю
  */
  
$geen_apples = 11;
$red_apples = 7;

amount($green_apples, $red_apples);		// Выведет на экран 18

// Находим у себя в кладовой, внезапно, ещё 10 желтых яблок
$yellow_apples = 10;

// И их тоже нужно учесть
amount($green_apples, $red_apples, $yellow_apples);		// Выведет на экран 28

Обратите внимание на то, что мы дважды вызвали одну и ту же функцию в пределах одного сценария. Это можно делать сколь угодно много раз. При работе с функциями помните об одной немаловажной детали — если среди аргументов функции присутствуют необъявленные по умолчанию и объявленные, сначала должны быть указаны те, которые являются необъявленными (обязательными).

function userF($v1, $v2 = 100, $v3) {		// К хорошему не приведет
	print $v1 + $v2 + $v3;
}

Возвращение значения

Одной из главный особенностей функций является их способность возвращать результат. Не всегда в сценарии необходимо что-то делать с результатом работы функции. Чаще его нужно просто сохранить и использовать в другом месте сценария совсем для других целей[?] собственно, для вывода некоего значения на экран функции вообще практически никогда не используются.. Для того, чтобы функция вернула значение в то место сценария, из которого она была вызвана, необходимо воспользоваться операторомreturn. Любой код, который следует за операторомreturn, не выполняется (если операторreturn сработал как надо).

/**
  * Объявляем пользовательскую функцию для суммирования яблок
  * одно из значений является заданным по умолчанию.
  * Функция просто суммирует значения аргументов, и возвращает
  * их сценарию, не выводя на экран.
  */
function amount($value_1, $value_2, $value_3 = 0) {
	$result = $value_1 + $value_2 + $value_3;	// Просто складываем значения аргументов функции
	return $result;								// Возвращаем результат сценарию. Переменная $result является локальной
												// и конкретно её значение не будет доступно вне тела функции
}

$green_apples = 9;		// у нас есть 9 зеленых яблок
$red_apples = 14;		// И еще 14 красных яблок

// Всего у нас...
$total_green_red = amount($green_apples, $red_apples);	// Оператор return функции amount() вернет значение 23,
														// которое присвоится переменной $total_green_red

// Нам принесли еще 7 желтых яблок
$yellow_apples = 7;

// И теперь у нас...
$total_green_red_yellow = amount($green_apples, $red_apples, $yellow_apples);	// Вернет значение 30 и запишет его в переменную 
																				// $total_green_red_yellow
																				
$all = amount($total_green_red, $total_green_red_yellow);	// Вернет значение 53

// Выведет на экран Зеленых и красных всего - 23
print "<p>Зеленых и красных всего - " . $total_green_red . "</p>";

// Выведет на экран Зеленых, красных и желтых всего - 30
print "<p>Зеленых, красных и желтых всего - " . $total_green_red_yellow . "</p>";

// Выведет на экран Сумма значений - 53
print "<p>Сумма значений - " . $all . "</p>";

Источник

Функция — это автономный блок кода, который выполняет определенную задачу.

PHP имеет огромную колличество внутренних или встроенных функций, которые вы можете вызывать непосредственно в своих PHP-скриптах для выполнения конкретной задачи, например gettype(), print_r(), var_dump и т. д.

Пожалуйста, ознакомьтесь с разделом справки по PHP, чтобы получить полный список полезных встроенных функций PHP.

В дополнение к встроенным функциям PHP также позволяет вам определять свои собственные функции. Это способ создания повторно используемых пакетов кода, которые выполняют определенные задачи и могут храниться и поддерживаться отдельно от основной программы. Вот некоторые преимущества использования функций:

Функции сокращают повторение кода в программе — функция позволяет выделить часто используемый блок кода в один компонент. Теперь вы можете выполнять ту же задачу, вызывая эту функцию в любом месте скрипта, не копируя и вставляя один и тот же блок кода снова и снова.
Функции значительно упрощают обслуживание кода — поскольку функция, созданная один раз, может использоваться много раз, любые изменения, внесенные внутри функции, автоматически внедряются во всех местах, не затрагивая несколько файлов.
Функции упрощают устранение ошибок — когда программа подразделяется на функции, при возникновении какой-либо ошибки вы точно знаете, какая функция вызывает ошибку и где ее найти. Таким образом, исправлять ошибки становится намного проще.
Функции могут быть повторно использованы в другом приложении — поскольку функция отделена от остальной части скрипта, ее легко повторно использовать в других приложениях, просто включив файл .php, содержащий эти функции.

В этом разделе мы узнаем, как создать свою собственную функцию в PHP.

Создание и вызов функций

Базовый синтаксис создания пользовательской функции может быть задан следующим образом:

function functionName() {
    // Код для выполнения
}

Объявление пользовательской функции начинается со слова function, за которым следует имя функции, которую вы хотите создать, после нее круглые скобки, т.е. (), и, наконец, сам код вашей функции должен быть расположен между фигурными скобками {}.

Вот простой пример пользовательской функции, отображающей сегодняшнюю дату:

<?php
// Определяем функцию
function whatIsToday() {
    echo "Today is " . date('l', mktime());
}
// Вызываем функцию
whatIsToday();
?>

Имя функции должно начинаться с буквы или символа подчеркивания, а не с числа; за первым символом могут следовать дополнительные буквы, цифры или символы подчеркивания. Имена функций нечувствительны к регистру.

Функции с параметрами

Вы можете указать параметры, когда определяете свою функцию для приема входящих значений во время выполнения. Параметры работают как переменные-заполнители внутри функции; они заменяются во время выполнения функции значениями (называемыми аргументами).

function myFunc($oneParameter, $anotherParameter) {
    // Код для выполнения
}

Вы можете определить столько параметров, сколько захотите. Однако для каждого указанного вами параметра при вызове функции необходимо передать соответствующий аргумент.

Функция getSum() в следующем примере принимает в качестве аргументов два целочисленных значения, просто складывает их вместе и затем отображает результат в браузере.

<?php
// Определяем функцию
function getSum($num1, $num2) {
  $sum = $num1 + $num2;
  echo "Сумма двух чисел $num1 и $num2 равна: $sum";
}

// Вызываем функцию
getSum(10, 20); // Выводит: 30
?>

Аргумент — это значение, которое вы передаете функции, а параметр — это переменная внутри функции, которая получает аргумент. Однако в обычном использовании эти термины взаимозаменяемы.

Функции с дополнительными параметрами и значениями по умолчанию

Вы также можете создавать функции с необязательными параметрами — просто вставьте имя параметра, затем знак равенства (=) и значение по умолчанию, как здесь:

<?php
// Определяем функцию
function customFont($font, $size=1.5) {
    echo "<p style="font-family: $font; font-size: {$size}em;">Hello, world!</p>";
}

// Вызываем функцию
customFont("Arial", 2);
customFont("Times", 3);
customFont("Courier");
?>

Как видите, третий вызов customFont() не включает второй аргумент. Это заставляет механизм PHP использовать значение по умолчанию для параметра $size, равное 1,5.

Возврат значений из функции

Функция может вернуть значение скрипту, который вызвал функцию, используя оператор return. Значение может быть любого типа, включая массивы и объекты.

<?php
// Определяем функцию
function getSum($num1, $num2) {
    $total = $num1 + $num2;
    return $total;
}

// Печатаем возвращенное значение
echo getSum(5, 10); // Выводит: 15
?>

Функция не может возвращать несколько значений. Однако вы можете получить аналогичные результаты, вернув массив, как показано в следующем примере.

<?php
// Определяем функцию
function divideNumbers($dividend, $divisor){
    $quotient = $dividend / $divisor;
    $array = array($dividend, $divisor, $quotient);
    return $array;
}

// Назнаем переменные, как если бы они были массивом
list($dividend, $divisor, $quotient) = divideNumbers(10, 2);
echo $dividend;  // Выводит: 10
echo $divisor;   // Выводит: 2
echo $quotient;  // Выводит: 5
?>

Передача аргументов функции по ссылке

В PHP есть два способа передать аргументы функции: по значению (value) и по ссылке (reference). По умолчанию аргументы функции передаются по значению, поэтому, если значение аргумента внутри функции изменяется, оно не затрагивается за пределами функции. Однако, чтобы функция могла изменять свои аргументы, они должны передаваться по ссылке.

Передача аргумента по ссылке выполняется путем добавления амперсанда (&) к имени аргумента в определении функции, как показано в примере ниже:

<?php
/* Определяем функцию умножения числа
само по себя и возвращаем новое значение */
function selfMultiply(&$number){
    $number *= $number;
    return $number;
}

$mynum = 5;
echo $mynum; // Выводит: 5

selfMultiply($mynum);
echo $mynum; // Выводит: 25
?>

Понимание области переменной

Вы можете объявить переменные где угодно в PHP-скрипте. Но расположение объявления определяет степень видимости переменной в PHP-программе, т.е. где переменная может быть использована или доступна. Эта доступность известна как область видимости переменных (variable scope).

По умолчанию переменные, объявленные внутри функции, являются локальными, и их нельзя использовать и управлять извне, как показано в примере ниже:

<?php
// Определяем функцию
function test() {
    $greet = "Hello World!";
    echo $greet;
}

test(); // Выводит: Hello World!

echo $greet; // Выводит ошибку undefined variable error
?>

Точно так же, если вы попытаетесь получить доступ или импортировать внешнюю переменную внутри функции, вы получите ошибку неопределенной переменной, как показано в примере:

<?php
$greet = "Hello World!";

// Определяем функцию
function test() {
    echo $greet;
}

test();  // Выводит ошибку undefined variable error

echo $greet; // Выводит: Hello World!
?>

Как вы можете видеть в приведенных выше примерах, переменная, объявленная внутри функции, недоступна извне, точно так же переменная, объявленная вне функции, недоступна внутри функции. Это разделение снижает вероятность того, что переменные в функции будут затронуты переменными в основной программе.

Можно повторно использовать одно и то же имя для переменной в разных функциях, поскольку локальные переменные распознаются только функцией, в которой они объявлены.

Ключевое слово global

Может возникнуть ситуация, когда вам нужно импортировать переменную из основной программы в функцию или наоборот. В таких случаях вы можете использовать ключевое слово global перед переменными внутри функции. Это ключевое слово превращает переменную в глобальную, делая ее видимой или доступной как внутри, так и вне функции, как показано в примере ниже:

<?php
$greet = "Hello World!";
 
// Определяем функцию
function test() {
    global $greet;
    echo $greet;
}
 
test(); // Выводит: Hello World!
echo $greet; // Выводит: Hello World!
 
// Присваиваем новое значение переменной
$greet = "Goodbye";
 
test(); // Выводит: Goodbye
echo $greet; // Выводит: Goodbye
?>

Вы узнаете больше о видимости и управлении доступом в Руководстве по классам и объектам в PHP.

Создание рекурсивных функций

Рекурсивная функция — это функция, которая вызывает себя снова и снова, пока не будет выполнено условие. Рекурсивные функции часто используются для решения сложных математических вычислений или для обработки глубоко вложенных структур, например, для печати всех элементов глубоко вложенного массива.

В следующем примере показано, как работает рекурсивная функция.

<?php
// Определяем рекурсивную функцию
function printValues($arr) {
    global $count;
    global $items;
    
    // Проверяем существование массива
    if(!is_array($arr)){
        die("ERROR: Input is not an array");
    }
    
    /*
    Перебираем массив, если значение само по себе является массивом, рекурсивно вызываем эту же функцию;
    функция else добавляет найденное значение в новый массив элементов $items,
    и увеличивать счетчик на 1 для каждого найденного значения
    */
    foreach($arr as $a){
        if(is_array($a)){
            printValues($a);
        } else{
            $items[] = $a;
            $count++;
        }
    }
    
    // Возвращаем общее количество и значения, найденные в массиве
    return array('total' => $count, 'values' => $items);
}
 
// Определяем вложенный массив
$species = array(
    "birds" => array(
        "Eagle",
        "Parrot",
        "Swan"
    ),
    "mammals" => array(
        "Human",
        "cat" => array(
            "Lion",
            "Tiger",
            "Jaguar"
        ),
        "Elephant",
        "Monkey"
    ),
    "reptiles" => array(
        "snake" => array(
            "Cobra" => array(
                "King Cobra",
                "Egyptian cobra"
            ),
            "Viper",
            "Anaconda"
        ),
        "Crocodile",
        "Dinosaur" => array(
            "T-rex",
            "Alamosaurus"
        )
    )
);
 
// Считаем и печатаем значения во вложенном массиве
$result = printValues($species);
echo $result['total'] . ' value(s) found: ';
echo implode(', ', $result['values']);
?>

Будьте осторожны при создании рекурсивных функций, потому что, если код написан неправильно, это может привести к бесконечному циклу вызова функции. Это приведет к чрезмерной нагрузке на сервер и служба поддержки хостинга заблокирует ваш сайт до устранения ошибок.

Источник

От автора: функции PHP похожи на функции других языков программирования. Функция представляет собой фрагмент кода, который принимает другой код в качестве параметра, выполняет определенную обработку и возвращает значение.

Мы уже рассмотрели много таких функций, например fopen() и fread() и т.д. Это встроенные функции, но PHP предоставляет нам возможность создавать собственные функции. Вы должны четко понимать, что существуют два отдельных аспекта:

Создание функции PHP

Вызов функции PHP

На самом деле вам вряд понадобиться создавать свою собственную функцию, потому что в PHP уже доступны тысячи функций из библиотек, созданных для разных сфер применения, и вам просто нужно вызвать нужную функцию. Полный перечень функций вы можете найти в Справочнике по функциям PHP.

Бесплатный курс по PHP программированию

Освойте курс и узнайте, как создать веб-приложение на PHP с полного нуля

Получить курс сейчас!

Создание функции PHP

Собственную PHP-функцию создать очень просто. Предположим, вы хотите создать функцию PHP, которая просто выводит в браузере короткое сообщение, когда вы ее вызываете. В следующем примере мы создаем функцию writeMessage(), а затем вызывает ее сразу после создания.

Обратите внимание, что при создании функции ее имя должно начинаться с ключевого слова function, и весь код PHP должен быть помещен внутри скобок { }, как в приведенном ниже примере:

<html>

<head>

<title>Writing PHP Function</title>

</head>

<body>

<?php

/* Определение функции PHP */

function writeMessage() {

echo «You are really a nice person, Have a nice time!»;

}

/*Вызов функции PHP */

writeMessage();

</body>

</html>

Этот код выводит следующий результат — You are really a nice person, Have a nice time!

Функции PHP с параметрами

PHP дает вам возможность передавать собственные параметры внутри функции. Вы можете передать столько параметров, сколько вам нужно. Эти параметры работают как переменные внутри функции. В следующем примере мы берем два целочисленных параметра и слагаем их, а затем выводим.

<html>

<head>

<title>Writing PHP Function with Parameters</title>

</head>

<body>

<?php

function addFunction($num1, $num2) {

$sum = $num1 + $num2;

echo «Sum of the two numbers is : $sum»;

}

addFunction(10, 20);

</body>

</html>

Этот код выводит следующий результат — Sum of the two numbers is : 30

Передача аргументов по ссылке

В функции можно передавать аргументы по ссылке. Это означает, что ссылка на переменную управляется функцией, а не экземпляром значения переменной.

Любые изменения, внесенные в аргумент в этих случаях, изменяют значения исходной переменной. Вы можете передать аргумент по ссылке, добавив к имени переменной амперсанд (&) либо в вызове функции, либо в определении функции. В следующем примере продемонстрированы оба случая.

<html>

<head>

<title>Passing Argument by Reference</title>

</head>

<body>

<?php

function addFive($num) {

$num += 5;

}

function addSix(&$num) {

$num += 6;

}

$orignum = 10;

addFive( $orignum );

echo «Original Value is $orignum »;

addSix( $orignum );

echo «Original Value is $orignum »;

</body>

</html>

Бесплатный курс по PHP программированию

Освойте курс и узнайте, как создать веб-приложение на PHP с полного нуля

Получить курс сейчас!

Этот код отображает следующий результат —

Original Value is 10

Original Value is 16

Функции PHP, возвращающие значение

Функция может возвращать значение с помощью оператора return в сочетании со значением или объектом. Return останавливает выполнение функции и отправляет значение обратно вызывающему коду. Более одного значения вы можете вернуть из функции с использованием массива return (1,2,3,4).

В следующем примере мы принимаем два целочисленных параметра и слагаем их, а затем возвращаем сумму в вызывающую программу. Обратите внимание, что ключевое слово return используется для возврата значения из функции.

<html>

<head>

<title>Writing PHP Function which returns value</title>

</head>

<body>

<?php

function addFunction($num1, $num2) {

$sum = $num1 + $num2;

return $sum;

}

$return_value = addFunction(10, 20);

echo «Returned value from the function : $return_value»;

</body>

</html>

Этот код выводит следующий результат: Returned value from the function : 30

Установка для параметров функций значений по умолчанию

Вы можете установить для параметра значение по умолчанию, если вызывающий функцию объект не передает его. Следующая функция выводит NULL в случае, если в эту функцию не было передано ни одного значения.

<html>

<head>

<title>Writing PHP Function which returns value</title>

</head>

<body>

<?php

function printMe($param = NULL) {

print $param;

}

printMe(«This is test»);

printMe();

</body>

</html>

Это код выводит следующий результат — This is test

Динамические вызовы функций

Имена функций можно назначать, как строки в переменных, а затем обрабатывать эти переменные точно так же, как и имя функции. В следующем пример продемонстрировано такое поведение.

<html>

<head>

<title>Dynamic Function Calls</title>

</head>

<body>

<?php

function sayHello() {

echo «Hello »;

}

$function_holder = «sayHello»;

$function_holder();

</body>

</html>

Этот код выводит следующий результат: Hello

Источник: //www.tutorialspoint.com/

Редакция: Команда webformyself.

Бесплатный курс по PHP программированию

Освойте курс и узнайте, как создать веб-приложение на PHP с полного нуля

Получить курс сейчас!

Разработка веб-приложения на PHP

Скачайте видеокурс и узнайте, как создать веб-приложение на PHP

Скачать

Источник