Не передаются глобальные переменные в php. Php7 - PHP: global внутри функции не показывает переменную - Stack Overflow на русском

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

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

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

Последнее обновление: 1.11.2015

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

Локальные переменные

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

В данном случае в функции get() определена локальная переменная $result . И из общего контекста мы не можем к ней обратиться, то есть написать $a = $result; нельзя, так как область действия переменной $result ограничено функцией get() . Вне этой функции переменной $result не существует.

То же самое относится и к параметрам функции: вне функции параметры $lowlimit и $highlimit также не существуют.

Как правило, локальные переменные хранят какие-то промежуточные результаты вычислений, как и в примере выше.

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

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

Чтобы указать, что переменная будет статической, к ней добавляется ключевое слово static . При трех последовательных вызовах функции getCounter() переменная $counter будет увеличиваться на единицу.

Если бы переменная $counter была обычной нестатической, то при каждом вызове функция getCounter() выводила бы 1.

Как правило, статические переменные служат для создания различных счетчиков, как в примере выше.

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

Иногда требуется, чтобы переменная была доступна везде, глобально. Подобные переменные могут хранить какие-то общие для всей программы данные. Для определения глобальных переменных используется ключевое слово global :1

"; } getGlobal(); echo $gvar; ?>

После вызова функции getGlobal() к переменной $gvar можно будет обратиться из любой части программы.

В JavaScript глобальные переменные имеют огромное значение, и они постоянно используются при написании скриптов. В PHP глобальные переменные - редко замечаемое явление, особенно если Вы используете ООП , однако, знать о них стоит. Если Вы вдруг не знаете про глобальные переменные в PHP , то эта статья заполнит этот пробел в знаниях.

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

Давайте разберём вот такой пример PHP-кода :

$x = 5; // Создаём переменную (разумеется, она глобальная)
function myFunc1() {
$x = 7; // Локальная переменная, доступная только внутри функции
}
function myFunc2() {
global $x; // Указываем, что $x - это глобальная переменная
$x = 7; // Изменяем глобальную переменную $x
}
myFunc1();
echo $x; // Выведет 5
echo "
";
myFunc2();
echo $x; // Выведет 7
print_r($GLOBALS); // Выводит все глобальные переменные
?>

При выводе $x в первый раз мы получили 5 , поскольку внутри функции myFunc1() мы создали локальную переменную $x , которая ничего общего с глобальной переменной $x не имеет. Таким образом, мы, изменяя значение локальной переменной, никак его не изменили у глобальной.

Во 2-ой функции мы перед использованием $x указали, что внутри данной функции $x должна быть глобальной, то есть мы внутри функции получили доступ к глобальной переменной. В результате, мы изменили её значение, о чём нам echo и сообщил.

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

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

Область видимости переменной - это контекст, в котором эта переменная определена. В большинстве случаев все переменные PHP имеют только одну область видимости. Эта единая область видимости охватывает также включаемые (include) и требуемые (require) файлы. Например:

$a = 1 ;
include "b.inc" ;
?>

Здесь переменная $a будет доступна внутри включенного скрипта b.inc . Однако определение (тело) пользовательской функции задает локальную область видимости данной функции. Любая используемая внутри функции переменная по умолчанию ограничена локальной областью видимости функции. Например:

$a = 1 ; /* глобальная область видимости */

Function test ()
{
echo $a ; /* ссылка на переменную локальной области видимости */
}

Test ();
?>

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

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

Сначала пример использования global :

Пример #1 Использование global

$a = 1 ;
$b = 2 ;

function Sum ()
{
global $a , $b ;

$b = $a + $b ;
}

Sum ();
echo $b ;
?>

Вышеприведенный скрипт выведет 3 . После определения $a и $b внутри функции как global все ссылки на любую из этих переменных будут указывать на их глобальную версию. Не существует никаких ограничений на количество глобальных переменных, которые могут обрабатываться функцией.

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

$GLOBALS - это ассоциативный массив, ключом которого является имя, а значением - содержимое глобальной переменной. Обратите внимание, что $GLOBALS существует в любой области видимости, это объясняется тем, что $GLOBALS является суперглобальным . Ниже приведен пример, демонстрирующий возможности суперглобальных переменных:

Пример #3 Суперглобальные переменные и область видимости

function test_global ()
{
// Большинство предопределенных переменных не являются
// "супер", и чтобы быть доступными в локальной области
// видимости, функции требуют указания "global".
global $HTTP_POST_VARS ;

Echo $HTTP_POST_VARS [ "name" ];

// Суперглобальные переменные доступны в любой области
// видимости и не требуют указания "global".
// Суперглобальные переменные доступны, начиная с PHP 4.1.0, а
// использование HTTP_POST_VARS считается устаревшим.
echo $_POST [ "name" ];
}
?>

Замечание :
Использование ключевого слова global вне функции не является ошибкой. Оно может быть использовано в файле, которые включается внутрь функции.

Использование статических (static ) переменных

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

Пример #4 Демонстрация необходимости статических переменных

function test ()
{
$a = 0 ;
echo $a ;
$a ++;
}
?>

Эта функция довольно бесполезна, поскольку при каждом вызове она устанавливает $a в 0 и выводит 0 . Инкремент переменной $a ++ здесь не играет роли, так как при выходе из функции переменная $a исчезает. Чтобы написать полезную считающую функцию, которая не будет терять текущего значения счетчика, переменная $a объявляется как static:

Пример #5 Пример использования статических переменных

function test ()
{
static $a = 0 ;
echo $a ;
$a ++;
}
?>

Теперь $a будет проинициализирована только при первом вызове функции, а каждый вызов функции test() будет выводить значение $a и инкрементировать его.

Статические переменные также дают возможность работать с рекурсивными функциями. Рекурсивной является функция, вызывающая саму себя. При написании рекурсивной функции нужно быть внимательным, поскольку есть вероятность сделать рекурсию бесконечной. Вы должны убедиться, что существует адекватный способ завершения рекурсии. Следующая простая функция рекурсивно считает до 10, используя для определения момента остановки статическую переменную $count:

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

Пример #7 Объявление статических переменных

function foo (){
static $int = 0 ; // верно
static $int = 1 + 2 ; // неверно (поскольку это выражение)
static $int = sqrt (121 ); // неверно (поскольку это тоже выражение)
$int ++;
echo $int ;
}
?>

Замечание :
Статические объявления вычисляются во время компиляции скрипта.

Ссылки с глобальными (global ) и статическими (static ) переменными

Движок Zend Engine 1, лежащий в основе PHP 4, оперирует модификаторами переменных static и global как ссылками . Например, реальная глобальная переменная, внедренная в область видимости функции указанием ключевого слова global , в действительности создает ссылку на глобальную переменную. Это может привести к неожиданному поведению, как это показано в следующем примере:

function test_global_ref () {
global $obj ;
$obj = &new stdclass ;
}

function test_global_noref () {
global $obj ;
$obj = new stdclass ;
}

Test_global_ref ();
var_dump ($obj );
test_global_noref ();
var_dump ($obj );
?>

Результат выполнения данного примера:get_instance_noref () {
static $obj ;

Echo "Статический объект: " ;
var_dump ($obj );
if (!isset($obj )) {
// Присвоить объект статической переменной
$obj = new stdclass ;
}
$obj -> property ++;
return $obj ;
}

$obj1 = get_instance_ref ();
$still_obj1 = get_instance_ref ();
echo "\n" ;
$obj2 = get_instance_noref ();
$still_obj2 = get_instance_noref ();
?>

Результат выполнения данного примера:

Статический объект: NULL
Статический объект: NULL

Статический объект: NULL
Статический объект: object(stdClass)(1) {
["property"]=>
int(1)
}

Этот пример демонстрирует, что при присвоении ссылки статической переменной она не запоминается , когда вы вызываете функцию &get_instance_ref() во второй раз.

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

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

Что такое область видимости?

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

Глобальная - к переменным можно получить доступ в любом месте скрипта
Локальная - к переменным можно получить доступ только внутри функции, в которой они были определены

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

Переменные с глобальной областью видимости называются глобальными, а с локальной областью видимости - локальными.

Вот пример того, как работают глобальные и локальные переменные.

"; } sayHello(); echo "Значение \$globalName: "$globalName"
"; echo "Значение \$localName: "$localName"
"; ?>

Привет, Гарри! Значение $globalName: "Зоя" Значение $localName: ""

В данном скрипте мы создали две переменных:

$globalName - это глобальная переменная
$localName - это локальная переменная, которая создана внутри функции sayHello() .

После создания переменной и функции скрипт вызывает sayHello() ,который выводит "Привет, Гарри!" . Затем скрипт пытается вывести значения двух переменных с помощью функции echo . Вот что происходит:

Так как $globalName была создана вне функции, она доступна в любом месте скрипта, поэтому выводится "Зоя" .
$localName будет доступна только внутри функции sayHello() . Так как выражение echo находится вне функции, PHP не дает доступа к локальной переменной. Вместо этого, PHP предполагает, что код будет создавать новую переменную с именем $localName , которая получит значение по умолчанию - пустую строку. вот почему второй вызов echo выводит значение "" для переменной $localName .

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

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

Function myFunction() { global $globalVariable; // Доступ к глобальной переменной $globalVariable }

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

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

"; global $globalName; echo "Привет, $globalName!
"; } sayHello(); ?>

При выполнении скрипт выведет:

Привет, Гарри! Привет, Зоя!

Функция sayHello() использует ключевое слово global для объявления переменной $globalName как глобальной. После чего она может получить доступ к переменной и вывести ее значение ("Зоя").

Что такое суперглобалы?

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

Вот список суперглобалов, доступных в PHP версии 5.3:

$GLOBALS - список всех глобальных переменных в скрипте (исключая суперглобалов)
$_GET - содержит список всех полей формы, отправленной браузером с помощью запроса GET
$_POST - содержит список всех полей формы отправленной браузером с помощью запроса POST
$_COOKIE - содержит список всех куки, отправленных браузером
$_REQUEST - содержит все сочетания ключ/значение, которые содержатся в массивах $_GET, $_POST, $_COOKIE
$_FILES - содержит список всех файлов, загруженных браузером
$_SESSION - позволяет хранить и использовать переменные сессии для текущего браузера
$_SERVER - содержит информацию о сервере, такую как, имя файла выполняемого скрипта и IP адрес браузера.
$_ENV - содержит список переменных среды, передаваемых PHP, например, CGI переменные.

Например, можно использовать $_GET для того, чтобы получить значения переменных заключенных в строке URL запроса скрипта, и вывести их на странице:

Если вы запустите выше приведенный скрипт с помощью строки URL http://www.example.com/script.php?yourName=Фред, то он выведет:

Привет, Фред!

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

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

"; } sayHello(); // Выводит "Привет, Зоя!" ?>

Статические переменные: они находятся где-то рядом

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

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

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

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

Function myFunction() { static $myVariable = 0; }

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

"; echo createWidget() . " мы уже создали.
"; echo createWidget() . " мы уже создали.>
"; ?>

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

Создаем некие виджеты... 1 мы уже создали. 1 мы уже создали. 1 мы уже создали.

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

"; echo createWidget() . " мы уже создали.
"; echo createWidget() . " мы уже создали.
"; echo createWidget() . " >мы уже создали.
"; ?>

Теперь скрипт выдаст ожидаемый результат:

Создаем некие виджеты... 1 мы уже создали. 2 мы уже создали. 3 мы уже создали.

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

Вот и все! Почаще обращайтесь к документации по PHP.