Функции php. Функции в PHP Php для вызова функции не нужно указать

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

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

Создаем свою первую php функцию

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

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

Вот как выглядит объявление функции myCompanyName:

Примечание : Название функции может начинаться со знака «_», но не с цифры!
Это лишь каркас нашей функции, а внутри него мы можем поместить любой код, который захотим. При вызове функции он будет выполняться. Видите в фигурных скобках в приведенном выше примере «{}»? Эти скобки определяют, где должен быть наш код функции. Открывающая фигурная скобка «{» говорит PHP, что код функции начинается, а закрывающая фигурная «}» говорит PHP, что наша функция окончена!

Давайте добавим в нее что-то простенькое, например .

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

Вызов готовой функции php

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

!
"; myCompanyName(); echo "Рад вас видеть!
";

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

• Всегда начинайте ваши функции с ключевым словом function.
• Помните, что ваш код функции должны быть между «{» и «}».
• Когда вы вызываете функцию, убедитесь, что пишете ее имя правильно.

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

Еще одна полезная возможность состоит в том, что функции вы можете вызывать с параметрами, то есть передавать внутрь ее кода дополнительную информацию. Наша первая функция myCompanyName не очень-то и полезна, потому что все что она умеет, это печатать одну и ту же строку.

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

"; } ?>

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

Возвращение значения функцией php

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

Как она возвращает значение? Лучше всего разобраться на примере. Объявим функцию с параметрами, а затем присвоим результат некоторой переменной, вот так:

"; $myNumber = mySum(3, 4); // Сохраняем результат вызова функции mySum в переменную $myNumber echo "После вызова функции, myNumber = " . $myNumber ."
"; ?>

Чтобы присвоить функции значение — в нее добавляется оператор return, видите его? Результат сложения двух чисел хранится в переменной $total, а с помощью return $total это значение передается самой функции. Затем мы просто присваиваем его переменной $myNumber после вызова функции mySum с двумя параметрами 3 и 4 (это числа которые следует сложить).

Практикуйтесь, разбирайтесь и у вас все получится!

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

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

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

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

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

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

Function имя_функции([параметры]) { блок кода }

Квадратные скобки () означают необязательность. Теперь приведем простой пример определения функции:

Для вызова функции используется оператор вызова, представляющий из себя пару круглых скобок. Завершается вызов функции как и все инструкции точкой с запятой (;):

При вызове функции исполняются инструкции, расположенные в ее теле.

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

Все функции в PHP имеют глобальную область видимости - они могут быть вызваны вне функции, даже если были определены внутри и наоборот:

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

Пользовательские функции создаются с помощью ключевого слова 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 . "

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

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

В любом языке программирования существуют подпрограммы. В языке C они называются функциями, в ассемблере - подпрограммами, а в Pascal существуют даже два вида подпрограмм: процедуры и функции.

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

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

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

Создание пользовательских функций

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

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

function Имя (аргумент1[=значение1],...,аргумент1[=значение1])
{
тело_функции
}

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

Требования, предъявляемые к именам функций:

• Имена функций могут содержать русские буквы, но давать функциям имена, состоящие из русских букв не рекоммендуется;
• Имена функций не должны содержать пробелов;
• Имя каждой пользовательской функции должно быть уникальным. При этом, необходимо помнить, что регистр при объявлении функций и обращении к ним не учитывается. То есть, например, функции funct() и FUNCT() имеют одинаковые имена;
• Функциям можно давать такие же имена, как и переменным, только без знака $ в начале имен.

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

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

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

Здравствуйте уважаемые читатели блога 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 . " раз.

Результат:

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

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

Результат:

Сделаем так, чтобы вместо вывода на экран она возвращала результат выполнения. Для этого используется ключевое слово 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() или любую другую.

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