Чем константа отличается от переменной
Константа, переменная — это основополагающие понятия в любом языке программирования. Дадим определения этим понятиям.
Константа — это величина, которая при выполнении программы остаётся неизменной.
Переменная — это ячейка памяти для временного хранения данных. Предполагается, что в процессе выполнения программы значения переменных могут изменяться.
Описание и инициализация переменных
Прежде чем использовать в программе какую-то переменную, надо обязательно дать её описание , то есть сказать, какое имя имеет переменная и каков её тип. Вначале указывается тип переменной, а затем её имя. Например:
int k; // это переменная целого типа int
double x; // это переменная вещественного типа удвоенной точности
Если имеется несколько переменных одного типа, то допускается их описание через запятую в одном операторе, например:
После описания переменной её можно использовать, но возникает вопрос: а какое значение имеет переменная сразу же после её описания? Ответ таков: в программе на языке C# значение переменной после описания не определено. Такая переменная может использоваться в левой части оператора присваивания, но её нельзя использовать в выражении или в правой части оператора присваивания. Например:
y=z+1; // а так нельзя! Переменная z не определена
Для последнего оператора компилятор языка C# выдаст сообщение об ошибке. Этим свойством ( нельзя использовать переменную, которая не получила ни какого значения ) язык C# выгодно отличается от своих предшественников — языков С и С++.
Чтобы избежать проблемы, рекомендуется инициализировать переменные , то есть не просто выделять память под переменные, но и задавать им при этом необходимые значения. Например:
double x=3, y=4, z=5;
Инициализация переменных выполняется один раз на этапе компиляции и ни как не сказывается на скорости работы программы.
Задание и использование констант
Выше было дано определение констант. Теперь рассмотрим работу с константами более подробно.
Все константы вне зависимости от типа данных можно подразделить на две категории: именованные константы и константы, которые не имеют собственного имени. Например:
25 — константа целого типа;
3.14 — вещественная константа;
‘A’ — символьная константа.
Все три приведённые здесь константы не имеют имени, они заданы своим внешним представлением и используются в программе непосредственно, например так:
int k=25; // переменная k инициализирована константой — целым числом 25.
В ряде случаев константе удобнее дать имя и использовать её далее по имени. Это делает текст программы более наглядным. Обычно применяется для математических или физических констант.
В языке C# определить именованную константу очень просто Для этого используют ключевое слово const , например:
const double PI=3.14; // здесь PI — константа
Чем константа отличается от переменной
Константа, переменная — это базовые понятия в любом языке программирования. Дадим им определения.
Константа — это величина, которая при выполнении программы остаётся неизменной.
Переменная — это ячейка памяти для временного хранения данных. Предполагается, что в процессе выполнения программы значения переменных могут изменяться.
Описание и инициализация переменных
Прежде чем использовать в программе какую-то переменную, надо дать ей описание , то есть сказать, какое имя имеет переменная и каков её тип. Вначале указывается тип переменной, а затем её имя. Например:
int k; // это переменная целого типа int
double x; // это переменная вещественного типа удвоенной точности
Если имеется несколько переменных одного типа, то допускается их описание через запятую в одном операторе, например:
После описания переменной её можно использовать, но возникает вопрос: а какое значение имеет переменная сразу же после её описания? Ответ таков: в программе на языке C или C++ переменная после описания имеет произвольное значение , то есть ей просто выделяется свободный участок памяти и на этом всё заканчивается. В переменной хранится та последовательность двоичных цифр, которая была там до выделения памяти под эту переменную. Такой подход таит определённую опасность: можно по ошибке использовать в выражении переменную, которой не было присвоено ни какое значение:
Так как переменная x ни как не была определена, т. е. имела произвольное значение (чаще всего — это очень большое число или наоборот — очень маленькое), то и переменная y получит явно не то значение, на которое рассчитывал пользователь.
Чтобы избежать такой ошибки, Бьерн Страуструп рекомендует инициализировать переменные , то есть не просто выделять память под переменные, но и задавать им при этом необходимые значения. Например:
double a=3, b=4, c=5;
Инициализация переменных выполняется один раз на этапе компиляции, она не снижает скорость работы программы, но при этом уменьшает риск использования переменной, которая не получила ни какого значения.
Задание и использование констант
Выше было дано определение констант. Теперь рассмотрим работу с константами более подробно.
Все константы вне зависимости от типа данных можно подразделить на две категории: именованные константы и константы, которые не имеют собственного имени. Например:
25 — константа целого типа;
3.14 — вещественная константа;
‘A’ — символьная константа.
Все три приведённые здесь константы не имеют имени, они заданы своим внешним представлением и используются в программе непосредственно, например так:
int k=25; // переменная k инициализирована константой — целым числом 25.
В ряде случаев константе удобнее дать имя и использовать её далее по имени. Обычно это делается для математических или физических констант.
В языке C был единственный способ создания именованных констант — с помощью директивы препроцессора #define , например:
t = PI * 2; // здесь использована именованная константа PI, заданная выше
В языке C++ появился ещё один способ — использование константных переменных , то есть переменных, которые нельзя изменять после инициализации. Рассмотрим на том же примере:
const double PI=3.14; // здесь PI — константная переменная
В чём преимущество от использования константных переменных вместо задания констант с помощью директивы препроцессора #define ? Всё очень просто: при использовании константной переменной компилятор проверяет правильность задания константы, и если она будет задана неверно, то будет выдана ошибка именно в операторе, в котором дано определение константной переменной.
Если использована именованная константа, заданная директивой препроцессора #define , то ошибка будет показана только там, где используется константа. Например:
// в директиве препроцессора сделаем ошибку:
t = PI * 2; // в этой строке компилятор выдаст ошибку,
// хотя на самом деле ошибка допущена гораздо раньше!
Основы javascript
Для хранения данных в программе используются переменные и константы . Переменные предназначены для хранения каких-нибудь временных данных или таких данных, которые в процессе работы могут менять свое значение. Константы, наоборот, предназначены для хранения неизменных данных, значение которых должно оставаться постоянным в течение всей программы.
Объявление переменных
Для создания переменных применяются операторы var и let . Например, объявим переменную username :
var username;
Объявление переменной представляет отдельную инструкцию, поэтому завершается точкой с запятой.
Аналогичное определение переменной с помощью оператора let :
let username;
Каждая переменная имеет имя. Имя представляет собой произвольный набор алфавитно-цифровых символов, знака подчеркивания (_) или знака доллара ($), причем названия не должны начинаться с цифровых символов. То есть мы можем использовать в названии буквы, цифры, подчеркивание и символ $. Однако все остальные символы запрещены.
Например, правильные названия переменных:
$commision someVariable product_Store income2 myIncome_from_deposit
Следующие названия являются некорректными и не могут использоваться:
222lol @someVariable my%percent
Также нельзя давать переменным такие имена, которые совпадают с зарезервированными ключевыми словами. В JavaScript не так много ключевых слов, поэтому данное правило не сложно соблюдать. Например, следующее название будет некорректным, так как for — ключевое слово в JavaScript:
var for;
Список зарезервированных слов в JavaScript:
await, break, case, catch, class, const, continue, debugger, default, delete, do, else, enum, export, extends, false, finally, for, function, if, import, in, instanceof, new, null, return, super, switch, this, throw, true, try, typeof, var, void, while, with, yield
С развитием JavaScript и принятием новых стандартов языка список зарезервированных слов может пополняться, однако в целом их не так уж много.
Также не рекомендуется объявлять переменные с именем, которые аналогичны уже имеющимся глобальным переменным. Например, для вывода на консоль используется метод console.log() . Здесь console — это имя глобального объекта, и мы можем определить переменную с этим именем.
let console; // определяем переменную console console.log("Hello"); // ! Ошибка
Определение переменной console приведет к тому, что она переопределит одноименный глобальный объект console, и при вызове метода console.log() мы столвнемся с ошибкой.
Подобных глобальных объектов не так много, кроме console это также alert, blur, close, closed, document, focus, frames, location, navigator, open, screen, window .
При названии переменных надо учитывать, что JavaScript является регистрозависимым языком, то есть в следующем коде объявлены две разные переменные:
let username; let userName;
Через запятую можно определить сразу несколько переменных:
var username, age, height; let a, b, c;
Присвоение переменной значения
После определения переменной ей можно присвоить какое-либо значение. Для этого применяется оператор присваивания ( = ):
var username; username = "Tom";
То есть в данном случае переменная username будет хранить строку «Tom». После присвоения переменной значения мы можем что-то сделать с этим значением, например, выведем его на консоль:
METANIT.COM
Можно сразу присвоить переменной значение при ее определении:
var username = "Tom"; let userage = 37;
Процесс присвоения переменной начального значения называется инициализацией .Можно обратить внимание, что одна переменная определена с помощью let , а другая — с помощью var . Конкретно в данном случае это не имеет значения, и мы могли бы определить обе переменных либо с помощью let , либо с помощью var . Но в целом между let и var , есть различия, которые будут рассмотрены в одной из следующих статьях.
Можно сразу инициализировать несколько переменных:
let name1 = "Tom", name2 = "Bob", name3 = "Sam"; console.log(name1); // Tom console.log(name2); // Bob console.log(name3); // Sam
JavaScript позволяет некоторые вольности при определении переменной. Так, мы можем НЕ использовать ключевые слова let или var
METANIT.COM
Хотя мы можем так делать, но это не самый рекомендуемый подход. В одной из следующих статей мы увидим, с какими проблемами мы можем столкнуться при подобном подходе.
Изменение переменных
Отличительной чертой переменных является то, что мы можем изменить их значение:
METANIT.COM
Константы
С помощью ключевого слова const можно определить константу , которая, как и переменная, хранит значение, однако это значение не может быть изменено.
const username = "Tom";
Если мы попробуем изменить ее значение, то мы столкнемся с ошибкой:
const username = "Tom"; username = "Bob"; // ошибка, username - константа, поэтому мы не можем изменить ее значение
Также стоит отметить, что поскольку мы не можем изменить значение константы, то она должна быть инициализирована, то есть при ее определении мы должны предоставить ей начальное значение. Если мы этого не сделаем, то опять же мы столкнемся с ошибкой:
const username; // ошибка, username не инициализирована
Когда использовать переменные, а когда константы? Если вы уверены, что значение в процессе программы не будет изменяться, тогда это значение определяется в виде константы. Если неизвестно, будет ли значение меняться или нет, то рекомендуется определить значение как константу. А в случае если в далее потребуется его изменить, то просто можно изменить определение значения с const на var / let .
Переменные и константы
Основной способ сохранения информации в ходе выполнения программы PHP состоит в использовании переменных; этот способ предусматривает выбор некоторого имени переменной и привязку к нему того значения, которое потребуется в процессе дальнейшего выполнения программы.
Ниже приведены наиболее важные сведения о переменных в языке PHP, которые следует знать:
- Все переменные в языке PHP обозначаются префиксом в виде знака доллара ($).
- Значением переменной является значение, присвоенное ей в последней по времени операции присваивания.
- Присваивание значений переменным осуществляется с помощью операции присваивания; при этом переменная должна находиться слева от знака операции присваивания (=), а вычисляемое выражение — справа.
- Переменные могут быть объявлены перед присваиванием им значений, но такое требование не является обязательным.
- Переменные не имеют связанного с ними типа, отличного от типа своего текущего значения.
- Переменные, используемые до того, как им будет присвоено значение, имеют значения, заданные по умолчанию.
Имена всех переменных в языке PHP начинаются с префикса в виде знака $. Остальная часть имен переменных, находящаяся за начальным префиксом $, должна состоять из букв в коде ASCII (прописных и строчных), цифр (0-9) и символов подчеркивания (_). Кроме того, первым символом после знака $ не должна быть цифра.
Присваивание значений переменным
Операция присваивания значения переменной очень проста — достаточно лишь написать имя переменной, ввести после него один знак равенства (=), затем ввести выражение, значение которого требуется присвоить переменной:
$pi = 3 + 0.14159; // Приближенное значение числа "пи"
Следует учитывать, что переменной присваивается результат выражения, а не само выражение. Например, после присваивания значения с помощью приведенного выше оператора невозможно определить, что значение, присвоенное переменной $pi, было получено путем сложения двух чисел.
Вполне возможно, что в программе фактически потребуется вывести на внешнее устройство приведенное математическое выражение, а не вычислять его значение. Программист может вынудить интерпретатор PHP рассматривать оператор присваивания переменной результата математического вычисления как оператор присваивания строкового значения, заключив это выражение в кавычки:
$pi = "3 + 0.14159";
Во многих языках программирования попытка использовать переменную до того, как ей будет присвоено значение, рассматривается как ошибка. В некоторых других языках такая возможность предоставляется, но может оказаться, что чтение значения этой переменной равносильно чтению сформированного случайным образом содержимого какой-то области памяти. В языке PHP по умолчанию применяется параметр конфигурации, касающийся активизации сообщений об ошибках, который позволяет использовать переменные без присвоенных им значений, не вызывая активизации ошибок, а интерпретатор PHP гарантирует, что такие переменные будут иметь вполне приемлемые значения, заданные по умолчанию.
Переменные в языке PHP не имеют связанных с ними типов, поэтому в отношении переменной, приведенной в тексте программы, нельзя узнать заранее, будет ли она использоваться для хранения числа или строки символов. Как же в этом случае можно определить, какое заданное по умолчанию значение должна иметь переменная, если ей еще не присвоено значение?
Ответ на этот вопрос состоит в том, что тип переменной с неприсвоенным значением (как и в случае переменной с присвоенным значением) интерпретируется в зависимости от контекста, в котором используется эта переменная. В той ситуации, когда ожидается появление числа, вырабатывается число; аналогичный принцип применяется в отношении символьных строк. В любом контексте, в котором переменная рассматривается как число, переменная с неприсвоенным значением рассматривается как имеющая значение 0, а в любом контексте, в котором ожидается строковое значение, переменная с неприсвоенным значением рассматривается как имеющая в качестве значения пустую строку (строку длиной нуль символов).
Поскольку язык PHP не предъявляет такого требования, чтобы переменной было обязательно присвоено значение перед ее использованием, в некоторых ситуациях можно фактически изменять код выполнения программы, избирательно присваивая или не присваивая значение переменной! В языке PHP предусмотрена функция IsSet, которая проверяет переменную для определения того, было ли этой переменной присвоено значение.
Как показано в приведенном ниже коде, переменную с неприсвоенным значением можно отличить даже от переменной, которой было присвоено значение, предусмотренное по умолчанию:
'; if (isset($unset)) echo 'Переменная $unset инициализирована
'; if ($set == $unset) echo '$set == $unset'; ?>
Безусловно, на первый взгляд это может показаться странным, но приведенный выше код вырабатывает следующий результат:
Переменной $unset никогда еще не присваивалось значение, поэтому она вырабатывает нулевое значение, когда ожидается число (как в проверке со сравнением на равенство, которое показывает, что две рассматриваемые переменные имеют одинаковое значение). Тем не менее функция IsSet позволяет провести различие между переменными $set и $unset.
Область определения переменной
— это формальный термин, используемый при формулировке правил, касающихся того, в каких ситуациях некоторое имя (скажем, переменной или функции) имеет один и тот же смысл в разных местах и в каких ситуациях два полностью совпадающих имени фактически ссылаются на разные объекты.
Любая переменная PHP, не заданная в функции, имеет глобальную область определения, и действие переменной распространяется за пределы данного конкретного «потока» выполнения. Иными словами, если какой-то переменной присваивается значение в начале файла сценария PHP, то переменная с этим именем сохраняет одно и то же значение в ходе обработки остальной части файла сценария, и если переменной не присваивается какое-то другое значение, то она сохраняет прежнее значение до конца сеанса выполнения данного кода (исключением являются переменные с теми же именами, находящиеся в теле функций).
Ниже показан расширенный пример использования глобальных и локальных переменных, показывающий их различия между собой:
Основы PHP Переменная $number существует
'; > else < echo ('
Переменная $number не существует
'); > // Внешнюю переменную можно сделать доступной внутри тела функции только // с использованием ключевого слова global global $number; if (isset($number)) < echo 'А теперь переменная $number существует и она равна '.$number.'
'; > $local = 11; // Это локальная переменная, ее можно использовать только в теле функции > func1(); ?>
Глобальные переменные внутри функций следует использовать в редких случаях, поскольку легко изменить значение переменной по ошибке, не предусмотрев последствий. Ошибки такого типа бывает очень сложно обнаружить.
Статические переменные – это переменные, которые не исчезают после завершения функции. Значение статической переменной можно снова использовать при следующем вызове функции – она по-прежнему будет иметь то же значение, которое получила при последнем вызове функции. Проще всего считать такую переменную глобальной, но доступной только для данной функции. Статическая переменная объявляется с помощью ключевого слова static:
"; > // Присвоить переменной age значение 30 $age = 30; // Вызвать функцию дважды birthday(); birthday(); // Вывести значение переменной age echo "Возраст: $age
"; ?>
В результате исполнения этого фрагмента будет выведено:
Для предоставления информации об окружении, в котором работает PHP-сценарий, PHP использует специальные переменные, которые называются суперглобальными (super globals). Эти переменные не нужно объявлять как глобальные, они автоматически становятся общедоступными и содержат важные сведения об окружении сценария, например данные, полученные от пользователя.
Начиная с версии PHP 4.0.1 суперглобальные переменные определены как массивы, их можно вызывать как внутри функций, так и внутри остального контекста программы. Старые суперглобальные переменные, носящие имена с префиксом $HTTP_* и расположенные не в массивах, по-прежнему существуют, но их не рекомендуется использовать из соображений безопасности. В таблице ниже приведен перечень суперглобальных массивов, появившихся в версии PHP 4.0.1:
Имя переменной массива | Описание |
---|---|
$GLOBALS | Содержит все глобальные переменные, доступные локальному сценарию. Имена переменных используются как индексы массива |
$_SERVER | Содержит информацию об окружении веб-сервера |
$_GET | Содержит информацию о запросах GET (при отправке форм). Эти значения следует обязательно проверять перед использованием |
$_POST | Содержит информацию о запросах POST (другой тип отправки форм). Эти значения следует обязательно проверять перед использованием |
$_COOKIE | Содержит информацию о cookies HTTP |
$_FILES | Содержит информацию о файлах, загружаемых методом POST |
$_ENV | Содержит информацию об окружении сценариев |
$_REQUEST | Содержит информацию о пользовательском вводе. Эти значения следует обязательно проверять пред использованием. Вместо этого массива следует использовать $_GET или $_POST, т.к. они более специализированные |
$_SESSION | Содержит информацию из всех переменных, зарегистрированных в рамках сессии (сеанса пользователя) |
Примером суперглобальной переменной может служить $_SERVER[«PHP_SELF»]. Эта переменная содержит имя исполняемого сценария и входит в состав массива $_SERVER:
Использование переменной PHP_SELF
Суперглобальные переменные обеспечивают удобный способ доступа к информации об окружении сценария – от настроек сервера до введенных пользователем данных.
Константы
В программе вы можете определять константы. Значение константы, как следует из ее названия, не может изменяться во время исполнения программы. Константы определяют с помощью функции define(), которой в первом аргументе передается имя константы, а во втором – ее значение. Константы имеют глобальную область видимости и могут принимать значение любого элементарного (скалярного) типа данных, например строки или числа.
Чтобы получить значение константы, достаточно просто обратиться к ее имени или воспользоваться функцией constant. В отличие от переменных, перед именем константы знак доллара ($) не ставится.
Если имя константы хранится в переменной или возвращается функцией, то чтобы получить значение константы, необходимо воспользоваться функцией constant(имя_константы). Эта функция получает имя константы в качестве аргумента и возвращает ее значение. Кроме того, с помощью функции get_defined_constants() можно получить список (в виде массива) всех определенных вами констант.
Отличия констант и переменных:
- в именах констант принято использовать только заглавные буквы;
- имена констант не начинаются со знака доллара ($);
- определить константу можно только с помощью функции define, а не простым оператором присваивания;
- константы определяются и доступны глобально;
- после объявления константу нельзя переопределить или отменить;
- константы могут иметь только скалярные значения (числа и строки).
В примере ниже показан порядок использования констант:
Использование констант в программе
Этот код дважды выведет значение константы HELLO . В константе полезно хранить значение, которое должно оставаться неизменным, например путь к файлу настроек.
PHP предоставляет несколько предопределенных констант, похожих на суперглобальные переменные. Примеры таких констант: константа __FILE__ – возвращает имя исполняющегося PHP-файла, константа __LINE__ – возвращает номер строки этого файла. Видно, что имя предопределенной константы начинается и заканчивается двумя символами подчеркивания. Эти константы удобно использовать для вывода сообщений об ошибках, поскольку с их помощью можно указать, при исполнении какой строки возникла ошибка.