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


Содержание

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

Автор: Артемьев Сергей Игоревич
ICQ: 438856621
email: _spin_@bk.ru

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

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

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

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

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

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

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

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

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

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

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

Передача переменных по ссылке

Стоит отметить, что по ссылке можно передавать только переменные, т.е. следующий код приведёт к ошибке:

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

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

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

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

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

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

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

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

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

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

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

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

Константы

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

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

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

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

Глава 2 Переменные и типы данных в PHP

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

  • целые числа;
  • вещественные числа;
  • строки;
  • массивы;
  • объекты;
  • логические величины.

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

Целые числа

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

Восьмеричная и шестнадцатеричная запись

В PHP поддерживается запись целых чисел в восьмеричной (по основанию 8) и шестнадцатеричной (по основанию 16) системах счисления. Восьмеричные числа начинаются с цифры 0, после которой следует серия цифр от 0 до 7. Примеры:

Шестнадцатеричные целые числа имеют префикс 0х или 0Х и могут состоять из цифр от 0 до 9 и букв от а (А) до f (F). Примеры:

Вещественные числа

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

Стандартная запись

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

Научная запись

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

Строковые значения

Строкой (string) называется последовательность символов, которая рассматривается как единое целое, но при этом обеспечивает доступ к отдельным символам. Примеры строк:

Обратите внимание: в PHP не поддерживается символьный тип данных. Строковый тип может рассматриваться как единое представление для последовательностей, состоящих из одного или нескольких символов.

Строковое присваивание

Строки делятся на две категории в зависимости от типа ограничителя — они могут ограничиваться парой кавычек (» «) или апострофов (‘ ‘). Между этими категориями существуют два принципиальных различия. Во-первых, имена переменных в строках, заключенных в кавычки, заменяются соответствующими значениями, а строки в апострофах интерпретируются буквально, даже если в них присутствуют имена переменных,

Два следующих объявления дают одинаковый результат:

Однако результаты следующих объявлений сильно различаются:

$sentence = «My favorite food is $food»;

$sentence2 = ‘My favorite food is $food’;

Переменной $sentence присваивается строка

My favorite food is meatloaf.

Обратите внимание: переменная $food автоматически интерпретируется. С другой стороны, переменной $sentence2 присваивается строка

My favorite food is $food.

В отличие от переменной $sentence, в $sentence2 осталась не интерпретированная переменная $food. Различия обусловлены использованием кавычек и апострофов при присваивании переменным $sentence и $sentence2.

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

Таблица 2.1. Служебные символы в строках

Последовательность
\n Новая строка
\r Возврат курсора
\t Горизонтальная табуляция
\\ Обратная косая черта
\$ Знак доллара
Кавычка
\[0-7] Восьмеричная запись числа (в виде регулярного выражения)
\x[0-9A-Fa-f] Шестнадцатиричная запись числа (в виде регулярного выражения)

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

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

Синтаксис встроенной документации

Второй вариант синтаксиса ограничения строк, представленный в HTML4, называется встроенной документацией (here doc). В этом варианте синтаксиса строка начинается с символов «Broiled Veal Chops»,

merlot => «Baked Ham»,

sauvignon => «Prime Rib»,

sauternes => «Roasted Salmon»);

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

Многомерные индексируемые массивы

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

Обобщенный синтаксис элементов многомерного массива:

Пример ссылки на элемент двухмерного индексируемого массива:

Многомерные ассоциативные массивы

Многомерные ассоциативные массивы также существуют в PHP (и приносят определенную пользу). Допустим, в массиве $раirings из предыдущего примера должна храниться информация не только о сорте, но и о производителе вина. Это можно сделать следующим образом:

$pairings[«Martinelli»][«zinfandel»] = «Broiled Veal Chops»;

$pairings[«Beringer»][«merlot»] = «Baked Ham»;

$pairings[«Jarvis»][«sauvignon»] = «Prime Rib»;

$pairings[«Climens»][«sauternes»] = «Roasted Salmon»;

Смешанное индексирование

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

$Buckeyes[«quarterback»] [1] = «Bellisari»;

$Buckeyes[«quarterback»] [2] = «Moherman»:

$Buckeyes[«quarterback»] [3] = «Wiley»;

В PHP существует множество функций для создания массивов и операций с ними — эта тема настолько обширна, что заслуживает отдельной главы. Работа с массивами в PHP подробно описана в главе 13.

Объекты

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

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

$blender = new appliance;

Определение класса задает атрибуты и функции, связанные с некоторой структурой данных — в данном примере это структура с именем appliance (устройство). У этой структуры имеется всего один атрибут power (мощность). Для изменения этого атрибута создается метод set_power.

Помните: определение класса — всего лишь шаблон, и выполнять операции с ним в программе невозможно; сначала нужно создать объекты на основе этого шаблона. Объекты создаются при помощи ключевого слова new. Например, в приведенном выше фрагменте создается объект $blender класса appliance.

После создания объекта $blender можно задать его мощность при помощи метода

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

Логические величины (истина/ложь)

Логический тип данных принимает всего два значения: истинное (true) и ложное (false). Логические величины создаются двумя способами: при проверке условий и в виде значений переменных. Обе ситуации достаточно просты.

Сравнения существуют в нескольких формах. Чаще всего они встречаются при использовании оператора = в условной команде if. Пример:

Результатом проверки является либо истина, либо ложь: переменная $sum либо равна 40, либо не равна. Если переменная $sum равна 40, проверка дает истинный результат. В противном случае результат равен false.

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

print «The flag is true!»;

print «The flag is false!»;

Если переменная $flag истинна, выводится первое сообщение, а если ложна — второе сообщение.

Возможен и другой вариант — представление истинных и ложных логических величин в виде значений 1 и 0 соответственно. В этом случае предыдущий пример выглядит так:

print «The flag is true!»;

print «The flag is false!»;

Наконец, существует еще один способ:

// При выполнении этой команды косвенно

// проверяется условие «if ($flag == TRUE)»

print «The flag is true!»;

print «The flag is false!»;

Идентификаторы

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

Идентификатор состоит из одного или нескольких символов и начинается с буквы или символа подчеркивания. Идентификатор может содержать только буквы, цифры, символы подчеркивания и другие ASCII-символы с кодами от 127 до 255. Примеры:

Недопустимые идентификаторы

This&that

Допустимые идентификаторы
Size !counter
_someword 4ward

В идентификаторах учитывается регистр символов. Следовательно, переменная с именем $recipe отличается от переменных с именами $Recipe, $rEciPe и $recipE.

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

Идентификатор не может совпадать с каким-либо из стандартных ключевых слов PHP.

Переменные

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

Объявление переменных

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

Имена переменных всегда начинаются со знака доллара, $. Ниже приведены примеры допустимых имен переменных:

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

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

$sentence = «This is a sentence.»; // $sentence интерпретируется как строка

$price = 42.99: // $price интерпретируется как вещественное число

$weight = 185; // $weight интерпретируется как целое число

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

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

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

  • локальные переменные;
  • параметры функций;
  • глобальные переменные;
  • статические переменные

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

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

print «\$x inside function is $x.
«;

print «\$x outside of function is $x.
«;

При выполнении этого фрагмента выводится следующий результат:

$х inside function is 0.

$х outside of function is 4.

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

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

Параметры объявляются в круглых скобках после имени функции. Объявление параметров практически не отличается от объявления типичной переменной:

// Функция умножает переданное значение на 10 и возвращает результат

function x10 ($value) <

$value = $value * 10;

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

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

print «Somevar is $somevar»;

Будет выведено значение $somevar, равное 16. Допустим, вы забыли включить следующую строку:

В этом случае $somevar будет присвоено значение 1, поскольку эта переменная будет считаться локальной по отношению к функции addit( ). Локальная переменная по умолчанию инициализируется 0, а затем к ней прибавляется 1; таким образом, будет выведено значение 1.

Альтернативный способ объявления глобальных переменных связан с использованием массива PHP $GLOBALS( ). Давайте вернемся к предыдущему примеру и воспользуемся этим массивом для объявления глобальной переменной $somevar: $somevar = 15;

print «Somevar is $somevar»;

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

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

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

STATIC $count = 0;

Как будут выглядеть результаты работы этого сценария? Если бы переменная $count не была объявлена статической (то есть являлась локальной), результат выглядел бы так:

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

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

Переключение типов

Иногда бывает удобно использовать переменные способами, не предусмотренными при их создании. Допустим, вам захочется прибавить строковое значение «15» к целому числу 12. К счастью, тип переменных PHP может изменяться и без использования механизма явного преобразования. Этот процесс, независимо от того, выполняется ли он прямо или косвенно, называется переключением (juggling) типов. Лучше всего продемонстрировать сказанное на конкретных примерах.

Предположим, вы суммируете две величины — строку и целое число. Как вы думаете, что при этом произойдет? Результат зависит от содержимого строки. Например, при суммировании целого числа со строковым представлением числа будет получено целое число:

$variable3 = $variablel + $variable2;

// $variable3 присваивается 4.

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

$variable3 = $variablel + $variable2;

// $v ariablel интерпретируется как вещественное число.

// и $variable3 присваивается 8.4.

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

$variable2 = «100 bottles of beer on the wall»;

$variable3 = ;variable1 + $variable2;

// $variable3 присваивается 105

В результате переменной ;variable3 присваивается значение 105. Это происходит из-за того, что лексический анализатор PHP определяет тип по началу строки. Допустим, мы привели переменную $variable2 к виду «There are 100 bottles of beer on the wall». Поскольку алфавитные символы трудно интерпретировать как целое число, строка интерпретируется как 0, и переменной $variable3 присваивается 5.

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

Преобразование типов

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

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

Таблица 2.2. Операторы преобразования типа переменных

Оператор преобразования типа Новый тип
(int) или (integer) Целое число
(real), (double) или (float) Вещественное число
(string) Строка
(array) Массив
(object) Объект

Простой пример преобразования типов:

$variable1= 13; // $variable1 присваивается целое число 13


$variable2 = (double) $variable1; // $variable2 присваивается 13.0

Хотя переменная $variable1 первоначально содержала целое число 13, преобразование (double) преобразует ее к вещественному типу (поэтому число 13 превращается в 13.0). Полученное значение присваивается переменной $variable2.

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

$variable3 = (int) $variable1 + $variable2; // $variable3 = 9

Следует заметить, что преобразование вещественного типа к целому всегда сопровождается округлением:

$variable2 = (int) $varlable1; // $variable2 = 14:

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

$array1 = (array) $varable1;

print $array1[0]; // Выводится значение 1114

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

$new_obj = (object) $model;

Ссылка на исходное строковое значение выглядит так:

Присваивание

Вы уже знаете, как присвоить значение переменной в сценарии PHP. Тем не менее, некоторые тонкости, связанные с присваиванием, стоит выделить особо. Вероятно, вам хорошо знаком механизм присваивания по значению, при котором именованной переменной присваивается конкретное значение — например, целое число 1 или строка «ciao». Однако существует и второй механизм — присваивание по ссылке, также открывающее перед программистами немало полезных возможностей. В следующих разделах оба механизма рассматриваются более подробно.

Присваивание по значению

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

В результате выполнения этих двух команд по адресу памяти, представленному именем $vehicle, сохраняется строка «car», а по адресу, представленному именем $amount, — значение 10.23.

Присваивание по значению также может выполняться в результате выполнения команды return в функциях:

Функция simple( ) всего лишь возвращает значение 5, которое присваивается некоторой переменной. В данном примере значение 5 будет присвоен о переменной $return_value.

Присваивание по ссылке

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

Чтобы присвоить значение по ссылке, укажите перед именем переменной-источника символ & (амперсанд):

print «$dessert2
«; // Выводится строка cookies

print Sdessert; // Снова выводится строка cookies

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

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

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

Оказывается, строку «spaghetti» можно интерпретировать как имя переменной — для этого в команде присваивания перед именем исходной переменной ставится второй знак $:

Эта команда присваивает строку «& meatballs» переменной с именем «spaghetti». Следовательно, следующие две команды выводят одинаковые результаты:

print $recipe $spaghetti;

print $recipe $($recipe);

В обоих случаях будет выведена строка «spaghetti & meatballs».

Стандартные переменные

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

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

Чтобы получить полный список переменных web-сервера, окружения и PHP, определенных для вашей конфигурации системы, достаточно выполнить следующий фрагмент:

while (list($var,$value) = each($GLOBALS)) :

echo «
$var => $ value»;

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

Переменные

Тип void

К основным типам также относится тип void Множество значений этого типа – пусто.

Переменная в СИ++ — именованная область памяти, в которой хранятся данные определенного типа. У переменной есть имя и значение. Имя служит для обращения к области памяти, в которой хранится значение. Перед использованием любая переменная должна быть описана. Примеры:

Общий вид оператора описания:

[класс памяти][const]тип имя [инициализатор];

Класс памяти может принимать значения: auto, extern, static, register. Класс памяти определяет время жизни и область видимости переменной. Если класс памяти не указан явно, то компилятор определяет его исходя из контекста объявления. Время жизни может быть постоянным – в течение выполнения программы или временным – в течение блока. Область видимости – часть текста программы, из которой допустим обычный доступ к переменной. Обычно область видимости совпадает с областью действия. Кроме того случая, когда во внутреннем блоке существует переменная с таким же именем.

Const – показывает, что эту переменную нельзя изменять (именованная константа).

При описании можно присвоить переменной начальное значение (инициализация).

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

extern – глобальная переменная, она находится в другом месте программы (в другом файле или долее по тексту). Используется для создания переменных, которые доступны во всех файлах программы.

static – статическая переменная, она существует только в пределах того файла, где определена переменная.

register — аналогичны auto, но память под них выделяется в регистрах процессора. Если такой возможности нет, то переменные обрабатываются как auto.

int a; //глобальная переменная

int b;//локальная переменная

extern int x;//переменная х определена в другом месте

static int c;//локальная статическая переменная

a=1;//присваивание глобальной переменной

int a;//локальная переменная а

a=2;//присваивание локальной переменной

::a=3;//присваивание глобальной переменной

int x=4;//определение и инициализация х

В примере переменная а определена вне всех блоков. Областью действия переменной а является вся программа, кроме тех строк, где используется локальная переменная а. Переменные b и с – локальные, область их видимости – блок. Время жизни различно: память под b выделяется при входе в блок (т. к. по умолчанию класс памяти auto), освобождается при выходе из него. Переменная с (static) существует, пока работает программа.

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

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

Описание переменной может быть выполнено или как объявление, или как определение. Объявление содержит информацию о классе памяти и типе переменной, определение вместе с этой информацией дает указание выделить память. В примере extern int x; — объявление, а остальные – определения.

2.4.Знаки операций в Си++

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

& получение адреса операнда
* Обращение по адресу (разыменование)
унарный минус, меняет знак арифметического операнда
поразрядное инвертирование внутреннего двоичного кода целочисленного операнда (побитовое отрицание)
! логическое отрицание (НЕ). В качестве логических значений используется 0 — ложь и не 0 — истина, отрицанием 0 будет 1, отрицанием любого ненулевого числа будет 0.
++ Увеличение на единицу: префиксная операция — увеличивает операнд до его использования, постфиксная операция увеличивает операнд после его использования. int m=1,n=2; int a=(m++)+n; // a=4,m=2,n=2 int b=m+(++n);//a=3,m=1,n=3
— — уменьшение на единицу: префиксная операция — уменьшает операнд до его использования, постфиксная операция уменьшает операнд после его использования.
sizeof вычисление размера (в байтах) для объекта того типа, который имеет операнд имеет две формы sizeof выражение sizeof (тип) Примеры: sizeof(float)//4 sizeof(1.0)//8, т. к. вещественные константы по умолчанию имеют тип double
+ бинарный плюс (сложение арифметических операндов)
бинарный минус (вычитание арифметических операндов)
* умножение операндов арифметического типа
/ деление операндов арифметического типа (если операнды целочисленные, то выполняется целочисленное деление)
% получение остатка от деления целочисленных операндов

Операции сдвига (определены только для целочисленных операндов).

Формат выражения с операцией сдвига:

операнд_левый операция_сдвига операнд_правый

> сдвиг вправо битового представления значения правого целочисленного операнда на количество разрядов, равное значению правого операнда, освободившиеся разряды обнуляются, если операнд беззнакового типа и заполняются знаковым разрядом, если – знакового
& поразрядная конъюнкция (И) битовых представлений значений целочисленных операндов (бит =1, если соответствующие биты обоих операндов=1)
| поразрядная дизъюнкция (ИЛИ) битовых представлений значений целочисленных операндов (бит =1, если соответствующий бит одного из операндов=1)
^ поразрядное исключающее ИЛИ битовых представлений значений целочисленных операндов(бит =1, если соответствующий бит только одного из операндов=1)

Операции сравнения: результатом являются true( не 0) или false(0)

больше, чем
= больше или равно
== Равно
!= не равно

Логические бинарные операции:

&& конъюнкция (И) целочисленных операндов или отношений, целочисленный результат ложь(0) или истина(не 0)
|| дизъюнкция (ИЛИ) целочисленных операндов или отношений, целочисленный результат ложь(0) или истина(не 0)

Формат операции простого присваивания:

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

В отличие от унарных и бинарных операций в ней используется три операнда.

Выражение1 ? Выражение2 : Выражение3;

Первым вычисляется значение выражения1. Если оно истинно, то вычисляется значение выражения2, которое становится результатом. Если при вычислении выражения1 получится 0, то в качестве результата берется значение выражения3.

Не нашли то, что искали? Воспользуйтесь поиском:

Лучшие изречения: На стипендию можно купить что-нибудь, но не больше. 8989 — | 7235 — или читать все.

188.64.174.135 © studopedia.ru Не является автором материалов, которые размещены. Но предоставляет возможность бесплатного использования. Есть нарушение авторского права? Напишите нам | Обратная связь.

Отключите adBlock!
и обновите страницу (F5)

очень нужно

PHP: Переменные

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

AVR GCC :: ПЕРЕМЕННЫЕ И КОНСТАНТЫ

Переменные

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

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

Хорошим стилем является осмысленное именование переменных. Разрешается использовать строчные и прописные буквы, цифры и символ подчёркивания, который в Си считается буквой. Первым символом обязательно должна быть буква, в имени переменной не должно быть пробелов. В современных версиях компиляторов длина имени практически не ограничена. Имя переменной не может совпадать с зарезервированными ключевыми словами. Заглавные и строчные буквы в именах переменных различаются, переменные a и A — разные переменные.

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

При объявлении переменной компилятор отводит ей место в памяти в зависимости от её типа. Стандартными средствами AVR GCC работает с типами данных char (символьный тип) и int (целочисленный тип).

Типы переменных

char — является самым экономным типом. Тип char может быть знаковым и беззнаковым. Обозначается, соответственно, как » signed char » (знаковый тип) и » unsigned char » (беззнаковый тип). Знаковый тип может хранить значения в диапазоне от -128 до +127. Беззнаковый — от 0 до 255. Под переменную типа char отводится 1 байт памяти (8 бит).

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

Целочисленная величина int может быть short (короткой) или long (длинной).

Ключевое слово (модификатор) short ставится после ключевых слов signed или unsigned . Таким образом, различают следующие типы: signed short int, unsigned short int, signed long int, unsigned long int .

Переменная типа signed short int (знаковая короткая целая) может принимать значения от -32768 до +32767, unsigned short int (беззнаковая короткая целая) — от 0 до 65535. Под каждую из них отводится ровно по два байта памяти (16 бит).

При объявлении переменной типа signed short int ключевые слова signed и short могут быть пропущены, и такой тип переменной может быть объявлен просто int . Допускается и объявление этого типа одним ключевым словом short .

Переменная unsigned short int может быть объявлена как unsigned int или unsigned short .

Под каждую величину signed long int или unsigned long int отводится 4 байта памяти (32 бита). Значения переменных этого типа могут находиться в интервалах от -2147483648 до 2147483647 и от 0 до 4294967295 соответственно.

Существуют также переменные типа long long int , для которых отводится 8 байт памяти (64 бита). Они также могут быть знаковыми и беззнаковыми. Для знакового типа диапазон значений лежит в пределах от -9223372036854775808 до 9223372036854775807, для беззнакового — от 0 до 18446744073709551615. Знаковый тип может быть объявлен и просто двумя ключевыми словами long long .

Тип Диапазон Шестнадцатиричный диапазон Размер
unsigned char 0 . 255 0x00 . 0xFF 8 bit
signed char
или просто
char
-128 . 127 -0x80 . 0x7F 8 bit
unsigned short int
или просто
unsigned int или unsigned short
0 . 65535 0x0000 . 0xFFFF 16 bit
signed short int или signed int
или просто
short или int
-32768 . 32767 0x8000 . 0x7FFF 16 bit
unsigned long int
или просто
unsigned long
0 . 4294967295 0x00000000 . 0xFFFFFFFF 32 bit
signed long
или просто
long
-2147483648 . 2147483647 0x80000000 . 0x7FFFFFFF 32 bit
unsigned long long 0 . 18446744073709551615 0x0000000000000000 . 0xFFFFFFFFFFFFFFFF 64 bit
signed long long
или просто
long long
-9223372036854775808 . 9223372036854775807 0x8000000000000000 . 0x7FFFFFFFFFFFFFFF 64 bit

Объявление переменных

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

Объявление переменной имеет следующий формат:

[модификаторы] спецификатор_типа идентификатор [, идентификатор] .

Модификаторы — ключевые слова signed , unsigned , short , long .
Спецификатор типа — ключевое слово char или int , определяющее тип объявляемой переменной.
Идентификатор — имя переменной.

Пример:
Таким образом, будут объявлены переменные x , a , b , c , y . В переменную x можно будет записывать значения от -128 до 127. В переменные a , b , c — от -32768 до +32767. В переменную y — от 0 до 18446744073709551615.

Инициализация значения переменной при объявлении

При объявлении переменную можно проинициализировать, то есть присвоить ей начальное значение. Сделать это можно следующим образом. Таким образом, в переменную x при объявлении сразу же будет записано число 100.

Лучше избегать смешивания инициализируемых переменных в одном операторе описания, то есть инициализируемые переменные лучше объявлять в отдельных строках.

Константы

Переменная любого типа может быть объявлена как немодифицируемая. Это достигается добавлением ключевого слова const к спецификатору типа. Переменные с типом const представляют собой данные, используемые только для чтения, то есть этой переменной не может быть присвоено новое значение. Если после слова const отсутствует спецификатор типа, то константы рассматриваются как величины со знаком, и им присваивается тип int или long int в соответствии со значением константы: если константа меньше 32768, то ей присваивается тип int , в противном случае long int .

Присваивание

Для присваивания в Си служит знак «=». Выражение, стоящее справа от знака присваивания, вычисляется, и полученное значение присваивается переменной, стоящей слева от знака присваивания. При этом предыдущее значение, хранящееся в переменной, стирается и заменяется на новое.

Оператор «=» не следует понимать как равенство.
Например, выражение a = 5; следует читать как «присвоить переменной a значение 5».

Примеры:
В правой части значение переменной может использоваться несколько раз:

Арифметические операции

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

+ плюс
минус
* умножить
/ разделить

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

Дополнительные способы присваивания

Кроме простого оператора присваивания «=», в Си существует еще несколько комбинированных операторов присваивания: «+=», «-=», «*= Инкремент и декремент

Если необходимо изменить значение переменной на 1, то используют инкремент или декремент .

Инкремент — операция увеличения значения, хранящегося в переменной, на 1.

Пример:
Декремент — операция уменьшения значения, хранящегося в переменной, на 1.

Пример:
Инкремент и декремент относятся к операциям присваивания. При использовании декремента и инкремента совместно с оператором присваивания «=» применяют постфиксную (x++) или префиксную (++x) запись. Первой выполняется префиксная запись.

Примеры:
Предположим, что в переменной x хранилось значение 5. Тогда в y будет записано значение 5, после чего значение переменной x будет увеличено на 1. Таким образом, в y будет 5, а в x — 6.
Если в x хранилось значение 5, то сначала будет выполнено уменьшение x до 4, а затем это значение будет присвоено переменной y . Таким образом, x и y будет присвоено значение 4.

Переменные

Переменные

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

auto double int struct
break else long switch
register typedef char extern
return void case float
unsigned default for signed
union do if sizeof
volatile continue enum short
while inline

А также ряд других слов, специфичных для данной версии компилятора, например far, near, tiny, huge, asm, asm_ и пр.

Например, правильные идентификаторы
a, _, _1_, Sarkasm, a_long_variable, aLongVariable, var19, defaultX, char_type
неверные
1a, $value, a-long-value, short

Си — регистрозависимый язык. Переменные с именами a и A, или end и END, или perfectDark и PerfectDarK – это различные переменные.

Типы переменных

Т ип переменной определяет

  • 1) Размер переменной в байтах (сколько байт памяти выделит компьютер для хранения значения)
  • 2) Представление переменной в памяти (как в двоичном виде будут расположены биты в выделенной области памяти).

В си несколько основных типов. Разделим их на две группы — целые и числа с плавающей точкой.

Целые

  • char — размер 1 байт. Всегда! Это нужно запомнить.
  • short — размер 2 байта
  • int — размер 4 байта
  • long — размер 4 байта
  • long long — размер 8 байт.

Здесь следует сделать замечание. Размер переменных в си не определён явно, как размер в байтах. В стандарте только указано, что

Указанные выше значения характерны для компилятора VC2012 на 32-разрядной машине. Так что, если ваша программа зависит от размера переменной, не поленитесь узнать её размер.

Теперь давайте определим максимальное и минимальное число, которое может хранить переменная каждого из типов. Числа могут быть как положительными, так и отрицательными. Отрицательные числа используют один бит для хранения знака. Иногда знак необходим (например, храним счёт в банке, температуру, координату и т.д.), а иногда в нём нет необходимости (вес, размер массива, возраст человека и т.д.). Для этого в си используется модификатор типа signed и unsigned. unsigned char — все 8 бит под число, итого имеем набор чисел от 00000000 до 11111111 в двоичном виде, то есть от 0 до 255 signed char от -128 до 128. В си переменные по умолчанию со знаком. Поэтому запись char и signed char эквивалентны.

Таб. 1 Размер целых типов в си.

Тип Размер, байт Минимальное значение Максимальное значение
unsigned char 1 255
signed char
( char )
1 -128 127
unsigned short 2 65535
signed short
( short )
2 -32768 32767
unsigned int
( unsigned )
4 4294967296
signed int
( int )
4 -2147483648 2147483647
unsigned long 4 4294967296
signed long
( long )
4 -2147483648 2147483647
unsigned long long 8 18446744073709551615
signed long long
( long long )
8 -9223372036854775808 9223372036854775807

sizeof

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

(Я думаю ясно, что переменные могут иметь любое валидное имя). Эту программу можно было написать и проще

В си один и тот же тип может иметь несколько названий
short === short int
long === long int
long long === long long int
unsigned int === unsigned

Типы с плавающей точкой

  • float — 4 байта,
  • long float — 8 байт
  • double — 8 байт
  • long double — 8 байт.

Здесь также приведены значения для VC2012, по стандарту размер типов float Таб. 2 Размер типов с плавающей точкой в си.

Тип Размер, байт Количество значащих знаков мантиссы Минимальное значение Максимальное значение float 4 6-7 1.175494351 E – 38 3.402823466 E + 38 double 8 15-16 2.2250738585072014 E – 308 1.7976931348623158 E + 308

Переполнение переменных

Си не следит за переполнением переменных. Это значит, что постоянно увеличивая значение, скажем, переменной типа int в конце концов мы «сбросим значение»

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

Постфиксное обозначение типа

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

  • 11 — число типа int
  • 10u — unsigned
  • 22l или 22L — long
  • 3890ll или 3890LL — long long (а также lL или Ll)
  • 80.0f или 80.f или 80.0F — float (обязательно наличие десятичной точки в записи)
  • 3.0 — число типа double

Экспоненциальная форма записи также по умолчанию обозначает число типа double.

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

Шестнадцатеричный и восьмеричный формат


В о время работы с числами можно использовать шестнадцатеричный и восьмеричный формат представления. Числа в шестнадцатиричной системе счисления начинаются с 0x, в восьмеричной системе с нуля. Соответственно, если число начинается с нуля, то в нём не должно быть цифр выше 7:

Экспоненциальная форма представления чисел

Э кспоненциальной формой представления числа называют представление числа в виде M e ± p , где M — мантиса числа, p — степень десяти. При этом у мантисы должен быть один ненулевой знак перед десятичной запятой.
Например 1.25 === 1.25e0, 123.5 === 1.235e2, 0.0002341 === 2.341e-4 и т.д.
Представления 3.2435e7 эквивалентно 3.2435e+7
Существеут и другое представление («инженерное»), в котором степень должна быть кратной тройке. Например 1.25 === 1.25e0, 123.5 === 123.5e0, 0.0002341 === 234.1e-6, 0.25873256 === 258.73256e-3 и т.д.

Объявление переменных

В си переменные объявляются всегда в начале блока (блок — участок кода ,ограниченный фигурными скобками)

При объявлении переменной пишется её тип и имя.

Можно объявить несколько переменных одного типа, разделив имена запятой

Здесь объявлены переменные a и b внутри функции main, и переменная z внутри тела цикла. Следующий код вызовет ошибку компиляции

Это связано с тем, что объявление переменной стоит после оператора присваивания. При объявлении переменных можно их сразу инициализировать.
int i = 0;
При этом инициализация при объявлении переменной не считается за отдельный оператор, поэтому следующий код будет работать

Начальное значение переменной

О чень важно запомнить, что переменные в си не инициализируются по умолчанию нулями, как во многих других языках программирования. После объявления переменной в ней хранится «мусор» — случайное значение, которое осталось в той области памяти, которая была выделена под переменную. Это связано, в первую очередь, с оптимизацией работы программы: если нет необходимости в инициализации, то незачем тратить ресурсы для записи нулей (замечание: глобальные переменные инициализируются нулями, почему так, читайте в этой статье).

Если выполнять эту программу на VC, то во время выполнения вылетит предупреждение
Run-Time Check Failure #3 — The variable ‘i’ is being used without being initialized.
Если нажать «Продолжить», то программа выведет «мусор». В многих других компиляторах при выполнении программы не будет предупреждения.

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

П еременные бывают локальными (объявленными внутри какой-нибудь функции) и глобальными. Глобальная переменная видна всем функциям, объявленным в данном файле. Локальная переменная ограничена своей областью видимости. Когда я говорю, что переменная «видна в каком-то месте», это означает, что в этом месте она определена и её можно использовать. Например, рассмотрим программу, в которой есть глобальная переменная

Будет выведено
foo: 100
bar: 333
Здесь глобальная переменная global видна всем функциям. Но аргумент функции затирает глобальную переменную, поэтому при передаче аргумента 333 выводится локальное значение 333.
Вот другой пример

Программа выведет 555. Также, как и в прошлом случае, локальная переменная «важнее». Переменная, объявленная в некоторой области видимости не видна вне её, например

Этот пример не скомпилируется, потому что переменная y существует только внутри своего блока.
Вот ещё пример, когда переменные, объявленные внутри блока перекрывают друг друга

Программа выведет
30
20
10
Глобальных переменных необходимо избегать. Очень часто можно услышать такое. Давайте попытаемся разобраться, почему. В ваших простых проектах глобальные переменные выглядят вполне нормально. Но представьте, что у вас приложение, которое

  • 1) Разрабатывается несколькими людьми и состоит из сотен тысяч строк кода
  • 2) Работает в несколько потоков

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

Безусловно, есть ситуации, когда глобальные переменные упрощают программу, но такие ситуации случаются не часто и не в ваших домашних заданиях, так что НЕ СОЗДАВАЙТЕ ГЛОБАЛЬНЫХ ПЕРЕМЕННЫХ!
Переменные могут быть не только целочисленными и с плавающей точкой. Существует множество других типов, которые мы будем изучать в дальнейшем.

Smalltalk в примерах/Переменные

В этой главе мы рассмотрим различные типы переменных которые есть в Смолтоке: Экзэмпляр, класс, экзепмляр класса, параметр, временная переменная. Глобальные переменные большая тема сама по себе поэтому мы рассмотрим её в Главе 7, Глобальные переменные. В Смолтоке также есть специальные переменные которые мы рассмотрим в Главе 6, Специальные переменные, буквы и символы.

Содержание

Имена переменных [ править ]

Код проше для понимания когда все методы и переменные имеют выразительные имена и просты для понимания. Давайте переменным ясные и очевидные имена чтобы читатель немедленно понимал назначение переменной. Не используйте аббревиатур; используйте их \potom. Ваша задача сделать код таким чтобы программист мог посмотреть на него и смог немедленно понять что происходит, даже без комментариев в коде. Часть этой задачи включает хорошее разделение ответственности в коде и часть включает нахождение хороших имён для методов и переменных.

Имена переменных состоят из одного или более слов соединённых вместе. Первая буква каждого слова должна быть большой, и последняя буква должна быть маленькой. Исключением из этого правила является первая буква имени следующих переменных: экземпляр, параметр, и временная переменная должна начинаться с маленькой буквы. Некоторые люди оставляют акронимы написанными большими буквами; я пытаюсь избегать использовать две большие буквы подряд \potom. Есть несколько примеров имён переменных.

Я всегда нахожу удобным использовать приставку в имени класса указывающую на имя программы или её компонента потому что мне нравится знать откуда класс когда я просматриваю код. Например, если у вас бухгалтерская программа с платёжными ведомостями, кредиторскими задолженностями и бухгалтерскими книгами, вы можете использовать такие приставки для компонентов: Pr, Ap, Gl, и что-нибудь подобное Aac для классов используемых для взаимодействия между компонентами (Accounting Appliction Communication). Классы общего назначения которые будут использоваться различными программами или компонентами имеют general company приставку, или приставку Sup.

Переменные экземпляра [ править ]

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

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

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

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

Переменные класса [ править ]

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

Есть два примера когда экземпляр Даты ссылаются на переменные стороны класса. Сообщения имяМесяца деньВМесяце используют массивы содержащиеся в переменных класса ИменаМесяцев и ДнейВМесяце.

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

Классы, ссылающиеся на свои экземпляры () [ править ]

Переменные — [ править ]

Параметры [ править ]

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

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

Параметры методов [ править ]

В коде показанном ниже, мы видим различные примеры сообщений и параметров. Ниже показано несколько примеров имён методов и параметров с различными описаниями.

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

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

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

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

Параметры блоков [ править ]

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

Возможно вы не будите часто используете блоки с более чем одним или двумя параметрами, но если вам это понадобится, вы можете послать блоку сообщение значение:значение:значение: с тремя параметрами, или значениеСАргументами: массив если вам надо более трёх параметров. Например, блок с пятью параметрами может быть похожим на следующий. Если количество элементов массива не совпадает с количеством параметров, вы получите сообщение об исключении.

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

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

Временные переменные [ править ]

Временные переменные — это переменные, которые существуют короткое время: пока выполняется метод или блок кода. Есть несколько причин для использования временных переменных. Наиболее важная причина сохранить значение, которое не может получено повторно. Например, если вы читаете объект из потока(stream) или разделяемой очереди (shared queue), и вы хотите использовать этот объект несколько раз, используйте временную переменную для сохранения объекта. Например:

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

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

Четвёртая причина использовать временные переменные — сделать код легче для понимания. Иногда трудно понять какой объект мы получим в результате сложной последовательности сообщений. Даже если мы не нуждаемся в использовали временной переменной при выполнении последовательность сообщений один раз, можно сделать код более читабельным поместив результат этой последовательности в хорошо названную переменную. (Альтернативный подход заключается в вычислении результата другим методом и замене сложных сообщений на одно сообщение) Например, следующий код позволяет проще понять что происходит без необходимости чтения кода блока сортировки.

Временные переменные в методе [ править ]

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

копироватьС: новыйЭлемент | новаяСовокуность | новаяСовокупность := я копировать. новаяСовокупность добавить: новыйЭлемент. \^<>новаяСовокупность

Вы можете написать имя временной переменной между вертикальными чертами, или можете позволить компилятору сгенерировать имя автоматически. Компилятор делает имя временной переменной если он не находит его в методе. Я обычно позволяю компилятору генерировать имена, но иногда из за этого могут возникнуть проблемы. Если вы дадите временной переменной такое жэ имя как у переменной экзэмпляра, компилятор будет предполагать что вы ссылаетесь на переменную экзэмпляра и не сгенерирует её как временную. (Если вы печатаете имя сами, вы будете предупреждены что переменная ужэ существует, возможно —). На стороне класса, если вашэ имя временной переменной имя и оно не помещено вами между вертикальными чертами, класс сам добавит новое имя когда код будет запущен!

Временные переменные в блоках [ править ]

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

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

мойМетод совокупность делать: [ :каждый | | результат |

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

Глобальные переменные [ править ]

Глава 7, Глобальные переменные, описывает глобальные переменные, поэтому мы не будем обсуждать их здесь.

Переменные как слот [ править ]

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

Из за того что объект существует отдельно и только помещается в переменную, нет причины по которой объект не можэт быть помещён в различные переменные одноременно. Мы можэм просто получить следующую ситуацыю. Когда вы просмотрите г, вы увидите что она содержыт три элемента, числа 1, 2 и 3. Множэственное присвоение, как показано в примере, легально но является прохим стилем.

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

С другой стороны, если мы сделаем следующее, мы увидим что б содержыт число 2, в то время как г содержыт числа 1 и 3.

В этом примере, мы присвоили различные значения б, и связали с ней объект 2 вместо экзэмпляра УпорядоеннойСовокупности.

Методы доступа [ править ]

Методы доступа это методы которые позволяют вам получать и присваивать значения переменным экземпляра и класса. Т.к. переменные экземпляра более сложно использовать чем переменные класса, вы можете более часто увидеть использование методов доступа для переменных экзэмплра. Из за того что они получают и присваивают переменные, методы доступа ещё известны как getters and setters, и когда вы пишите метод доступа, вы должны писать и getter and setter. По соглашэнию они именуются так жэ как и переменная экзэмпляра. Например,

Если вы используете позднюю инициализацию (инициализация переменной когда она нужна в первый раз) вместо инициализации переменных экземпляра методом инициализировать, метод доступа зарплат должен выглядеть примерно так:

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

Методы доступа для совокупностей [ править ]

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

Однако, вы —. После всего, мы можете решить изменить совокупность УпорядоченнаяСовокупность на Массив или Словарь и вы не должны концентрироваться на том как другие программы обращаются к совокупности. Предоставив несколько методов доступа таких как добавитьНавык: и удалитьНавык:, вы не должны открывать текущую совокупность для всех. (Друое применение —)

Пять применений методов доступа [ править ]

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

Метод доступа или прямая ссылка [ править ]

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

Прямая ссылка [ править ]

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

Переменные.

В php все имена переменных начинаются со знака $

Все переменные регистрозависимы, т.е.

$A и $a — это две абсолютно разные переменные!

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

Присвоение значения переменной и ее удаление.

Присвоение значения переменной происходит с помощью оператора присваивания «=». На следующем слайде подробно приведены примеры присвоения значений переменным.

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

С помощью этой функции можно удалить переменную из памяти, не дожидаясь конца кода.

На слайде выше мы удалили $foo поэтому echo $foo ничего не дало, т.к. $foo стала пустая после unset($foo)

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

Попробуйте сначала самостоятельно сделать это задание, потом посмотрите слайд с ответом ниже задания

Откройте Ваш index.php и напишите код исходя из условия:

Создайте переменную $name и присвойте ей значение «Tom» (обязательно в кавычках)
Создайте переменную $age и присвойте ей значение 25 Выведите на экран браузера Фразу: «Меня зовут Tom, мне 25 лет.»

Типы переменных.

Типы object и resourse сейчас мы разбирать не будем, а про остальные поговорим :-)

boolean

Самый простой тип. Выражает истинность значения — это может быть либо TRUE, либо FALSE.

$foo = True; // присвоить $foo значение TRUE

TRUE и FALSE – регистро-независимы.

При преобразовании в логический тип, следующие значения рассматриваются как FALSE:
v целое 0 (ноль) число с плавающей точкой 0.0 (ноль) пустая строка и строка «0» пустой массив специальный тип NULL (включая неустановленные переменные)

Все остальные значения рассматриваются как TRUE

integer и float

Грубо говоря integer — это целые числа
float — числа с плавающей запятой

string

Тип — строка. Например:

Стороковые значения переменных мы можем заключать в одинарные кавычки (апосторфы) и так же в двойные.

И разница между этим есть!

Первое отличие — это то, что в «» можно подставлять значения переменных.

Соответственно браузер выведет: Привет Tom

Второе отличие «» от » — можно подставлять спец символы, которые экранируются (непосредственно выводятся в браузер) обратной косой чертой (бэк слеш) например:

НО. И это важно! В самом браузере мы не увидим перевода на новую строку или табуляцию. Запишите код выше в свой index.php который Вы создавали в папке C:\WebServers\home\test_sait\www Сохраните. Перейдите в браузере по адресу http://test_sait/ и Вы увидете ровно следующее:

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

и выбрать «Исходный код», то мы увидим ту самую табуляцию и переводы строк

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

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

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

Есть более простой метод вывода спец символов, называемый heredoc

например мы эхом выводим ту же строку, что разбирали выше, тогда:

Что мы здесь видим?

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

Потом Вашу метку закрываете и все! Все отобразится как есть.

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

Первый: в конце открывающей метки не должно быть НИЧЕГО! Даже случайного пробела. Т.е. написали label и тут же жмем enter.

Второй: в начале и в конце Закрывающей метки тоже не должно быть НИЧЕГО! Даже случайного пробела. Т.е. писать label нужно с САМОГО НАЧАЛА СТРОКИ. потом ставим ; И ВСЕ. Enter и уже пишем код дальше.

Тип NULL

Примеры переменных, которым присвоен тип NULL

Переменной не было присвоено ни какое значение, значит echo $a даст NULL

Переменную $a удалили спомощью функции unset() значит echo $a даст NULL

Экранирование переменных.

Посмотрев на слайд ниже мы увидим как экранируются переменные (мы явно указываем php где начало и конец переменной)
Когда пхп видит символ $ Он понимает, что это начало переменной и начинает считывать ее имя (см.слайд)
Он видит — ага, символ b — все ок, допустимый символ для переменной
Дальше символ e — все ок, допустимый символ для переменной
Дальше символ e — все ок, допустимый символ для переменной
Дальше символ r — все ок, допустимый символ для переменной
Дальше символ ‘ — тут php видит, что апостроф — это недопустимый сивол и понимает, что имя переменной закончилось и надо искать переменную с именем $beer

А в след примере пхп будет считывать все до конца в имени перем. т.к. символ s на конце тоже допустимый и, конечно же, не найдя $beers, ничего не выдаст, эхом напрмер. (кстати тип переменной $beers будет определен как NULL)

Точно указывать где конец и начало переменных можно фигурными скобками <>

Доступ к символу в строке.

Начнем с функции strlen() — она считает колличество символов в переменной.

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

Константы.

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

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

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

Все переменные в PHP начинаются со знака доллар «$». Далее после этого знака может находиться любая последовательность состоящая из буквенно-цифровых символов (включая знак подчеркивания), но первый символ не может быть цифрой.

Примеры корректных переменных в PHP: $per, $p1e2r3e, $user_10, $_user_10, $prosto_dlinnaya_peremennaya и т.д.

Стоит отметить, что PHP чувствителен к регистру, а значит переменные $pEr, $per, $PER — будут разные. Например:

На экране будет выведено: 1, 2, 3.

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

Чтобы вывести текст $text (название самой переменной) нужно поставить перед ней обратный слэш «\»:

Существует специальная функция unset(имя_переменной) , которая позволяет уничтожать объявленные переменные. В основном это делается для освобождения памяти. Например:

С помощью функции isset(имя_переменной) можно проверять существование переменных. Функция возвращает true (истина) в случае существования и false (ложь) в противном случае. Очень похожей функцией является empty(имя_переменной) , которая возвращает true в случае если переменная не существует, равна нулю или пустой строке и false в противном случае.

Константы в PHP

Константы в PHP в отличии от переменных очень похожи на константы в других языках, поскольку они не могут менять своё значение. Для объявление константы в PHP есть специальная функция define(«ИМЯ_КОНСТАНТЫ», значение_константы) . Приведем пример:

Требования к именованию констант аналогичны требованиям именованию переменных. По этой причине в рассмотренном примере выше, последнее объявление константы «1CON» является некорректным.

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

Для проверки существования константы существует специальная функция defined(ИМЯ_КОНСТАНТЫ) , которая выдает true (истина) в случае существования константы и false (ложь) в другом случае. Приведем пример использования функции defined:

В PHP есть так же предопределенные константы, которые Вы можете видеть в таблице:

Константа Описание
__LINE__ Текущая строка в файле
__FILE__ Полный путь и имя текущего файла
__FUNCTION__ Имя функции
__CLASS__ Имя класса
__METHOD__ Имя метода класса
NULL Пустая константа (не путайте с нулем)

Пример применения выше описанных предопределенных констант приведен ниже:

Внешние переменные в PHP

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

Протокол HTTP позволяет передавать и считывать данные с помощью методов GET и POST . Выбор метода можно задать в html-формах (см. тег form).

Эти методы (GET и POST) являются очень важными, поэтому для описание этих методов был посвящен целый урок 3: использование методов GET и POST.

Уроки PHP – Переменные

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

Есть несколько правил, которые вам нужно знать при создании переменных.

Во-первых, имя переменной должно начинаться с буквы или нижнего подчеркивания. Во-вторых, имя не может начинаться с цифры. В-третьих, оно может содержать только буквенно-цифровые символы и символы подчеркивания (A-z, 0-9 и _). В-четвертых, имена переменных чувствительны к регистру. Значение $somevar и $SOMEVAR – это две разные переменные. Поэтому обращайте внимание на правильность регистра, когда ссылаетесь на существующую переменную.

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

Переменные могут быть объявлены в любом месте вашего PHP скрипта. И вы можете определять переменные в двух областях видимости: локально или глобально. Когда вы определяете переменную вне функции, она имеет глобальную область видимости. С другой стороны, переменная, которую вы объявляете внутри функции, имеет локальную область видимости. Такая переменная может быть доступна только внутри этой функции.

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

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

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

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

Переменная переменной берет значение переменной и рассматривает его как имя переменной. $$a – это переменная переменной, использующая в качестве имени значение переменной $a . Оно равно «hello». В результате создается переменная $hello , в которой хранится значение «world».

Предопределенные переменные

Помимо «обычных» переменных, PHP также предлагает большое количество предопределенных переменных, которые также называются «суперглобальными» переменными. Это $_SERVER , $GLOBALS , $_REQUEST , $_POST , $_GET , $_FILES , $_ENV , $_COOKIE , $_SESSION и другие. «Суперглобальные» переменные доступны всегда, и область видимости в этом случае не имеет значения.

Вы можете обращаться к любой из этих «суперглобальных» переменных, например, в любой функции, классе или файле. Возможно, вы найдете некоторые из этих «суперглобальных» переменных более полезными, а некоторые – менее полезными. Например, $_POST и $_GET будут очень полезны, если ваш текущий проект требует работы с формами, при отправке или получении некоторых данных.

Константы

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

Эта функция принимает три параметра. Этими параметрами являются имя, значение и является ли константа нечувствительной к регистру. Другими словами, define(имя, значение, регистр) . имя – это имя константы, значение – это значение константы, регистр указывает, должно ли имя константы не учитывать регистр (здесь значением по умолчанию является false , т.е., учитывать регистр).

Типы данных

В настоящее время в PHP существует семь типов данных. Это строки, целые числа, числа с плавающей точкой (также называемые double), логические значения (boolean), массивы, объекты и NULL. Вы уже видели пример строки в самом начале урока ( $first_var ). Проще говоря, строка – это любая последовательность символов, заключенная в одинарные или двойные кавычки.

Целые числа, числа с плавающей точкой и логические значения

Целое число – это целое число. И оно должно соответствовать некоторым критериям. Во-первых, оно должно быть без десятичных знаков (без точки, или запятой). Во-вторых, оно не может содержать пробелы. В-третьих, оно может быть как положительным, так и отрицательным. В-четвертых, оно должно содержать как минимум одну цифру. Наконец, допустимое целое число может быть указано в трех форматах: десятичный, шестнадцатеричный или восьмеричный.

Число с плавающей запятой – любое число с десятичной точкой или в экспоненциальной форме. Логические значения могут иметь одно из двух возможных состояний. Это либо true (истина), либо false (ложь).

О PHP массивах вы можете почитать в этом уроке.

Илон Маск рекомендует:  Атрибут itemtype в HTML
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL