Что такое переменные в php. Основы

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

В PHP имя переменной всегда начинается со знака доллара ($), за которым обязательно должна следовать буква, после которой можно использовать буквы, цифры и знак подчёркивания. Имена чувствительны к регистру символов, т.е. переменные $value, $Value, $VALUE и $VaLuE - четыре РАЗНЫХ переменных, хотя их имя и читается одинаково.

Примеры синтаксически правильных имён переменных:

Пример некорректных имён:

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

Пример плохо читаемого кода

Краткость, конечно, сетстра таланта, но жертвовать простотой восприятия кода ради его компактности - неразумно. Тем более, что длина имени никак не влияет на производительнось скрипта. Но не стоит и впадать в противоположную крайность - давать переменным слишком длинные имена. Если имя должно состоять из двух и более слов - части имени нужно выделять заглавными буквами или разделять подчёркиваниями. Например, имя $strusernameadndomain намного лучше воспринимается в виде $str_UserNameAndDomain .

Пример хорошо читаемого кода

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

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

Рассмотрим пример:

Передача переменных по значению

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

• isset() - проверяет, была ли объявлена переменная и отличается ли её значение от NULL;
• empty() - аналог isset()
• unset() - встроенная функция языка, удаляющая значение переменной и удаляющая саму переменную из списка доступных переменных (уничтожающая переменную).

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

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

Блоками программы в данном случае являются "скрипт", "функция" или "класс". Например:

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

Исправить положение очень легко, достаточно добавить всего одну строку (выделена жирным шрифтом):

global $name; // явно указываем, что надо // использовать глобальную переменную. $fullName = $name . $family; echo "Имя внутри функции: ".$fullName; } echo "Имя ДО вызова функции: ".$name; // результат: "Имя ДО вызова функции: Вася" tryChengeName(" Иванов"); // результат: "Имя внутри функции: Вася Иванов" echo "Имя ПОСЛЕ вызова функции: ".$name; // результат: "Имя ПОСЛЕ вызова функции: Вася Иванов" ?>

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

Примеры работы с классами мы рассмотрим в разделе "Классы и наследование".

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

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

Настоятельно не рекомендуется пользоваться подобными приёмами без острой необходимости. Код, напичканый такими трюками, очень сложно сопровождать. Особенно это важно при работе с данными, вводимыми пользователями. Главная причина сложностей - неявные зависимости. Например, что случится, если вместо имени "Вася" написать что-то вроде """""_;%//^q"" ? Правильно! Скрипт в большинстве случаев не сможет выполниться! Можно, конечно, добавить кучу проверок на наличие "неправильных" символов, но проще вообще не пользоваться такими трюками.

Константы

Константа - это некая неизменная величина. Константа объявляется одновременно с именем и значением. Для объявления константы служит функция define() , а для определения наличия константы (т.е. была она определена или нет) - функция defined() . Имя константы строится по тем же правилам, что и имена переменных.

Примеры констант:

Отдельный вид констант PHP - так называемые "магические константы". Это системные константы, значение которых определяет и устанавливает интерпретатор. Таких констант немного:

• __LINE__ Содержит номер текущей строки в текущем файле.
• __FILE__ Содержит полное имя текущего файла
• __FUNCTION__ Содержит имя текущей функции.
• __CLASS__ Содержит имя текущего класса.
• __METHOD__ Содержит имя текущего метода текущего класса.

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

— это ячейка памяти для хранения данных.

Почти все данные с которыми работает программа находятся в переменных.

Каждая переменная имеет своё собственное имя которое ей даёт программист.

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

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

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

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

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

Имена переменных чувствительны к регистру букв, что конечно упрощает их выбор, так как next и nExt уже будут два разных имени.

Давайте напишем скрипт с переменными, и выведем содержащиеся в них данные на экран.

$next = "Это данные в переменной";
$nExt = "Это данные в другой переменной";
echo "$next. $nExt";
?>

Браузер должен показать вот такую строку.

Разберём скрипт по составу.

$ — с этого знака всегда начинается имя переменной.
nExt — имя переменной.
= — оператор присвоения.
"Это данные в другой переменной" — значение переменной.
echo — команда вывод на экран.
?> — конечный тег php

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

Объявление переменной делается один раз в начале скрипта, после чего она может использоваться бесконечное число раз без указания содержимого.

И в подтверждении этого ещё один скрипт, в котором для вывода на экран используется только название переменной.

$scolco_let= 5.5 ;
$marcaAvto= "Лада";
$probegAvto= 100 ;

?>

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

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

Делается это следующим образом: после имени переменной ставится нужный математический оператор, определяющий вид действия (+, -, *, /), затем оператор присвоения (=), и число, на которое нужно произвести действие.

$x= 10 ;
$x+= 10 ;
echo "$x";
?>

Эта программа выведет число 20.

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

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

Если по простому, то тип переменной определяется её содержанием. Если в переменной число — это integer или double (числовые типы), если строка — строковой тип string и т.д.

На имя переменной её тип не влияет, т.е. по имени невозможно определить к какому типу переменная относится.

Для определения типа переменной, при необходимости, есть специальная функция, но об этом чуть ниже.

Основные типы переменных:

integer — Целые числа разрядность которых зависит от разрядности операционной системы компьютера.

Если она составляет 32 бита то число может принимать значение от -2 147 483 648 до 2 147 483 647, если разрядность 64 бита, то от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807.

double (float) — Число с плавающей точкой значение которого возможно от 1.7 х 10 -308 до 1.7 х 10 308 с любым знаком (+ или -).

string — Строковый тип. может хранить строки любого объёма.

boolean — логический тип принимающий лишь два значения: true (истина) и false (ложь).

array — Тип массивы — это объединение нескольких однотипных переменных.

object — Тип объект — объединение нескольких разнотипных переменных и методов их обработки.

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

NULL — Специальный тип, предупреждающий о том что переменная не была инициализирована.

Рассмотрим их в общих чертах по порядку. Хоть переменные php и не требуют строгого задания типа, при их объявлении, но общие понятия о них, думаю, иметь всё же необходимо.

Целые числа (integer) .

Целые числа — это наиболее простой, а значит и наиболее быстродействующий тип данных. По умолчанию задаются они в десятичной системе исчисления. Однако php допускает задавать их в восьмеричной и шестнадцатеричной системах.

Что это значит? В восьмеричной системе основанием числа служит величина 8, так же как 10 в десятичной системе, а для всех чисел используются цифры от 0 до 7

В шестнадцатеричной, соответственно, величина 16, и цифры от 0 до 9. Кроме того в шестнадцатеричной системе для выражения числа применяются буквы английского алфавита A, B, C, D, E, F, обозначающие цифры, соответственно 10, 11, 12, 13, 14, 15.

В значениях переменных перед числом в восьмеричной системе ставиться префикс 0, а в шестнадцатеричной — 0х

$next= 123 ; //десятичное число
$next= 0123 ; //восьмеричное число
$next= 0x123 ; //шестнадцатеричное число
$next= 0xABCDEF ; //шестнадцатеричное число
?>

Число с плавающей точкой, вещественное число (double или float) .

Эти числа имеют огромнейший интервал, за пределы которого, пока во всяком случае, программы никогда не выходят.

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

//Объявление вещественного числа в стандартной форме
$next= 1.23456 ;
$next= -1.23456 ; //Отрицательное вещественное число
//Объявление вещественного числа в научной форме
$next= 1.23456 ; //Положительное вещественное число
$next= 1.23456e+2 ; //Положительное число больше единицы (123.456)
$next= 1.23456e-2 ; //Положительное число меньше единицы (0.0123456)
?>

Как видите, в научной записи порядок указывается буквой «е» и числом определяющим его величину.

Строки (string)

Строки могут принимать любой, произвольный размер, и формируются путём заключения той или иной фразы в кавычки. В php используется 3 вида кавычек.

Это прямые двойные кавычки, прямые одиночные кавычки (апострофы), и прямые обратные кавычки (обратные апострофы).

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

echo "Зададим class="next" для следующих элементов";
?>

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

$scolco_let= 5.5 ;
$marcaAvto= "Лада";
$probegAvto= 100 ;
echo "За $scolco_let лет $marcaAvto проехала $probegAvto тыс. км.";
?>

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

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

echo "Зададим class=\"next\" для следующих элементов";
?>

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

$next= "Бензо";
echo "Работает {$next}-генератор."; //Работает Бензо-генератор.
echo "Засорился {$next}насос."; //Засорился Бензонасос.
?>

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

Как уже говорилось выше, переменные этого типа могут принимать только два значения — TRUE (истина) и FALSE (ложь). Используются они для сравнения и управления циклами.

Более подробно их рассмотрим в статье посвящённой операторам php.

Массивы(array)

Массивы — это набор данных, состоящий из однотипных элементов.

$next[ 0 ]= "Бульдог";
$next[ 1 ]= "Питбуль";
$next[ 2 ]= "Дог";
echo $next[ 0 ] ;
echo "
";
echo $next[ 1 ] ;
echo "
";
echo $next[ 2 ] ;
?>

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

Объект(object)

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

Структура объекта схожа с массивом, только для доступа к его отдельным элементам применяются не квадратные скобки, а оператор ->.

Инициализации объекта осуществляется выражением new, которое создаёт в переменной экземпляр объекта.

class foo
{
function do_foo()
{
echo "Doing foo.";
}
}

$bar = new foo;
$bar-> do_foo();
?>

К объектам мы ещё вернёмся и будем изучать их более подробно.

Специальный тип NULL предназначен для того, чтоб отметить неинициализированную переменную. Такая переменная образуется, если в ней пропущен оператор присвоения = , или если она уничтожается конструкцией unset() .

Определение типа переменной

Для определения типа переменной, в php поддерживается несколько типов функций. Это функции проверяющие принадлежность переменной к определённому типу данных (is_string() , is_integer() , is_bolead() и так далее).

Все они начинаются префиксом is_ после которого идёт название типа.

Универсальной функцией, позволяющей определить тип любой переменной, является функция gettype() . Получив в качестве аргумента переменную, она возвращает её тип.

//Объявляем переменную с целым числом
$next= 123 ;
echo gettype($next); //выведет integer

//Объявляем переменную с вещественным числом
$next= 1.23456 ;
echo gettype($next); //выведет double

//Объявляем переменную со строкой
$next= "......";
echo gettype($next); //выведет string
?>

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

Перемена

– Мама! А правда я такая страшная?
– Сейчас ничего, а когда родилась, доктор сказал: «Зашевелится, стреляйте…»

1.3K

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

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

Присвоение имени и создание переменной в PHP

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

Посмотрим на некоторые допустимые и недопустимые имена переменных PHP :

$_myName // допустимо. $myName // допустимо. $__myvar // допустимо. $myVar21 // допустимо. $_1Big // недопустимо, подчеркивание должно следовать после буквы. $1Big // недопустимо - должно начинаться с буквы или символа подчеркивания. $_er-t // недопустимо - содержит буквенно-цифровой символ (-).

Имена PHP переменных чувствительны к регистру. Это означает, что PHP считает переменную $ _myVariable отличной от переменной » $ _myvariable .

Присвоение значения переменной РНР

Переменные инициализируются значениями с помощью оператора присваивания PHP (=) . Чтобы присвоить значение переменной, ее имя помещается слева от выражения, за которым следует оператор присваивания. Значение, которое присваивается после PHP объявления переменных, помещается справа от оператора присваивания. Строка, как и во всех выражениях PHP кода , завершается точкой с запятой (;) .

Начнем с присвоения слова «Круг » переменной с именем myShape :

$myShape = "Круг";

Мы объявили переменную с именем myShape и присвоили ей строковое значение «Круг «. Аналогичным образом можно объявить переменную, содержащую численное значение:

$numberOfShapes = 6;

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

Доступ к PHP значениям переменных

Теперь мы должны рассмотреть, как получить доступ к текущему значению, присвоенному переменной. Например, если мы хотим вывести на экран значение, которое мы присваивали переменной numberOfShapes , нужно сослаться на него в команде echo :

Это приведет к следующему выводу в браузере:

Номер фигуры 6.

Точно так же можно отобразить значение переменной myShape :

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

То, что нам нужно в этом случае выводится следующим образом:

Круг это 6-я фигура.

К сожалению, PHP будет видеть th на конце имени переменной $ numberOfShapes как часть имени. Затем он попытается вывести значение переменной $ numberOfShapesth , которой не существует. Это приводит к тому, что значение этой переменной не отображается:

Круг это фигура.

Можно обойти эту проблему, поставив фигурные скобки ({ }) вокруг имени переменной, чтобы экранировать ее от других символов:

Что дает нам желаемый результат:

Круг это 6-я фигура.

Изменение типа РНР переменной

PHP типы переменных: целое, вещественное, логическое, массив, объект и строка. Для начала рассмотрим изменение типа переменной после ее создания.

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

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

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

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

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

Например, $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.