Windows

Область видимости переменной. PHP глобальная переменная в функции. Сделать переменную глобальной в PHP Php 7 глобальные переменные

В 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. Объясняется различие локальной и глобальной области видимости, показывается как получить доступ к глобальным переменным внутри функции, как работать с суперглобалами и создавать статические переменные.

Когда приступаешь к изучению 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.

Область видимости переменной - это контекст, в котором эта переменная определена. В большинстве случаев все переменные 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 все объявленные и используемые в функции переменные по умолчанию локальны для функции. То есть, по умолчанию нет возможности изменить значение глобальной переменной в теле функции.

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

Поясним данный факт на конкретном примере:

$a = 100 ;

function funct () {
$a = 70 ;
echo "

$a

" ;
}
funct ();
echo "

$a

" ;
?>

Сценарий выведет сперва 70, а затем 100:

70
100

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

$a = 1 ;
$b = 2 ;

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

$b = $a + $b ;
}

Sum ();
echo $b ;
?>

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

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

Использование $GLOBALS вместо global:

$a = 1 ;
$b = 2 ;

Function Sum ()
{
$GLOBALS [ "b" ] = $GLOBALS [ "a" ] + $GLOBALS [ "b" ];
}

Sum ();
echo $b ;
?>

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

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

Echo $HTTP_POST_VARS [ "name" ];

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

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

В этом примере переменная $a будет доступна также внутри включенного скрипта - main.inc .

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

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

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

30 ?>

В результате исполнения этого фрагмента будет выведено: 30.

Внутри функции birth() выполняется присваивание переменной $age значения 1, но это не таже самая переменная, что была определена в глобальной области видимости. Поэтому, когда выполняется вывод на экран значения переменной $age , выводится первоначальное значение 30. Стоит отметить, что локальные переменные создаются в момент вызова функции и удаляются после окончания работы функции.

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