How efficient is define in PHP?

StackOverflow https://stackoverflow.com/questions/148185

  •  02-07-2019
  •  | 
  •  

Question

C++ preprocessor #define is totally different.

Is the PHP define() any different than just creating a var?

define("SETTING", 0);  
$something = SETTING;

vs

$setting = 0;  
$something = $setting;
Was it helpful?

Solution

'define' operation itself is rather slow - confirmed by xdebug profiler.

Here is benchmarks from http://t3.dotgnu.info/blog/php/my-first-php-extension.html:

  • pure 'define'
    380.785 fetches/sec
    14.2647 mean msecs/first-response

  • constants defined with 'hidef' extension
    930.783 fetches/sec
    6.30279 mean msecs/first-response

broken link update

The blog post referenced above has left the internet. It can still be viewed here via Wayback Machine. Here is another similar article.

The libraries the author references can be found here (apc_define_constants) and here (hidef extension).

OTHER TIPS

In general, the idea of a constant is to be constant, (Sounds funny, right? ;)) inside your program. Which means that the compiler (interpreter) will replace "FOOBAR" with FOOBAR's value throughout your entire script.

So much for the theory and the advantages - if you compile. Now PHP is pretty dynamic and in most cases you will not notice a different because the PHP script is compiled with each run. Afai-can-tell you should not see a notable difference in speed between constants and variables unless you use a byte-code cache such as APC, Zend Optimizer or eAccelerator. Then it can make sense.

All other advantages/disadvantages of constants have been already noted here and can be found in the PHP manual. 

php > $cat='';$f=microtime(1);$s='cowcow45';$i=9000;while ($i--){$cat.='plip'.$s.'cow';}echo microtime(1)-$f."\n";

0.00689506530762

php > $cat='';$f=microtime(1);define('s','cowcow45');$i=9000;while ($i--){$cat.='plip'.s.'cow';}echo microtime(1)-$f."\n";

0.00941896438599

This is repeatable with similar results. It looks to me like constants are a bit slower to define and/or use than variables.

Here are the differences, from the manual

  • Constants do not have a dollar sign ($) before them;
  • Constants may only be defined using the define() function, not by simple assignment;
  • Constants may be defined and accessed anywhere without regard to variable scoping rules;
  • Constants may not be redefined or undefined once they have been set; and
  • Constants may only evaluate to scalar values.

For me, the main benefit is the global scope. I certainly don't worry about their efficiency - use them whenever you need a global scalar value which should not be alterable.

NOT efficient it appears. (And i'm basing all the assumptions here on one comment from php.net, i still haven't did the benchmarks myself.)

recalling a constant, will take 2x the time of recalling a variable.

checking the existence of a Constant will take 2ms and 12ms for a false positive!

Here's a benchmark from the comments of the define page in php's online doc.

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'))...

from tris+php at tfconsulting dot com dot au 26-Mar-2009 06:40

http://us.php.net/manual/en/function.defined.php#89886

Define is simple static sense, meaning its value can't be changed during runtime while variable is dynamic sense because you can freely manipulate its value along the process.

Main differences:

  • define is constant, variable is variable
  • they different scope/visibility

When I run speed tests, constants being set and dumped out run much a little faster than setting variables and dumping them out.

Not sure about efficiency, but it is more than creating a var:

  • It is a constant: you can't redefine or reassign this SETTING.
  • If the define isn't found, $something is set to "SETTING", which is useful, for example, in i18n: if a translation is missing (ie. the corresponding define is the localization file), we see a big word in uppercase, quite visible...
Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow
scroll top