defined — проверяет, существует ли данная именованная константа


Определение констант

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

Определяет новую константу с именем, переданным в $name, и значением $value.

Если необязательный параметр $case_sen равен true, то в дальнейшем в программе регистр букв константы учитывается, в противном случае – не учитывается (по умолчанию, как мы видим, регистр учитывается). Созданная константа не может быть уничтожена или переопределена. Например:

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

Проверка существования константы

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

bool defined(string $name)

Возвращает true, если константа с именем $name была ранее определена.

Выражения

Выражения – это один из «кирпичей», на которых держится здание PHP. Действительно, практически все, что вы пишете в программе – это выражение. Мне нравится следующее определение понятия «выражение»: «нечто, имеющее определенное значение». И обратно: если что-то имеет значение, то это «что-то» есть выражение.

Самый простой пример выражения – переменная или константа, стоящая, скажем, в правой части оператора присваивания. Например, цифра 5 в операторе $a=5; есть выражение, т. к. оно имеет значение 5. После такого присваивания мы вправе ожидать, что в $a окажется 5. Теперь, если мы напишем $b=$a; то, очевидно, в $b окажется также 5, ведь выражение $a в правой части оператора имеет значение 5.

Нетрудно догадаться, какое оно имеет значение: 5 (тут просто не может быть никаких других вариантов, не правда ли?). А это значит, что мы можем написать что-то типа следующих команд:

$a=($b=10); // или просто $a=$b=10

При этом переменным $a и $b присвоится значение 10. А вот еще пример, уже менее тривиальный:

Что окажется в переменных после выполнения этих команд? Очевидно, то же, что и в результате работы следующих операторов:

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

echo «$a:», gettype($a),» $b:», gettype($b);

// выведет «200:integer 200:string»

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

Итак, вот эти операторы:

??$b=intval(выражение) или $b=(int)(выражение)

Переводит значение выражения в целое число и присваивает его $b.

??$b=doubleval(выражение) или $b=(double)(выражение)

Переводит значение в действительное число и присваивает его $b.

??$b=strval(выражение) или $b=(string)(выражение)

Переводит значение выражения в строку.

Преобразует значение выражения в логический тип. То есть, после выполнения этого оператора в $b окажется либо true, либо false. Вообще-то, есть еще два хитроумных оператора (array) и (object), но эти операторы мы рассматривать не будем в силу их крайне слабой распространенности.

Константы в PHP

Всем доброго времени суток. На связи Алексей Гулынин. В прошлой статье мы разобрали оператор эквивалентности в PHP . В данной статье я бы хотел рассказать о константах в PHP. В школе вы не раз встречали константы, например «число PI» или из физики универсальная газовая постоянная (R). Константы один раз определяют и они уже не меняются. Тоже самое касается констант в программировании, т.е. мы один раз определяем константу и она больше не меняется в коде программы. Константами могут быть различные математические величины, пути до файлов.

Чем константа отличается от переменной:

1) Её определяют один раз и нигде больше нельзя присвоить значение,
2) Чтобы к ней обратиться, не нужно ставить знак «$» перед ней (здесь есть минус — теперь мы не можем использовать имя константы в текстовой строке).
Давайте выведем константу «PI»:

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

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

1) __FILE__ — хранит имя файла, в котором находится тот код, который сейчас выполняется,
2) PHP_VERSION — версия интерпретатора PHP,
3) PHP_OS — версия операционной системы, под которой работает PHP.

Наберите следующий код и посмотрите, какие константы ещё бывают:

Можно определять свои собственные константы, делается это с помощью оператора define . Давайте определим 2 константы:

В данном случае у нас выведутся значения данных констант.

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

Вы увидите, что всё работает (в предыдущем примере работать не будет, так как там учитывается регистр букв).

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

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

Наберите данный пример и посмотрите, что будет.

Домашнее задание: создайте одну текстовую константу без учета регистра символов и одну числовую с учетом регистра. Проверьте существуют ли эти константы.

В данной статье вы узнали, что такое константы в PHP.

На связи был Алексей Гулынин, оставляйте свои комментарии, увидимся в следующих статьях.

Как проверить, существует ли константа в PHP — php

Поэтому я использую PHP-фреймворк fuelphp, и у меня есть эта страница, которая является HTML- файлом, поэтому я не могу использовать в ней PHP. У меня есть другой файл с верхней панелью, который мой HTML файл будет вызывать через ajax.

Илон Маск рекомендует:  Что такое код getmenuitemid

Как проверить, существует ли константа в PHP?
Я хочу проверить местонахождение файла каркаса fuelphp.

Вот константы, которые мне нужно проверить (на самом деле, я должен проверить только одну из них):

редактировать:
Я понял, что это не переменные, а константы.

Различие define и const

В чем различие между этими определениями переменной:

Что из этих двух является более предпочтительным и в чем достоинства каждого?

2 ответа 2

Это очень дискуссионный вопрос у всех. Но в целом, в с++ лучше использовать const везде, где это возможно.

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

У define это все — недостатки. Они действуют от места определения и до . конца. Хотя, где этот конец будет — ещё нужно хорошо подумать. Они могут переопределять друг дружку и иногда искать, где именно было в очередной раз переопределено — ещё то удовольствие. Компилятор часто выдает очень «загадочные ошибки». Классический пример с макросом min/max. Файл windows.h определяет их. И может быть очень весело. Детали — NOMINMAX.

Ещё у define есть большой недостаток — это то, что некоторые думают, что там есть скобки. А их нет.

кажется, что будет посчитано (x+y) в квадрате. А на самом деле — . на самом деле x+y + x*y.

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

  • eсли нужно просто определить константу — используйте const (даже само слово намекает).
  • eсли нужно определить макрос — используйте функции (если хочется интересней — используйте inline, но компиляторы сейчас достаточно умные).
  • если нужно усложнить код и добавить синтаскического сахара — тогда самое время использовать define.

UPD

А ещё хорошо найти книгу Эффективное использование C++. 55 верных советов улучшить структуру и код ваших программ — Скотт Майерс и почитать второй совет (в любом случае — там всю книгу можно читать и читать).


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

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

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

Но, опять же, такое различие существует лишь на уровне соглашений, т.е. разницы между const int и constexpr int в тривиальных применениях вы не заметите.

Однако и у #define тоже есть свои преимущества.

Ограничение на использование только либо const , либо #define варианта возникнет тогда, когда вы будете создавать кросс-компилируемый С и С++ код (например, заголовочные файлы библиотек, предназначенных для использования в обоих языках). Тогда вам в большинстве случаев придется пользоваться именно #define , ибо в языке С квалификатор const не создает констант. В языке С для создания именованных констант времени компиляции у вас есть только enum и #define .

В качестве еще одного преимущества варианта с #define можно назвать очевидную (но часто забываемую) возможность использовать #define -константы в условных выражениях препроцессора, т.е. в #if . Ни const , ни constexpr вам там не помогут. Шаблонное метапрограммирование и появление в языке С++ таких C++17 свойств, как «static if» ( if constexpr ) тоже частично переносит такие применения из области препроцессора в область самого языка и, соответственно, снижает ценность #define -констант в С++, но тем не менее эта деталь тоже заслуживает упоминания.

ИСПОЛЬЗОВАНИЕ ИМЕНОВАННЫХ КОНСТАНТ

Именованная константа — это просто имя, которому присваивается постоянное значение (константа). Такая константа в отличие от значения переменной не может изменяться по мере выполнения программы. Именованная константа создается с использованием директивы препроцессора #define (специальной инструкции для препроцессора компилятора). Например, следующий оператор определяет именованную константу CLASS_SIZE как значение 50:

#define CLASS_SIZE 50

Чтобы отличить именованную константу от переменной, большинство программистов используют для именованных констант буквы верхнего регистра. Например, следующая программа CONSTANT.CPP определяет и выводит именованную константу CLASS_SIZE:

#define CLASS_SIZE 50 // Число студентов в классе

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

Лучшие изречения: Сдача сессии и защита диплома — страшная бессонница, которая потом кажется страшным сном. 8771 — | 7143 — или читать все.

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

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

очень нужно

Почему кто-то использует #define для определения констант?

Это простой вопрос, но зачем кому-то использовать #define для определения констант?

Какая разница между

#define sum 1 и const int sum = 1;

#define имеет много разных приложений, но ваш вопрос, похоже, касается одного конкретного приложения: определение именованных констант.

В С++ редко существует причина использовать #define для определения именованных констант.

#define обычно широко используется в коде C, так как язык C существенно отличается от С++, когда дело доходит до определения констант. Короче говоря, объекты const int не являются константами в C, а это значит, что в C основным способом определения истинной константы является использование #define . (Кроме того, для констант int можно использовать перечисления).

Никто не должен! На самом деле, следует предпочесть const int sum = 1; над #define sum 1 по ряду причин:

Илон Маск рекомендует:  Атрибут pluginspage в HTML

Механизм на основе видимости:

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

Избегайте странных магических чисел при ошибках компиляции:

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

Простота отладки:

Также по тем же причинам, указанным в # 2, в то время как отладка #define не даст никакой помощи.

Таким образом, чтобы избежать вышеуказанных ситуаций, const будет лучшим выбором.

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

Это то, что вы не можете сделать с константой. Если вам не нужно значение, доступное из препроцессора, я бы сказал, используйте const, если нет причин, почему это невозможно. Там некоторые вещи на этом в С++ FAQ lite, где они справедливо указывают на то, что только потому, что препроцессор «злой», это не значит вам это никогда не понадобится.

#define необходимо сделать такие вещи, как включение охранников, потому что у С++ нет реальной системы импорта модулей.

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

Это имеет ряд ограничений: #define sq(x) x * x не будет работать правильно, если вы используете его как sq(3+3) ; и использование #define для константы никак не относится к сфере видимости и не связывает какой-либо тип с константой. Тем не менее, #define может использоваться (особенно в сочетании с некоторыми другими специальными элементами, такими как операторы препроцессора # и ## ), чтобы сделать магию, которая в противном случае невозможна (за исключением того, что вручную выполняет то, что делает препроцессор).

Всегда пытайтесь использовать «const int», а не #define.

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

Также это единственный способ определить что-то, что будет проверено позже, # if/# else/# endif

Это означает, что sum не существует после завершения этапа предварительной обработки.

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

const int — это просто int, который не может измениться. #define — это директива для препроцессора C, которая намного больше, чем просто для определения констант.

Во-первых, это директива препроцессора, прежде чем компилятор компилирует ваш код, он перейдет и заменит сумму на 1. Вторая объявляет переменную в памяти для хранения этого количества. Я уверен, что можно утверждать, что лучше, но «const int», вероятно, более распространен в С++ (когда дело доходит до числовых констант).

Посмотрите другие вопросы по меткам c++ c-preprocessor const или Задайте вопрос

Checking for existence of constants before defining them

I am seeing many plugins use the following format for defining their constant:

So basically there is a check before we define the constant.

My question is why is this check necessary? What if I make a new version of the plugin and want to change the name of the javascript folder from ‘js’ to ‘javascript’? I would have to include that change in an upgrade routine. Why not just define the constants without checking for their existence?

Я вижу много плагин использовать следующий формат для определения их постоянная:

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

Мой вопрос: почему эта проверка необходима? Что делать, если я создаю новую версию плагина и хочу изменить имя папки javascript с «js» на «javascript»? Я должен был бы включить это изменение в процедуру обновления. Почему бы просто не определить константы, не проверяя их существование?

Создан 05 мар. 13 2013-03-05 10:22:24 urok93

Defined — проверяет, существует ли данная именованная константа

defined — проверяет, существует ли данная именованная константа.

Описание

bool defined (string name)

Возвращает TRUE , если именованная константа name определена, FALSE в ином случае.

Пример 1. Проверка констант


Назад Оглавление Вперёд
define Вверх die

© 2006-2012 Веб-мастер Борисов Виктор Александрович

Checking for existence of constants before defining them

I am seeing many plugins use the following format for defining their constant:

So basically there is a check before we define the constant.

My question is why is this check necessary? What if I make a new version of the plugin and want to change the name of the javascript folder from ‘js’ to ‘javascript’? I would have to include that change in an upgrade routine. Why not just define the constants without checking for their existence?

Я вижу много плагин использовать следующий формат для определения их постоянная:


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

Мой вопрос: почему эта проверка необходима? Что делать, если я создаю новую версию плагина и хочу изменить имя папки javascript с «js» на «javascript»? Я должен был бы включить это изменение в процедуру обновления. Почему бы просто не определить константы, не проверяя их существование?

Создан 05 мар. 13 2013-03-05 10:22:24 urok93

defined

defined — Проверяет существование указанной именованной константы

Описание

Проверяет существование и наличие значения указанной константы.

Если необходимо узнать о существовании переменной, то используйте isset() , так как defined() применима лишь для констант. Если вам необходимо узнать о существовании функции, то используйте function_exists() .

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

Возвращаемые значения

Возвращает TRUE , если именованная константа, указанная в параметре name , была определена, FALSE в противном случае.

Примеры

Пример #1 Проверка констант

Смотрите также

  • define() — Определяет именованную константу
  • constant() — Возвращает значение константы
  • get_defined_constants() — Возвращает ассоциативный массив с именами и значениями всех предопределенных констант
  • function_exists() — Возвращает TRUE, если указанная функция определена
  • См. раздел Константы

Коментарии

In PHP5, you can actually use defined() to see if an object constant has been defined, like so:

class Generic
<
const WhatAmI = ‘Generic’ ;
>

if ( defined ( ‘Generic::WhatAmI’ ))
<
echo Generic :: WhatAmI ;
>

?>

Thought it may be useful to note.

If your constants don’t show up in your included or required files, then you probably have php safe mode turned on!

I ran into this problem, I forgot to turn of safe mode when I was creating a new site.

I saw that PHP doesn’t have an enum function so I created my own. It’s not necessary, but can come in handy from time to time.

function enum ()
<
$args = func_get_args ();
foreach( $args as $key => $arg )
<
if( defined ( $arg ))
<
die( ‘Redefinition of defined constant ‘ . $arg );
>

enum ( ‘ONE’ , ‘TWO’ , ‘THREE’ );
echo ONE , ‘ ‘ , TWO , ‘ ‘ , THREE ;
?>

My preferred way of checking if a constant is set, and if it isn’t — setting it (could be used to set defaults in a file, where the user has already had the opportunity to set their own values in another.)

( ‘CONSTANT’ ) or define ( ‘CONSTANT’ , ‘SomeDefaultValue’ );

You may find that if you use to dump your constants, and they are not defined, depending on your error reporting level, you may not display an error and, instead, just show the name of the constant. For example:

. may say TEST instead of an empty string like you might expect. The fix is a function like this:

function C (& $constant ) <
$nPrev1 = error_reporting ( E_ALL );
$sPrev2 = ini_set ( ‘display_errors’ , ‘0’ );
$sTest = defined ( $constant ) ? ‘defined’ : ‘not defined’ ;
$oTest = (object) error_get_last ();
error_reporting ( $nPrev1 );
ini_set ( ‘display_errors’ , $sPrev2 );
if ( $oTest -> message ) <
return » ;
> else <
return $constant ;
>
>

?>

And so now you can do:

( TEST ) ?>

If TEST was assigned with define(), then you’ll receive the value. If not, then you’ll receive an empty string.

Please post if you can do this in fewer lines of code or do something more optimal than toggling the error handler.

Before using defined() have a look at the following benchmarks:

true 0.65ms
$true 0.69ms (1)
$config[‘true’] 0.87ms
TRUE_CONST 1.28ms (2)
true 0.65ms
defined(‘TRUE_CONST’) 2.06ms (3)
defined(‘UNDEF_CONST’) 12.34ms (4)
isset($config[‘def_key’]) 0.91ms (5)
isset($config[‘undef_key’]) 0.79ms
isset($empty_hash[$good_key]) 0.78ms
isset($small_hash[$good_key]) 0.86ms
isset($big_hash[$good_key]) 0.89ms
isset($small_hash[$bad_key]) 0.78ms
isset($big_hash[$bad_key]) 0.80ms

PHP Version 5.2.6, Apache 2.0, Windows XP

Each statement was executed 1000 times and while a 12ms overhead on 1000 calls isn’t going to have the end users tearing their hair out, it does throw up some interesting results when comparing to if(true):

1) if($true) was virtually identical
2) if(TRUE_CONST) was almost twice as slow — I guess that the substitution isn’t done at compile time (I had to double check this one!)
3) defined() is 3 times slower if the constant exists
4) defined() is 19 TIMES SLOWER if the constant doesn’t exist!
5) isset() is remarkably efficient regardless of what you throw at it (great news for anyone implementing array driven event systems — me!)

May want to avoid if(defined(‘DEBUG’)).

I found something out: defined() becomes probably false if a reference gets lost.

(); // $_SESSION created
define ( ‘SESSION_BACKUP’ , $_SESSION );
if ( defined ( ‘SESSION_BACKUP’ )) echo ‘A’ ;
session_unset (); // $_SESSION destroyed
if ( defined ( ‘SESSION_BACKUP’ )) echo ‘B’ ;

?>

You will see «A», but not «B».

You can use the late static command «static::» withing defined as well. This example outputs — as expected — «int (2)»

abstract class class1
<
public function getConst ()
<
return defined ( ‘static::SOME_CONST’ ) ? static:: SOME_CONST : false ;
>
>

final class class2 extends class1
<
const SOME_CONST = 2 ;
>

$class2 = new class2 ;

var_dump ( $class2 -> getConst ());
?>

If you wish to protect files from direct access I normally use this:

// Main stuff here
define ( ‘START’ , microtime ());

if you want to check id a class constant is defined use self:: before the constant name:

This function, along with constant(), is namespace sensitive. And it might help if you imagine them always running under the «root namespace»:

<
const WMP = «wmp» ;
function test ()
<
if( defined ( «WMP» )) echo «direct: » . constant ( «WMP» ); //doesn’t work;
elseif( defined ( «FOO\\BAR\\WMP» )) echo «namespace: » . constant ( «FOO\\BAR\\WMP» ); //works
echo WMP ; //works
>
>
namespace
<
FOOBARtest ();
>

// Checking the existence of a class constant, if the class is referenced by a variable.

class Class_A
<
const CONST_A = ‘value A’;
>

// When class name is known.
if ( defined( ‘Class_A::CONST_A’ ) )
echo ‘Class_A::CONST_A defined’;

// Using a class name variable. Note the double quotes.
$ > if ( defined( «$class_name::CONST_A» ) )
echo ‘$class_name::CONST_A defined’;

// Using an instantiated object for a variable class.
$object_A = new $class_name();
if ( defined( get_class($object_A).’::CONST_A’ ) )
echo ‘$object_A::CONST_A defined’;

Be careful with boolean defines and assuming a check is done for a specific value by defined such as
( ‘DEBUG’ , false );

if( defined ( ‘DEBUG’ )) <
echo ‘Not really debugging mode’ ;
>
?>

You want to also check the constant as in

if( defined ( ‘DEBUG’ ) && DEBUG ) <
echo ‘Really this is debugging mode’ ;
>
?>

All defined is doing is verifying the constant exists not it’s value.

Dont forget to put the name of your constant into single quotation mark. You will not get an error or a warning.

( «AMOUNT_OF_APPLES» , 12 );
if( defined ( AMOUNT_OF_APPLES )) <
//you won’t get an output here
echo AMOUNT_OF_APPLES ;
>
?>

so do instead

( «AMOUNT_OF_APPLES» , 12 );
if( defined ( «AMOUNT_OF_APPLES» )) <
//here you go
echo AMOUNT_OF_APPLES ;
>

//output: 12
?>

It took me half an day to see it.

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