PHP performance of using constants instead of strings

Question

I am creating a web app in pure PHP and I have to interchange some status between functions, this status can be around 5 like for example: user_created, user_active, user_inactive and so on. So, what't the most efficient way to do this?

Inicially I was returning strings from my functions, but i know that strings comparison can be quite slow and more on if the name of the status get longer and longer, so I thought on creating constants with integer values, but it got me thinking... if the PHP parser still needs to read the whole constant name before comparing, is not it the same than using a string, or a variable? is there a more efficient way to do this?

sorry if it looks like a trivial question, I just try to optimize every aspect of my app

if it's not totally clear what i am going to do is really simple:

function getUserStatus() {
    // return some value
}

and then use it as follows

$userStatus = getUserStatus();
switch ($userStatus) {
    // all possible cases
}

Answer 1

I'm going to address several aspects of your question, to hopefully give you a broader understanding.

For your actual question, the answer is that the runtime stage and the parsing stage of your application are separate concepts. PHP does have to parse your source code, but that source code is then converted into another format known as Opcode. Opcode is a lower level, more efficient representation of your code. The runtime also caches this representation, which means it doesn't have to parse your source code on every invocation.

When you compare two strings, the time it takes is dependent on the length of the shortest string (generally speaking). Integers, however, can generally be compared much more efficiently, and that is what performance benefit you are trying to achieve by using integer-based constants. The lookup of a constant's value does not necessarily require traversing the name of the constant as a string, because its representation in opcode is not, necessarily, the same as it is in your source code. However, as is pointed out in another answer, it seems that PHP is actually optimized for string comparisons and they actually out-perform constant integer comparisons by a small degree!

That doesn't, necessarily, mean you shouldn't switch to constants, anyway, however. The real benefit of using constants vs string literals for these types of comparisons is that the runtime is able to help you out when you, say, make a typo. If your codebase is littered with string comparisons of the type $var == "some special value", the parser is more than happy to let you introduce a typo in "some special value" in obscure areas of your code. If you use constants, however, a comparison such as $var == MY_SPECIAL_CONSTANT will warn you if you mistype the name of the constant. It also allows you to define the concrete value in a single place (the constant definition) such that if you ever need to change it, it's a one-line change instead of a massive find-replace effort.

A lot of PHP code tends to be "string based programming" and these types of codebases can be brittle and easily susceptible to typos. Constants can really help here and this where their value really lies, rather than in performance.

Answer 2

You can test it with something like below.

Note that PHP Optimizes a lot, and stores compiled byte code in its cache. http://php.net/manual/en/intro.opcache.php

The results

string 0.38328790664673 constant 0.50211310386658

string 0.38391804695129 constant 0.51568698883057

What surprises me is that String seems to be faster.

I noted the following setting in the opcache config:

opcache.interned_strings_buffer integer
The amount of memory used to store interned strings, in megabytes. 
This configuration directive is ignored in PHP < 5.3.0.

A pretty neat setting with like 0 documentation. PHP uses a technique called string interning to improve performance so, for example, if you have the string "foobar" 1000 times in your code, internally PHP will store 1 immutable variable for this string and just use a pointer to it for the other 999 times you use it. Cool. This setting takes it to the next level. instead of having a pool of these immutable string for each SINGLE php-fpm process, this setting shares it across ALL of your php-fpm processes. It saves memory and improves performance, especially in big applications.

So stating that string comparison is slower than constant comparison is a wrong assumption in PHP.

BUT: You can break this optimalization example:

$state = "State";
switch($string) {
    case "Offline" . $state:
    break;
}

The result of this will be: string 0.61401081085205 constant 0.51961803436279

In this case the constant comparison will be faster.

The performance improvements where added to PHP5.4 and here is the RFC https://wiki.php.net/rfc/performanceimprovements

But note that constants generally make for better refactor able code and therefor better maintainable. Furthermore the performance hit is negligible

function doSomethingString() {
    return "OfflineState";
}

const OFFLINE_STATE = 1;
function doSomethingConstant() {
    return OFFLINE_STATE;
}

function dummy() {}

// String
echo('string' . PHP_EOL);
$start = microtime(true);
for($i = 0; $i < 10000000; $i++) {
    switch(doSomethingString()) {
        case "OfflineState":
            dummy();
            break;
    }
}
echo(PHP_EOL);
$end = microtime(true);
echo($end - $start);
echo(PHP_EOL);


//Constant
echo('constant' . PHP_EOL);
$start = microtime(true);
for($i = 0; $i < 10000000; $i++) {
    switch(doSomethingConstant()) {
        case OFFLINE_STATE:
            dummy();
            break;
    }
}
echo(PHP_EOL);
$end = microtime(true);
echo($end - $start);
echo(PHP_EOL);

My php version:

PHP 7.2.8-1+ubuntu18.04.1+deb.sury.org+1 (cli) (built: Jul 25 2018 10:52:19) ( NTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.2.0, Copyright (c) 1998-2018 Zend Technologies
    with Zend OPcache v7.2.8-1+ubuntu18.04.1+deb.sury.org+1, Copyright (c) 1999-2018, by Zend Technologies

Answer 3

i know that strings comparison can be quite slow

This is not really accurate within the context of a web app.

A string comparison takes microseconds.

Loading a web page, accessing a database, etc take milliseconds or seconds (thousands of times longer).

So this kind of micro-optimization is hardly ever worth it. Instead you should focus on what makes the clearest, most maintainable code.

Performance optimization of your code comes into play later, if you are looping over millions of items or serving thousands of requests per second.

if the PHP parser still needs to read the whole constant name before comparing, is not it the same than using a string, or a variable?

Using constants (and having the values of the constants be numbers rather than strings) is probably slightly faster than using string values, and probably clearer and maintainable code also. But again, in the course of loading a web page, you will not be able to tell a difference.