Итак, что такое функция (function)на PHP ?

Функция (function)- это мини-программа, которая выполняет какие-то полезные действия и выдает готовый результат.
Давайте посмотрим на схемку:

Попробуем по готовому шаблону функции написать мини программу.
Готовый шаблон функции:

Припустим, нам нужно написать функцию, которая сможет подсчитать сумму чисел 5 и 2 . Смотрим на шаблон и пишем:

Разберем код .
function suma() - это функция с именем suma ;
echo 5 + 2; - в теле функции мы указали, что числа 5 и 2 нужно сложить вместе (5 + 2) ;
suma(); - вызываем функцию. Вызов функции означает ее выполнение. То есть, задачка 5 + 2 должна быть выполнена и дать результат 7 .

Теперь попробуем рассмотреть функции поэтапно.

Этапы создания функции на PHP

Этап I . Создание функции
Вспомните готовый шаблон функции:

Вот таким способом создается функция на PHP.
Давайте в теле функции напишем текст «Я рад видеть вас на блоге сайт ».
Только не забудьте: текст пишем через .

"; } ?>

Теперь нужно вызвать функцию «сайт() ».

Этап II . Вызов готовой функции на PHP
Функция создана и теперь она должна быть выполнена. Для выполнения и вывода функции достаточно указать «имя функции(); »

сайт();

Это будет выглядеть вот так:

"; } сайт(); ?>

Можно это сделать и так:

"; } ?> Куча текста….. Куча текста…..

Введите в браузере адрес:

Результат:

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

Все примеры с функциями выше были без аргументов. Что такое аргумент я вам объясню на коде:

Итак, я создал функцию с именем «сайт ». В параметрах (там, где скобки) прописал через запятую две переменные $a и $b .

Function сайт ($a , $b )

$a и $b – это и есть два аргумента.
echo "$a + $b = "; – здесь я вывел на монитор текст. Результат: 5 + 5 =
echo $a + $b; – здесь я указал функции, что переменную $a и $b нужно сложить вместе.
сайт (15, 5); – вызвал функцию. Внимание: в скобках я указал два аргумента (15, 5) , которые ждет переменная $a и $b . Переменная $a получит первый аргумент – 15 , $b – второй 5 .

Для тех, кто не понял, куда подставляется аргумент и в какой очередности, вот схема:

Итак, готовый код:

Сохраните как «function.php » в папку «test-1 » локального сервера (см. урок 1).

Введите в браузере адрес:

https://localhost/test-1/function.php

Результат:

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

Функция под именем «сайт » получит в переменную $link аргумент https://сайт/ , а переменная $title получит текст ссылки – «Блог сайт – создание сайта! »

Готовый код:

Сохраните как «function.php » в папку «test-1 » локального сервера (см. урок 1).

Введите в браузере адрес.

Заметка: активирована адаптивная версия сайта, которая автоматически подстраивается под небольшой размер Вашего браузера и скрывает некоторые детали сайта для удобства чтения. Приятного просмотра!

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

• Внутри функции можно использовать любой PHP код (циклы, условия, любые операции), включая другие функции (как встроенные, так и собственные);
• Имя функции должно начинаться с латинской буквы, либо знака подчёркивания, далее может идти любое количество латинских букв, цифр или знаков подчёркивания;
• Все функции имеют глобальную область видимости, это значит, что любая функция может быть вызвана в любом месте, даже если эта функция определена внутри другой;
• PHP не поддерживает перегрузку функций, также отсутствует возможность переопределить (изменить, дополнить) или удалить созданную функцию;
• Функции не обязаны быть определены до их использования. То есть если вы сначала вызовите функцию, а только потом – ниже по коду её опишите, то это не повлияет на работоспособность и не вызовет ошибок.

Функции, зависящие от условий

Мы можем создавать (определять, описывать) функцию, в зависимости от условия. Например:

//вызвали функцию sayHi, её можно вызывать в любом месте /*здесь нельзя вызвать функцию sayGoodbye, так как мы ещё не проверили условие и не зашли внутрь конструкции if*/ if($apply){ function sayGoodbye(){ echo "Всем пока!
"; } } /*вот теперь можем вызвать sayGoodbye*/
"; }

Результат:

И взгляните на этот пример:

/*а вот что будет, если вызвать sayGoodbye здесь*/ sayGoodbye(); if($apply){ function sayGoodbye(){ echo "Всем пока!
"; } } function sayHi(){ echo "Всем привет!
"; }

Результат:

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

Вложенные функции

Вложенная функция – это функция, объявленная внутри другой функции. Пример:

/*Здесь нельзя вызвать sayGoodbye, так как она появится только после вызова функции sayHi*/ sayHi(); /*вызвали функцию sayHi, её можно вызывать в любом месте*/ /*Теперь можем вызывать sayGoodbye*/ sayGoodbye(); function sayHi(){ echo "Всем привет!
"; function sayGoodbye(){ echo "Всем пока!
"; } }

Опять-таки, при первом обходе интерпретатор PHP помечает себе, что он нашёл описание функции sayHi, но не заходит внутрь её тела, он видит только название, а раз интерпретатор не заходит внутрь тела sayHi, то он понятия не имеет, что внутри мы определяем ещё одну функцию – sayGoodbye.

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

Но стоит обратить внимание на очень тонкий момент в ситуации выше: функция sayHi становится одноразовой, потому что если мы ещё раз её вызовем, то PHP опять наткнётся на определение функции sayGoodbye, а в PHP так делать нельзя – нельзя переопределять функции. Об этом и о том, как с этим бороться я писал в предыдущей статье.

В PHP описанные выше приёмы применяются очень редко, чаще их можно увидеть, например, в JavaScript.

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

В PHP ровно две области видимости: глобальная и локальная . В каждом языке программирования области видимости устроены по-разному. Например, в C++ даже в циклах своя (локальная) область видимости. В PHP, кстати, – это глобальная область видимости. Но сегодня мы говорим о функциях.

У функций в PHP своя, внутренняя область видимости (локальная), то есть все переменные внутри функции видны только внутри этой самой функции.

Итак, ещё раз: все, что вне функций – это глобальная область видимости, все, что внутри функций – локальная область видимости. Пример:

Уважаемые знатоки, внимание, вопрос! Что выведет последняя инструкция echo $name; ?

Как вы сами видели, у нас было 2 переменных $name , одна внутри функции (локальная область видимости), другая просто в коде (глобальная область видимости), последнее присвоение в переменную $name было $name = "Рудь Сергей"; Но так как это было внутри функции, то там оно и осталось. В глобальной же области видимости последним присвоением было $name = "Андрей"; что мы собственно и видим в результате.

То есть две одинаковые переменные, но в разных областях видимости никак не пересекаются и не влияют друг на друга.

Давайте я проиллюстрирую области видимости на рисунке:

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

Обращение к глобальным переменным из локальной области видимости

Но что если нам всё-таки нужно из функции обратиться к той самой переменной $name из глобальной области видимости, да не просто обратиться, а изменить её? Для этого есть 3 основных варианта. Первый из них использование ключевого слова global :

"; global $name; /*начиная с этого момента мы имеем ввиду глобальную переменную $name*/ $name = "Рудь Сергей"; } $name = "Андрей"; sayHi($name); echo $name; // ?

Результат:

Но у этого способа есть минус, с тех пор как мы обратились к глобальной переменной $name мы потеряли (переписали) локальную переменную $name .

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

$name = "Андрей"; //Тоже самое что и $GLOBALS["name"] = "Андрей";

Следовательно:

"; $GLOBALS["name"] = "Рудь Сергей"; } $name = "Андрей"; sayHi($name); echo $name; // ?

Результат тот же, что и при использовании ключевого слова global :

Только в этот раз мы не переписали локальную переменную, то есть переменная $name внутри функции осталась прежней и равна "Андрей" , а не "Рудь Сергей" .

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

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

Так вот, ПРАВИЛЬНАЯ передача аргумента по ссылке в PHP 5.3 и выше осуществляется следующим образом:

Function sayHi(& $name){

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

И в итоге имеем:

//принимаем не значение, а ссылку на значение echo "Привет, ".$name."!
"; $name = "Рудь Сергей"; } $name = "Андрей"; sayHi($name); echo $name; // ?

Результат:

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

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

"; $c++; // увеличиваем счётчик на 1

---

Результат:

Переменная $c не запоминает своего значения, она каждый раз создаётся заново. Нам нужно сделать так, чтобы наша локальная переменная $c запоминала своё значение после выполнения функции, для этого используют ключевое слово static :

// счётчик, сделали статическим echo "Привет, ".$name."!
"; $c++; // увеличиваем счётчик на 1 echo "Всего поздоровались " . $c . " раз.

---

"; } sayHi("Рудь Сергей"); sayHi("Андрей"); sayHi("Дмитрий");

Результат:

Возврат значений

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

Результат:

Сделаем так, чтобы вместо вывода на экран она возвращала результат выполнения. Для этого используется ключевое слово return:

Результат:

Теперь мы можем использовать это различными способами:

//выводит результат echo "
"; $num = getSquare(5); echo $num;

Результат:

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

echo "До меня PHP никогда не дойдёт:("; } echo getSquare(5); //выводит результат echo "
"; $num = getSquare(5); // присвоили результат в переменную echo $num; // вывели переменную на экран

Результат:

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

Рекурсивная функция

Рекурсивная функция – это функция, которая вызывает сама себя. Рекурсия используется не часто и считается ресурсоёмкой (медленной) операцией. Но бывает, что использование рекурсии самый очевидный и простой вариант. Пример:

"; if($number < 20){ // чтобы рекурсия не стала бесконечной countPlease(++$number); // функция countPlease вызвала сама себя } } countPlease(1);

Результат:

Если вы знаете, как обойтись без рекурсии, то лучше так и сделать.

Строгая типизация в PHP (уточнение типа)

В PHP сделаны мелкие шаги к строгой типизации, благодаря этому мы можем заранее указать, какой тип должна принимать функция (это называется type-hint ):

Результат:

Catchable fatal error: Argument 1 passed to countPlease() must be an array, integer given, called in /home/index.php on line 7 and defined in /home/index.php on line 3

Ошибка нам говорит, что функция ожидает принять массив, а вместо этого мы ей передаём число. К сожалению, пока что мы можем уточнять тип только для (array), а с PHP 5.4 ещё добавился такой вариант как callable :

Callable проверяет, может ли переданное значение быть вызвано в качестве функции. Callable может быть как именем функции, заданным строковой переменной, так и объектом и именем вызываемого метода. Но про объекты и методы мы поговорим позже (это раздел объектно-ориентированного программирования), а с функциями вы уже знакомы. Результат работы я вам показать не могу, так как у меня сейчас стоит PHP 5.3, но он был бы:

Вызвали функцию getEcho

Использование аргументов переменной длины

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

Результат:

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

func_num_args() - Возвращает количество аргументов, переданных функции
func_get_arg(порядковый номер) - Возвращает элемент из списка аргументов
func_get_args() - Возвращает массив, содержащий аргументы функции

"; echo func_get_arg(0) ; } $age = 22; getEcho("Рудь Сергей", $age);

Результат:

Заключение

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

Если у кого-то есть желание набить руку, но нет идей как это сделать – лучшим способом будет написание уже готовых (встроенных) функций PHP, например, можно написать собственную функцию count() или любую другую.

Благодарю всех за внимание и до новых встреч! Если что-то не понятно, смело задавайте ваши вопросы в комментариях!

Заметка: активирована адаптивная версия сайта, которая автоматически подстраивается под небольшой размер Вашего браузера и скрывает некоторые детали сайта для удобства чтения. Приятного просмотра!

Всем добрый день. Сегодняшней статьёй мы продолжаем погружаться в недра PHP, но не только. В конце данной статьи вы найдёте кроссворд, разгадав который вы можете получить от 500 до 1500 рублей. Все подробности , а мы продолжаем учиться.

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

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

Синтаксис:

Function siteOn(){ // тело функции echo "Привет всем читателям блога Site on!"; }

Где siteOn – это произвольное имя функции, оно регистро-независимое. Функция в примере выше выводит заданный текст. Когда PHP интерпретатор обрабатывает код, он видит только объявление функции, без её тела, и естественно, не выполняет его. Тело функции храниться в памяти до завершения работы PHP скрипта, то есть до конца загрузки страницы.

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

"; } siteOn(); // вызов функции siteOn(); // вызов функции siteOn(); // вызов функции ?>

В примере выше мы вызвали функцию аж 3 раза, и вот результат:

Зачем нужны функции?

Казалось бы, ну функция и что? Мы могли бы эту строчку просто написать 3 раза и без функции. Могли, но если мы вдруг захотим что-то поменять в этом фрагменте, то менять нам придётся всего в одном месте, а не в трёх. Но это ещё не всё! Сейчас мы рассмотрели простой вариант, когда всё рядом и в одном файле. В жизни же в файле может быть тысячи строк, и раскиданы они могут быть хаотично по всему файлу.

Одно дело зайти и поменять всё в одной функции, другое дело менять в 10 местах да ещё и искать по всему файлу. Но и это не всё! Сайты не состоят из одного файла, какой-нибудь фрагмент кода нам мог бы пригодиться в десятках различных файлов, и нам пришлось бы искать все повторения этого кода кучу времени. Благодаря функциям мы знаем, что, например, все функции мы храним в таком-то файле, зайду туда, и поменяю один раз.

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

Проверка на существование

В PHP нельзя 2 раза объявить одну и туже функцию. К примеру, если написать:

// любой код или без него } function siteOn(){ // любой код или без него } ?>

То получим следующую ошибку. Кстати, запоминайте все типичные ошибки:

Cannot redeclare siteOn() (previously declared in Z:\home\custom\www\index.php:3) in Z:\home\custom\www\index.php on line 9

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

Чтобы узнать, существует уже такая функция или нет, вы можете использовать встроенную функцию function_exists(). Пример:

// любой код или без него } if(function_exists("siteOn")){ echo "Такая функция уже есть!"; } ?>

Результат:

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

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

Аргумент функции ещё можно назвать её параметром. Выглядит это вот так:

В примере выше аргумент функции это переменная $author . Как его можно использовать? При вызове функций, мы можем передавать внутрь неё значение аргумента. Это придаёт нашим функциям небывалую гибкость и динамику:

"; } siteOn("Сергей"); // первый способ $name = "Андрей"; // второй способ siteOn($name); siteOn(); // ничего не передаём ?>

Результат:

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

Функция может иметь сколько угодно аргументов, например:

"; } siteOn("Сергей", "Site on!"); // первый способ $name = "Андрей"; // второй способ siteOn($name, "Сладкоешка"); siteOn("Фёдор Иванов"); // передали только 1 аргумент ?>

Результат:

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

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

"; } $text = "siteOn"; // заносим в переменную имя функции $text("Сергей", "Site on!"); // вызываем функцию через переменную ?>

Результат будет каким и обычно:

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

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

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

// закомментировали эти 2 строки, так как количество теперь передаётся при вызове функции // $rows = 20; // количество строк, tr // $cols = 20; // количество столбцов, td $table = "

"; for ($tr=1; $tr<=$rows; $tr++){ $table .= ""; for ($td=1; $td<=$cols; $td++){ if ($tr===1 or $td===1){ $table .= ""; }else{ $table .= ""; } } $table .= ""; } $table .= "

". $tr*$td ."	". $tr*$td ."

"; echo $table; } getTable(3,3); // выводим таблицу умножения 3 на 3 getTable(5,5); // выводим таблицу умножения 5 на 5 getTable(10,10); // выводим таблицу умножения 10 на 10 ?>

Результат:

Аргументы по умолчанию

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

"; } siteOn("Сергей"); ?>

В этом примере мы аргументу $blog присвоили значение по умолчанию Site on! После чего вызвали функцию всего с одним аргументом, а второй использовал своё значение по умолчанию.

Результат:

аргументы по умолчанию обязательно записываются последними.

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

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

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

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

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

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

" . $_SERVER["REMOTE_ADDR"] . "

"; }

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

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 "

Зеленых и красных всего - " . $total_green_red . "

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

Зеленых, красных и желтых всего - " . $total_green_red_yellow . "

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

Сумма значений - " . $all . "

";