Знакомство с PHP переменными. Переменные в PHP Вывод всех переменных в php

10.01.2022

Skype

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

При использовании переменных необходимо учитывать следующие правила:

В PHP не нужно объявлять переменную перед тем как начать её использовать.
Переменные в PHP представлены знаком доллара с последующим именем переменной .
Имена переменных чувствительны к регистру символов, это означает, что имена переменных $myVar , $MYVAR или $MyVar будут считаться, как имена трёх различных переменных.

Инициализация - это присвоение начального значения переменной. Присвоить какое-либо значение переменной можно с помощью оператора присваивания , который обозначается символом равно (=):

$str = "строка1, "; $Str = "строка2"; echo $str, $Str;

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

$x = 10; // Сначала присваивается число $x = "текст"; // Затем присваивается строка

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

$num1 = 10; $num2 = $num1; // Тоже самое, что и $num2 = 10;

В этом примере переменной $num1 присваивается число 10. Затем переменной $num2 присваивается значение переменной $num1 . Несмотря на то, что переменные $num1 и $num2 имеют одинаковое значение, каждая из них содержит собственную копию числа 10, поэтому изменение значения одной из них не повлияет на другую:

$num2: " . $num2; // 10 $num1 = 20; echo "
$num1: " . $num1; // 20 echo "
$num2: " . $num2; // 10 ?>

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

При работе со строками - пустую строку.
При работе с числами - число нуль.
Там, где ожидается булево значение - FALSE .
При работе с переменной в качестве массива - пустой массив.
При работе с переменной в качестве объекта - объект типа stdClass .
Без контекста использования - специальное значение NULL .

// При работе со строками $str = $str . "abc"; // Тоже самое, что и "" . "abc" // При работе с числами $num = $num + 25; // Тоже самое, что и 0 + 25 // Там, где ожидается булево значение $num = $bool ? 1: 2; // Тоже самое, что и FALSE ? 1: 2; // При работе с переменной в качестве массива $arr = "abc"; // Тоже самое, что и $arr = ; // При работе с переменной в качестве объекта $obj->foo = "abc"; // new stdClass; $obj->foo = "abc"; // Без контекста использования echo gettype($x); // NULL

Зачем нужны переменные?

Переменные помогают сделать программный код понятнее. Рассмотрим небольшой пример:

$total_price = 2.42 + 4.33; // Общая цена

Имеющиеся здесь числа могут означать что угодно. Чтобы стало понятнее, что здесь суммируется, можно присвоить 2.42 в качестве значения переменной $candy_price (цена конфет), а 4.33 - в качестве значения переменной $oil_price (цена масла):

$total_price = $candy_price + $oil_price;

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

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

Переменные переменных

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

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

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

Переменная в PHP — это именованная область в памяти, которая хранит в себе какие-либо данные: числа, строки (текст) и т.д. У каждой переменной в памяти имеется свой уникальный адрес, который даётся ей при её создании. Имя переменной ссылается на этот адрес.

У переменной имеется имя (которое вы придумываете сами при создании переменной), обращаясь к переменной по имени, можно получить данные которая она в себе хранит. Получая доступ к переменной по её имени, мы можем оперировать данными хранящимися в переменной: сохранять, считывать, изменять и удалять их.

Имена переменных в PHP начинаются со знака доллара $ :

$имяПеременной; // объявление переменной $имяПеременной = значение; // инициализация переменной

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

$имяПеременной = значение; // одновременное объявление и инициализация переменной

Значения переменных в PHP

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

Приведём примеры присваивания переменным различных значений:

$var = 5; // присвоили переменной число $var = "Строка"; // присвоили переменной строку $var = true; // присвоили переменной булево значение $var = NULL; // присвоили переменной значение NULL $var = array(1, "два", true); // присвоили переменной массив $var = $var; // присвоили переменной элемент массива $var = $_POST["var"]; // присвоили переменной данные из формы $var = new Object(); // присвоили переменной объект

Виды переменных в PHP

Переменные в PHP подразделяются на несколько видов, рассмотрим их:

Обычные переменные (присваивание по значению).
Ссылочные переменные (присваивание по ссылке).
Переменные переменных (динамические переменные).

Ссылочные переменные в PHP

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

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

$a = 5; $b = & $a; $a = 7; echo $b; // выведет 7

Если изменим значение переменной $b , то значение для переменной $a тоже изменится.

Переменные переменных в PHP

Переменные переменных (динамические переменные) применяются крайне редко, просто знайте о них. Чтобы использовать динамическую переменную, нужно перед именем переменной, добавить ещё один знак доллара $ .

$hello = "world"; $a = "hello"; echo $a; // покажет hello echo $ $a; // покажет world

Разберём четвёртую строку:
echo $$a — это $ и $a , $a — это hello , соединяем $ и hello , получаем переменную $hello которая имеет значение world .

Разное о переменных в PHP

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

Echo @$имяПеременной;

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

12 years ago

A little gotcha to watch out for:

If you turn off RegisterGlobals and related, then use get_defined_vars(), you may see something like the following:

Array
[ GLOBALS ] => Array
[ GLOBALS ] => Array
* RECURSION *
[ _POST ] => Array()
[ _GET ] => Array()
[ _COOKIE ] => Array()
[ _FILES ] => Array()
)

[ _POST ] => Array()
[ _GET ] => Array()
[ _COOKIE ] => Array()
[ _FILES ] => Array()

)
?>

Notice that $_SERVER isn"t there. It seems that php only loads the superglobal $_SERVER if it is used somewhere. You could do this:

print "

"
.
htmlspecialchars
(print_r
(get_defined_vars
(),
true
)) .
"

" ;
print "

"
.
htmlspecialchars
(print_r
($_SERVER
,
true
)) .
"

" ;
?>

And then $_SERVER will appear in both lists. I guess it"s not really a gotcha, because nothing bad will happen either way, but it"s an interesting curiosity nonetheless.

6 years ago

Since get_defined_vars() only gets the variables at the point you call the function, there is a simple way to get the variables defined within the current scope.

// The very top of your php script
$vars = get_defined_vars ();

// Now do your stuff
$foo = "foo" ;
$bar = "bar" ;

// Get all the variables defined in current scope
$vars = array_diff (get_defined_vars (), $vars );

echo "

"
;
print_r
($vars
);
echo
"

" ;
?>

15 years ago

Here is a function which generates a debug report for display or email
using get_defined_vars. Great for getting a detailed snapshot without
relying on user input.

function generateDebugReport ($method , $defined_vars , $email = "undefined" ){
// Function to create a debug report to display or email.
// Usage: generateDebugReport(method,get_defined_vars(),email);
// Where method is "browser" or "email".

// Create an ignore list for keys returned by "get_defined_vars".
// For example, HTTP_POST_VARS, HTTP_GET_VARS and others are
// redundant (same as _POST, _GET)
// Also include vars you want ignored for security reasons - i.e. PHPSESSID.
$ignorelist =array("HTTP_POST_VARS" , "HTTP_GET_VARS" ,
"HTTP_COOKIE_VARS" , "HTTP_SERVER_VARS" ,
"HTTP_ENV_VARS" , "HTTP_SESSION_VARS" ,
"_ENV" , "PHPSESSID" , "SESS_DBUSER" ,
"SESS_DBPASS" , "HTTP_COOKIE" );

$timestamp = date ("m/d/y h:m:s" );
$message = "Debug report created $timestamp \n" ;

// Get the last SQL error for good measure, where $link is the resource identifier
// for mysql_connect. Comment out or modify for your database or abstraction setup.
global $link ;
$sql_error = mysql_error ($link );
if($sql_error ){
$message .= "\nMysql Messages:\n" . mysql_error ($link );
}
// End MySQL

// Could use a recursive function here. You get the idea ;-)
foreach($defined_vars as $key => $val ){
if(is_array ($val ) && ! in_array ($key , $ignorelist ) && count ($val ) > 0 ){
$message .= "\n $key array (key=value):\n" ;
foreach($val as $subkey => $subval ){
if(! in_array ($subkey , $ignorelist ) && ! is_array ($subval )){
$message .= $subkey . " = " . $subval . "\n" ;
}
elseif(! in_array ($subkey , $ignorelist ) && is_array ($subval )){
foreach($subval as $subsubkey => $subsubval ){
if(! in_array ($subsubkey , $ignorelist )){
$message .= $subsubkey . " = " . $subsubval . "\n" ;
}
}
}
}
}
elseif(! is_array ($val ) && ! in_array ($key , $ignorelist ) && $val ){
$message .= "\nVariable " . $key . " = " . $val . "\n" ;
}
}

If($method == "browser" ){
echo nl2br ($message );
}
elseif($method == "email" ){
if($email == "undefined" ){
$email = $_SERVER [ "SERVER_ADMIN" ];
}

$mresult = mail ($email , "Debug Report for " . $_ENV [ "HOSTNAME" ]. "" , $message );
if($mresult == 1 ){
echo "Debug Report sent successfully.\n" ;
}
else{
echo "Failed to send Debug Report.\n" ;
}
}
}
?>

17 years ago

Simple routine to convert a get_defined_vars object to XML.

//Example object
$x -> name -> first = "John" ;
$x -> name -> last = "Smith" ;
$x -> arr [ "Fruit" ] = "Bannana" ;
$x -> arr [ "Veg" ] = "Carrot" ;
$y -> customer = $x ;
$y -> customer -> __attr -> id = "176C4" ;

$z = get_defined_vars ();
obj2xml ($z [ "y" ]);
?>
will output:

John
Smith

Bannana
Carrot

10 years ago

As a note, get_defined_vars() does not return a set of variable references (as I hoped). For example:

// define a variable
$my_var = "foo" ;

// get our list of defined variables
$defined_vars = get_defined_vars ();

// now try to change the value through the returned array
$defined_vars [ "my_var" ] = "bar" ;

echo $my_var , "\n" ;

?>

will output "foo" (the original value). It"d be nice if get_defined_vars() had an optional argument to make them references, but I imagine its a rather specialized request. You can do it yourself (less conveniently) with something like:

$defined_vars = array();
$var_names = array_keys (get_defined_vars ());

foreach ($var_names as $var_name )
{
$defined_vars [ $var_name ] =& $ $var_name ;
}

1 year ago

I posted here before about "this" being in get_defined_vars.

It turns out it"s not always there but in certain cases it will inexplicably appear.

Php -r "
class Test {
public function a() {var_dump(array_keys(get_defined_vars()));$a = 123;}
public function b() {var_dump(array_keys(get_defined_vars()));$this;}
}
$t = new Test();
$t->a();
$t->b();
"

Array()
array("this")

This does not happen in PHP 7.2 but will happen in PHP 5.6.

1 year ago

Some comments here point out that this function wont return references. It does however return names and names are "references".

I would not recommend the suggestions here that convert it to references.

Public function x($a, $b, $c) {
foreach(array_keys(get_defined_vars()) as $key)
if($key !== "this")
$this->y(${$key});
}

Public function y(&$input) {
$input++;
}

Instead of ${} you can also use $$.

I have done some whacky things in my time to make extremely generic code but I"ve never had to do anything like the above. It might not even work (but should since it"s no different to $a[$key]).

You could also do $$key++ but I"ve never seen code like that which wasn"t horrifically bad (using dynamic where dynamic isn"t beneficial).

If you"re doing something like that then give it additional scrutiny.

Переменную можно представить в виде яшика, внутри которого находится значение

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

Имена всех переменных в РНР начинаются со значка $ (знак доллара)

Например, $testVariable = 3; (следующее выражение создает переменную с именем $testVariable (и присваивает ей значение 3.

$testVariable = 3;

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

$testVariable = "Три";

Знак равенства, который мы использовали в двух последних выражениях, называется оператором присваивания. С его помощью переменным присваиваются значения. Для выполнения различных математических операций используются другие операторы.
$testVariable =1+1; // присваивает значение 2
$testVariable =1-1; // присваивает значение 0
$testVariable = 2*2; //присваивает значение 4
StestVariable =2/2; // присваивает значение 1
Глядя на этот пример, вы уже, вероятно, догадались, что + - оператор сложения, --оператор вычитания, * - оператор умножения, а / - оператор деления. Все они - арифметические операторы, выполняют действия с числами. Переменные можно использовать везде, где применяются конкретные символьные значения. Взгляните на следующий набор выражений.
$var1 = "РНР"; // присваивает значение "РНР" переменной $varl
$var2 = 5; // присваивает значение 5 переменной $var2
$var3 = $var2 + 1; //~присваивает значение 6 переменной $var3
$var2 = $varl; // присваивает значение "РНР" переменной $var2
echo $var1; // выволит "РНР"
echo $var2; // выводит "5"
echo $var3; // выводит "6"
echo $var1 . " - наше все!"; // выводит "РНР - наше все!"
echo "$var1 - наше все!"; // выводит "РНР - наше все!"
echo "$var1 - наше все!"; // выводит "$varl - наше все!"
Обратите внимание на две последние строки. Вы можете добавить имя переменной внутрь текста и получить ее значение в том же месте, если заключите строку в двойные кавычки вместо одинарных. Процесс преобразования имен переменных в их значения называется интерполяцией. Как видно на примере последней строки, текст, заключенный в одинарные кавычки, не интерполирует имена переменных в их содержимое.

Переменные в РНР - особые объекты, которые могут содержать в буквальном смысле все, что угодно. Если в программе что-то хранится, то оно всегда хранится в переменной (исключение - константа, которая, впрочем, может содержать только число или строку). При присваивании переменная в большинстве случаев копируется один-в-один, какую бы сложную структуру она ни имела. Единственное исключение из этого правила - копирование переменной, ссылающейся на объект: в этом случае объект остается в единственном экземпляре, копируется лишь ссылка на него...

Как уже говорилось, в РНР не нужно ни описывать переменные явно, ни указывать их тип. Интерпретатор все это делает сам. Однако иногда он может ошибаться (например, если в текстовой строке на самом деле задано десятичное число), поэтому изредка появляется необходимость явно указывать, какой же тип имеет то или иное выражение.

Типы переменных, которые поддерживает РНР:

integer (целое число)

Целое число со знаком, обычно длиной 32 бита (от -2 147 483 648 до 2 147 483 647, если это еще кому-то может быть интересно). double (вещественное число) Вещественное число довольно большой точности (ее должно хватить для подавляющего большинства математических вычислений).

string (строка текста)

Строка любой длины. В отличие от С, строки могут содержать в себе также и нулевые символы, что никак не повлияет на программу. Иными словами, строки можно использовать для хранения бинарных данных. Длина строки ограничена только размером свободой памяти, так что вполне реально прочитать в одну строку целый "объемистый" файл размером так килобайтов 200-300 (что часто и делается). Строка легко может быть обработана при помощи стандартных функций, допустимо также непосредственное обращение к любому ее символу.

array (ассоциативный массив)

Ассоциативный массив (или, как его часто называют программисты на Perl, хэш, хотя для РНР такое понятие совсем не подходит). Это набор из нескольких элементов, каждый из которых представляет собой пару вида ключ=> значение (символом => мы обозначаем соответствие определенному ключу какого-то значения). Доступ к отдельным элементам осуществляется указанием их ключа. Ключами здесь могут служить не только целые числа, но и любые строки.

Ссылка на объект, который реализует несколько принципов объектно-ориентированного программирования. Внутренняя структура объекта похожа на ассоциативный массив, за исключением того, что для доступа к отдельным элементам (свойствам) и функциям (методам) объекта используется оператор ->, а не квадратные скобки. Переменные в РНР версии 5 (в отличие от версии 4) хранят не сами объекты, а лишь ссылки на них. Это означает, что при копировании таких переменных (например, оператором $а = $obj) данные объекта в памяти не дублируются, и последующее изменение объекта $а повлечет за собой немедленное изменение объекта $obj.

resource (ресурс)

Некоторый ресурс, который РНР обрабатывает особым образом. Пример ресурса - переменная, содержащая дескриптор открытого файла. Такая переменная может в дальнейшем быть использована для того, чтобы указать РНР, с каким файлом нужно провести ту или иную операцию (например, прочитать строку). Другой пример: функция imageCreate () графической библиотеки GD создает в памяти новую "пустую" картинку указанного размера и возвращает ее идентификатор. Используя этот идентификатор, вы можете манипулировать картинкой (например, нарисовать в ней линию или вывести текст), а затем - сохранить результат в PNG- или JPEG-файл.

boolean (логический тип)

Существует и еще один "гипотетический" тип переменных - логический. Логическая переменная может содержать одно из двух значений: false (ложь) или true (истина). Вообще, любое ненулевое число (и непустая строка), а также ключевое слово true символизирует истину, тогда как 0, пустая строка и слово false - ложь. Таким образом, любое ненулевое выражение (в частности, значение переменной) рассматривается в логическом контексте как истина. Вы можете пользоваться константами false и true в зависимости от логики программы. При выполнении арифметических операций над логической переменной она превращается в обычную, числовую переменную. А именно, false рассматривается как О, a true - как 1.

NULL (специальное значение) Переменной можно присвоить специальную константу NULL (или null, эго одно и то же), чтобы пометить ее особым образом. Тип этой константы - особый и называется также NULL. Это именно отдельный тип, и функция gettype()

Действия с переменными

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

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

Проверка существования Можно проверить, существует ли (т. е. инициализирована ли) указанная переменная. Осуществляется это при помощи встроенного в РНР оператора isset. Например:
if (isset(SmyVar))
echo "Такая переменная есть. Ее значение SmyVar";

Если переменной в данный момент не существует (т. е. нигде ранее ей не присваивалось значение, либо же она была вручную удалена при помощи unset, то isset о возвращает ложь, в противном случае - истину. Важно помнить, что мы не можем использовать неинициализированную переменную в программе - иначе это породит предупреждение со стороны интерпретатора (что, скорее всего, свидетельствует о наличии логической ошибки в сценарии). Конечно, предупреждения можно выключить, тогда все неинициализированные переменные будут полагаться равными пустой строке. Однако мы категорически не советуем вам этого делать - уж лучше лишняя проверка присутствия в коде, чем дополнительная возня с "отлавливанием" потенциальной ошибки в будущем. Если вы все же захотите отключить это злополучное предупреждение (а заодно и все остальные), лучше использовать оператор отключения ошибок и, который действует локально/

Уничтожение

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

Переменная - это символическое обозначение области памяти, которое программист может использовать для присвоения произвольного значения. Изменять значение переменной можно в ходе выполнения программы. О непосредственном управлении данной областью памяти позаботится сам компьютер, нам необходимо лишь определить для переменной имя и присвоить ей значение. Необходимо помнить о том, что при использовании переменной перед ее именем нужно всегда ставить знак доллара ($) - именно так вы сообщаете РНР, что в данном случае используется переменная.

Правильные названия переменных:

$result,
$Result или
$reSULt.
Ошибки при вводе с клавиатуры названий переменных - вот одна из наиболее распространенных ошибок в РНР-скриптах.

Неправильные названия переменных, например:

$12_hoi.rs_AM (цифры в начале имени переменной),
$High Noon (наличие пробела)
$High-Noon (использование знака минус - это в РНР также специальный символ).

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

Оператор присваивания

Мы не сильно ошибемся, если скажем, что нет на свете такой программы, в которой не было бы ни одного оператора присваивания. И в РНР - программе этот оператор, конечно же, тоже есть. Мы уже с ним встречались, это - знак равенства (=): $ имя_переменной = значение;

Переменные в PHP представлены знаком доллара с последующим именем переменной. Имя переменной чувствительно к регистру.

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

Замечание : Под буквами здесь подразумеваются символы a-z, A-Z и байты от 128 до 255 (0x80-0xff ).

Замечание : $this - это специальная переменная, которой нельзя ничего присваивать.

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

$var = "Боб" ;
$Var = "Джо" ;
echo " $var , $Var " ; // выведет "Боб, Джо"

$ 4site = "еще нет" ; // неверно; начинается с цифры
$_4site = "еще нет" ; // верно; начинается с символа подчеркивания
$täyte = "mansikka" ; // верно; "ä" это (Расширенный) ASCII 228.
?>

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

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

$foo = "Боб" ; // Присваивает $foo значение "Боб"
$bar = & $foo ; // Ссылка на $foo через $bar.
$bar = "Меня зовут $bar " ; // Изменение $bar...
echo $bar ;
echo $foo ; // меняет и $foo.
?>

$foo = 25 ;
$bar = & $foo ; // Это верное присвоение.
$bar = &(24 * 7 ); // Неверно; ссылка на неименованное выражение.

Function test ()
{
return 25 ;
}

$bar = & test (); // Неверно.
?>

Хорошей практикой считается инициализировать переменные, хотя в PHP это и не является обязательным требованием. Неинициализированные переменные принимают значение по умолчанию в зависимости от их типа, который определяется из контекста их первого использования: булевы принимают значение FALSE , целые числа и числа с плавающей точкой - ноль, строки (например, при использовании в echo ) - пустую строку, а массивы становятся пустыми массивами.

Пример #1 Значения по умолчанию в неинициализированных переменных

// Неустановленная И не имеющая ссылок (то есть без контекста использования) переменная; выведет NULL
var_dump ($unset_var );

// Булевое применение; выведет "false" (Подробнее по этому синтаксису смотрите раздел о тернарном операторе)
echo($unset_bool ? "true\n" : "false\n" );

// Строковое использование; выведет "string(3) "abc""
$unset_str .= "abc" ;
var_dump ($unset_str );

// Целочисленное использование; выведет "int(25)"
$unset_int += 25 ; // 0 + 25 => 25
var_dump ($unset_int );

// Использование в качестве числа с плавающей точкой (float/double); выведет "float(1.25)"
$unset_float += 1.25 ;
var_dump ($unset_float );

// Использование в качестве массива; выведет array(1) { => string(3) "def" }
$unset_arr [ 3 ] = "def" ; // array() + array(3 => "def") => array(3 => "def")
var_dump ($unset_arr );

// Использование в качестве объекта; создает новый объект stdClass (см. http://www..classes.php)
// Выведет: object(stdClass)#1 (1) { ["foo"]=> string(3) "bar" }
$unset_obj -> foo = "bar" ;
var_dump ($unset_obj );
?>

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

8 years ago

This page should include a note on variable lifecycle:

Before a variable is used, it has no existence. It is unset. It is possible to check if a variable doesn"t exist by using isset(). This returns true provided the variable exists and isn"t set to null. With the exception of null, the value a variable holds plays no part in determining whether a variable is set.

Setting an existing variable to null is a way of unsetting a variable. Another way is variables may be destroyed by using the unset() construct.

print isset($a ); // $a is not set. Prints false. (Or more accurately prints "".)
$b = 0 ; // isset($b) returns true (or more accurately "1")
$c = array(); // isset($c) returns true
$b = null ; // Now isset($b) returns false;
unset($c ); // Now isset($c) returns false;
?>

is_null() is an equivalent test to checking that isset() is false.

The first time that a variable is used in a scope, it"s automatically created. After this isset is true. At the point at which it is created it also receives a type according to the context.

$a_bool = true ; // a boolean
$a_str = "foo" ; // a string
?>

If it is used without having been given a value then it is uninitalized and it receives the default value for the type. The default values are the _empty_ values. E.g Booleans default to FALSE, integers and floats default to zero, strings to the empty string "", arrays to the empty array.

A variable can be tested for emptiness using empty();

$a = 0 ; //This isset, but is empty
?>

Unset variables are also empty.

empty($vessel ); // returns true. Also $vessel is unset.
?>

Everything above applies to array elements too.

$item = array();
//Now isset($item) returns true. But isset($item["unicorn"]) is false.
//empty($item) is true, and so is empty($item["unicorn"]

$item [ "unicorn" ] = "" ;
//Now isset($item["unicorn"]) is true. And empty($item) is false.
//But empty($item["unicorn"]) is still true;

$item [ "unicorn" ] = "Pink unicorn" ;
//isset($item["unicorn"]) is still true. And empty($item) is still false.
//But now empty($item["unicorn"]) is false;
?>

For arrays, this is important because accessing a non-existent array item can trigger errors; you may want to test arrays and array items for existence with isset before using them.

7 years ago

"Note: $this is a special variable that can"t be assigned."

While the PHP runtime generates an error if you directly assign $this in code, it doesn"t for $$name when name is "this".

$this = "text" ; // error

$name = "this" ;
$ $name = "text" ; // sets $this to "text"

2 years ago

I highly recommend to use an editor that can list all variable names in a separate window.

The reason are typing errors in variable names.

$somename = "nobody" ;
// Now we want to use $somename somewhere
echo $somemane ;
?>
And wonder why it doesn"t print "nobody".
The reason is simple, we have a typing error in $somename and $somemane is a new variable.

In this example it might be easy to find. But if you use variables to calculate some things, you might hardly find it and ask yourself why your calculation is always wrong.
With an editor that list all variable names in a separate window such "double" variables but with wrong typing can be easily found.

BTW:
It would have been better, if the PHP language would require to use some sort of keyword to define a variable the first time.