# Bitwise Operator

What is a bit? A bit is a representation of 1 or 0. Basically OFF(0) and ON(1)

What is a byte? A byte is made up of 8 bits and the highest value of a byte is 255, which would mean every bit is set. We will look at why a byte's maximum value is 255.

``````-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|
-------------------------------------------
``````

This representation of 1 Byte

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255 (1 Byte)

# A few examples for better understanding

## The "AND" operator: `&`

``````\$a =  9;
\$b = 10;
echo \$a & \$b;
``````

This would output the number 8. Why? Well let's see using our table example.

``````-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|
-------------------------------------------
|      \$a    |   0|  0|  0|  0| 1| 0| 0| 1|
-------------------------------------------
|      \$b    |   0|  0|  0|  0| 1| 0| 1| 0|
-------------------------------------------
|      &     |   0|  0|  0|  0| 1| 0| 0| 0|
-------------------------------------------
``````

So you can see from the table the only bit they share together is the 8 bit.

Second example

``````\$a =  36;
\$b = 103;
echo \$a & \$b; // This would output the number 36.
\$a = 00100100
\$b = 01100111
``````

The two shared bits are 32 and 4, which when added together return 36.

## The "Or" operator: `|`

``````\$a =  9;
\$b = 10;
echo \$a | \$b;
``````

This would output the number 11. Why?

``````-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|
-------------------------------------------
|      \$a    |   0|  0|  0|  0| 1| 0| 0| 1|
-------------------------------------------
|      \$b    |   0|  0|  0|  0| 1| 0| 1| 0|
-------------------------------------------
|      |     |   0|  0|  0|  0| 1| 0| 1| 1|
-------------------------------------------
``````

You will notice that we have 3 bits set, in the 8, 2, and 1 columns. Add those up: 8+2+1=11.

-> meaning question

### What is this?

This is a collection of questions that come up every now and then about syntax in PHP. This is also a Community Wiki, so everyone is invited to participate in maintaining this list.

### Why is this?

It used to be hard to find questions about operators and other syntax tokens.¹
The main idea is to have links to existing questions on , so it's easier for us to reference them, not to copy over content from the PHP Manual.

¹ Note: Since January 2013, does support special characters. Just surround the search terms by quotes, e.g. `[php] "==" vs "==="`

### What should I do here?

If you have been pointed here by someone because you have asked such a question, please find the particular syntax below. The linked pages to the PHP manual along with the linked questions will likely answer your question then. If so, you are encouraged to upvote the answer. This list is not meant as a substitute to the help others provided.

## The List

If your particular token is not listed below, you might find it in the List of Parser Tokens.

`&` Bitwise Operators or References

`=&` References

`&=` Bitwise Operators

`&&` Logical Operators

`%` Arithmetic Operators

`!!` Logical Operators

`@` Error Control Operators

`?:` Ternary Operator

`??` Null Coalesce Operator (since PHP 7)

`::` Scope Resolution Operator

`\` Namespaces

`->` Classes And Objects

`=>` Arrays

`^` Bitwise Operators

`>>` Bitwise Operators

`<<` Bitwise Operators

`<<<` Heredoc or Nowdoc

`=` Assignment Operators

`==` Comparison Operators

`===` Comparison Operators

`!==` Comparison Operators

`!=` Comparison Operators

`<>` Comparison Operators

`<=>` Comparison Operators (since PHP 7.0)

• Spaceship (three way comparison) operator

`|` Bitwise Operators

`||` Logical Operators

`~` Bitwise Operators

`+` Arithmetic Operators, Array Operators

`+=` and `-=` Assignment Operators

`++` and `--` Incrementing/Decrementing Operators

`.=` Assignment Operators

`.` String Operators

`,` Function Arguments

`,` Variable Declarations

`\$\$` Variable Variables

``` Execution Operator

`<?=` Short Open Tags

`[]` Arrays (short syntax since PHP 5.4)

`<?` Opening and Closing tags

`...` Argument unpacking (since PHP 5.6)

`**` Exponentiation (since PHP 5.6)

`#` One-line shell-style comment

``````Syntax    Name             Description

x == y    Equality         True if x and y have the same key/value pairs
x != y    Inequality       True if x is not equal to y
x === y   Identity         True if x and y have the same key/value pairs
in the same order and of the same types
x !== y   Non-identity     True if x is not identical to y
++ x      Pre-increment    Increments x by one, then returns x
x ++      Post-increment   Returns x, then increments x by one
-- x      Pre-decrement    Decrements x by one, then returns x
x --      Post-decrement   Returns x, then decrements x by one
x and y   And              True if both x and y are true x=6 y=3
(x < 10 and y > 1) returns true
x && y    And              True if both x and y are true x=6 y=3
(x < 10 && y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"
``````

# `<=>` Spaceship Operator

The spaceship operator `<=>` is the latest comparison operator added in PHP 7. It is a non-associative binary operator with the same precedence as equality operators (`==`, `!=`, `===`, `!==`). This operator allows for simpler three-way comparison between left-hand and right-hand operands.

The operator results in an integer expression of:

• `0` when both operands are equal
• Less than `0` when the left-hand operand is less than the right-hand operand
• Greater than `0` when the left-hand operand is greater than the right-hand operand

e.g.

``````1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1
``````

A good practical application of using this operator would be in comparison type callbacks that are expected to return a zero, negative, or positive integer based on a three-way comparison between two values. The comparison function passed to `usort` is one such example.

### Before PHP 7 you would write...

``````\$arr = [4,2,1,3];

usort(\$arr, function (\$a, \$b) {
if (\$a < \$b) {
return -1;
} elseif (\$a > \$b) {
return 1;
} else {
return 0;
}
});
``````

### Since PHP 7 you can write...

``````\$arr = [4,2,1,3];

usort(\$arr, function (\$a, \$b) {
return \$a <=> \$b;
});
``````

# An overview of operators in PHP:

## Logical Operators:

• \$a && \$b : TRUE if both \$a and \$b are TRUE.
• \$a || \$b : TRUE if either \$a or \$b is TRUE.
• \$a xor \$b : TRUE if either \$a or \$b is TRUE, but not both.
• ! \$a : TRUE if \$a is not TRUE.
• \$a and \$b : TRUE if both \$a and \$b are TRUE.
• \$a or \$b : TRUE if either \$a or \$b is TRUE.

## Comparison operators:

• \$a == \$b : TRUE if \$a is equal to \$b after type juggling.
• \$a === \$b : TRUE if \$a is equal to \$b, and they are of the same type.
• \$a != \$b : TRUE if \$a is not equal to \$b after type juggling.
• \$a <> \$b : TRUE if \$a is not equal to \$b after type juggling.
• \$a !== \$b : TRUE if \$a is not equal to \$b, or they are not of the same type.
• \$a < \$b : TRUE if \$a is strictly less than \$b.
• \$a > \$b : TRUE if \$a is strictly greater than \$b.
• \$a <= \$b : TRUE if \$a is less than or equal to \$b.
• \$a >= \$b : TRUE if \$a is greater than or equal to \$b.
• \$a <=> \$b : An integer less than, equal to, or greater than zero when \$a is respectively less than, equal to, or greater than \$b. Available as of PHP 7.
• \$a ? \$b : \$c : if \$a return \$b else return \$c (ternary operator)
• \$a ?? \$c : Same as \$a ? \$a : \$c (null coalescing operator - requires PHP>=7)

## Arithmetic Operators:

• -\$a : Opposite of \$a.
• \$a + \$b : Sum of \$a and \$b.
• \$a - \$b : Difference of \$a and \$b.
• \$a * \$b : Product of \$a and \$b.
• \$a / \$b : Quotient of \$a and \$b.
• \$a % \$b : Remainder of \$a divided by \$b.
• \$a ** \$b : Result of raising \$a to the \$b'th power (introduced in PHP 5.6)

## Incrementing/Decrementing Operators:

• ++\$a : Increments \$a by one, then returns \$a.
• \$a++ : Returns \$a, then increments \$a by one.
• --\$a : Decrements \$a by one, then returns \$a.
• \$a-- : Returns \$a, then decrements \$a by one.

## Bitwise Operators:

• \$a & \$b : Bits that are set in both \$a and \$b are set.
• \$a | \$b : Bits that are set in either \$a or \$b are set.
• \$a ^ \$b : Bits that are set in \$a or \$b but not both are set.
• ~ \$a : Bits that are set in \$a are not set, and vice versa.
• \$a << \$b : Shift the bits of \$a \$b steps to the left (each step means "multiply by two")
• \$a >> \$b : Shift the bits of \$a \$b steps to the right (each step means "divide by two")

## String Operators:

• \$a . \$b : Concatenation of \$a and \$b.

## Array Operators:

• \$a + \$b : Union of \$a and \$b.
• \$a == \$b : TRUE if \$a and \$b have the same key/value pairs.
• \$a === \$b : TRUE if \$a and \$b have the same key/value pairs in the same order and of the same types.
• \$a != \$b : TRUE if \$a is not equal to \$b.
• \$a <> \$b : TRUE if \$a is not equal to \$b.
• \$a !== \$b : TRUE if \$a is not identical to \$b.

## Assignment Operators:

• \$a = \$b : The value of \$b is assigned to \$a
• \$a += \$b : Same as \$a = \$a + \$b
• \$a -= \$b : Same as \$a = \$a - \$b
• \$a *= \$b : Same as \$a = \$a * \$b
• \$a /= \$b : Same as \$a = \$a / \$b
• \$a %= \$b : Same as \$a = \$a % \$b
• \$a **= \$b : Same as \$a = \$a ** \$b
• \$a .= \$b : Same as \$a = \$a . \$b
• \$a &= \$b : Same as \$a = \$a & \$b
• \$a |= \$b : Same as \$a = \$a | \$b
• \$a ^= \$b : Same as \$a = \$a ^ \$b
• \$a <<= \$b : Same as \$a = \$a << \$b
• \$a >>= \$b : Same as \$a = \$a >> \$b

### Note

`and` operator and `or` operator have lower precedence than assignment operator `=`.

This means that `\$a = true and false;` is equivalent to `(\$a = true) and false`.

In most cases you will probably want to use `&&` and `||`, which behave in a way known from languages like C, Java or JavaScript.

`{}` Curly braces

And some words about last post

``````\$x[4] = 'd'; // it works
\$x{4} = 'd'; // it works

\$echo \$x[4]; // it works
\$echo \$x{4}; // it works

\$x[] = 'e'; // it works
\$x{} = 'e'; // does not work

\$x = [1, 2]; // it works
\$x = {1, 2}; // does not work

echo "\${x[4]}"; // it works
echo "\${x{4}}"; // does not work

echo "{\$x[4]}"; // it works
echo "{\$x{4}}"; // it works
``````

Null coalescing operator (??)

This operator has been added in PHP 7.0 for the common case of needing to use a ternary operator in conjunction with `isset()`. It returns its first operand if it exists and is not `NULL`; otherwise it returns its second operand.

``````<?php
// Fetches the value of \$_GET['user'] and returns 'nobody'
// if it does not exist.
// This is equivalent to:
\$username = isset(\$_GET['user']) ? \$_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of \$_GET['user'], \$_POST['user'], and
// 'nobody'.
\$username = \$_GET['user'] ?? \$_POST['user'] ?? 'nobody';
?>
``````

Question:

What does "&" mean here in PHP?

# PHP "&" operator

Makes life more easier once we get used to it..(check example below carefully)

& usually checks bits that are set in both \$a and \$b are set.

have you even noticed how these calls works?

``````   error_reporting(E_ERROR | E_WARNING | E_PARSE);
error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
error_reporting(E_ALL & ~E_NOTICE);
error_reporting(E_ALL);
``````

So behind all above is game of bitwise operator and bits.

One usefull case of these is easy configurations like give below, so a single integer field can store thousands of combos for you.

Most people have already read the docs but didn't reliase the real world use case of these bitwise operators.

# Example That you 'll love

``````<?php

class Config {

// our constants must be 1,2,4,8,16,32,64 ....so on
const TYPE_CAT=1;
const TYPE_DOG=2;
const TYPE_LION=4;
const TYPE_RAT=8;
const TYPE_BIRD=16;
const TYPE_ALL=31;

private \$config;

public function __construct(\$config){
\$this->config=\$config;

if(\$this->is(Config::TYPE_CAT)){
echo 'cat ';
}
if(\$this->is(Config::TYPE_DOG)){
echo 'dog ';
}
if(\$this->is(Config::TYPE_RAT)){
echo 'rat ';
}
if(\$this->is(Config::TYPE_LION)){
echo 'lion ';
}
if(\$this->is(Config::TYPE_BIRD)){
echo 'bird ';
}
echo "\n";
}

private function is(\$value){
return \$this->config & \$value;
}
}

new Config(Config::TYPE_ALL);
// cat dog rat lion bird
new Config(Config::TYPE_BIRD);
//bird
new Config(Config::TYPE_BIRD | Config::TYPE_DOG);
//dog bird
new Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);
//rat lion bird
``````

`==` is used for check equality without considering variable data-type

`===` is used for check equality for both the variable value* and **data-type

# Example

`\$a = 5`

1. `if (\$a == 5)` - will evaluate to true

2. `if (\$a == '5')` - will evaluate to true, because while comparing this both value php internally convert that string value into integer and then compare both values

3. `if (\$a === 5)` - will evaluate to true

4. `if (\$a === '5')` - will evaluate to false, because value is 5, but this value 5 is not an integer.

### Tags

php   operators   symbols   php-5.3