What is the practical use of bitwise operators in PHP?

PHP is a general purpose language, it can be used for potentially anything. Situations arise when even a high-level language needs to interact with binary numbers and bitwise operations. For example:

• interpret a file with binary format
• Do network communication, and the protocol is binary
• compact representation of multiple states ,flags, or yes/no options. A number from 0 to 255 can represent 8 Independent States ,and " read" each bit is faster using bitwise operators
• encryption, calculation of hashes or checking digits. With bitwise operators, one can implement these things in pure PHP, otherwise it would be necessary to write in C.

Here is an interesting question, but I totally disagree with the statement of your question Where You mention:

... in compiled languages,such as C/C++, it is easier to understand due to the higher level of hardware contact ...

It is certain that this is only one of several applications of bit a bit, however, in PHP and despite being a language of script developed in C, it does not leave and depending on the need of each implementation to be necessary all the operability bitwise.

The best answer I can give besides evoking academic situations is to indicate some practice, this to escape a little from the basic answer of administration permissions that are wrong on many levels and have nothing to do with the real world of a programmer.

So here's an applicability case:

Imagine a unique identifier for an online service where any user will have to have a unique number on the service. This will have your registration on one of the data servers that will be several service support. To shuffle further, the handle must still contain a style of check digit for instant validation.

one way to achieve this is bitwise.

Instead of having three fields, we can have a single field that aggregates all of them. Even the three fields would not meet the requirement to have a unique identifier.

Imagine a 32-bit integer, but the same is valid for 64 bits.

Thus and taking into account the limit of 32 bits (fictitious scheme only to portray what I expose) we can group the bits as follows:

00000000 - 0000000000000000000 - 0000 = valor único num inteiro de 32 bits
    |               |              |
    |               |              |-- 4 bits - até 15 valor do check-digit
    |               |
    |               |-- 20 bits - até 1.048.575 valor único na tabela do srv
    |              
    |--- 8 bits - índice do servidor até 255 servidores

Thus we can combine these three distinct fields into a single integer, thus obtaining a number always unique and of extra functionality. I think expose well, that also in PHP this type of operations are very necessary.

In this case I put and as an example imagine that the user delivers their unique code to the service. Immediately it is possible to validate the integrity of the identifier delivered, then immediately point to the server where your registration is located and obtain your data. This is in a way, how some systems work.

This field / structure type is named bit field. From wiki get:

A bit field is a term used in computer programming to store multiple, logical, neighboring bits, where each of the sets of bits, and single bits can be addressed. A bit field is most commonly used to represent integral types of known, fixed bit-width.

There are many advantages in the use of bit fields and in real cases they are widely used.

I found it indispensable to use bitwise in this algorithm. It is very quick to find combinations of values over a value. In case I'm searching 17.2 the algorithm will return me the key b and c + d...

        $values     = array('a' => '12.8', 'b' => '17.2', 'c' => '10.2', 'd' => '5');
        $target     = explode('.', number_format(17.2, 2)); // VALOR ESPERADO
        $len        = count($values);


        for($i = 1; $i < pow(2, $len); $i++){
            $soma   = 0;
            $set    = array();
            for($j = 0; $j < $len; $j++){
                if(1 << $j & $i){ // MAGICA
                    $set[] = $j;
                    $soma += $values[$j];
                }
            }

            $soma   = explode('.', number_format($soma, 2));
            if($soma[0] == $target[0] && $soma[1] == $target[1]){
                foreach($set as $pos){
                    $ids[] = $values[$pos];
                }
                return $ids;
            }
        }