Difference between & and && in PHP

Question

I am confused with & and &&. I have two PHP books. One says that they are same, but the another says they are different. I thought they

Answer 1

Matthew's answer about how Logical And && operator is the biggest difference; logical comparison will stop when it will find something that breaks the chain. In addition, one more big difference it the result type/value.

tl;dr

By using the Logical And &&, it will always return a Boolean type/value, true or false.

false & 1 // int(0)
false && 1 // bool(false)

It is important to use Boolean type/values when returning a function with a logical result, because someone can use the Identical comparison operator === to compare the results (which is high likely to happen) and it will fail if you use something like this:

(false & 1) === false // bool(false)
(true & true) === true // bool(false)

Never use Bitwise And & when you need to make a logical comparison and especially when returning values from functions with logical results. Instead use the Logical And &&:

(false && 1) === false // bool(true)
(true && true) === true // bool(true)

When comparing characters, Logical And && will always result to true, even with NUL character, unless if it's converted to an integer:

'A' && 'B' // bool(true)
'A' && 0 // bool(false)
'A' && '\0' // bool(true)
'A' && (int)'\0' // bool(false)

If you use the Bitwise And & with characters, it will result the character corresponding to the Bitwise And operation between those two characters:

'A' & 'B' // string(1) "@"

01000001 // ASCII 'A'
&
01000010 // ASCII 'B'
=
01000000 // ASCII '@'

Beware the usage of the Bitwise And & when using with types other than Integers and Characters (which are special kind of integers). For example, if you use it with real numbers float/double, then it can result to 0 even if both operands are NOT 0:

1.0 & 1.0 // int(1)
2.0 & 1.0 // int(0)

1.0 && 1.0 // bool(true)
2.0 && 1.0 // bool(true)

In addition, if we go at assembly instructions level, we can see that difference and how the compiler manages to handle so the Logical And && uses cmp , 0 to compare and does not continue executing if one operand fails; Bitwise And uses and , to make a bitwise result and then test if it's of 0 value. I know this question is tagged for php and php behavior may be different than c, but I'll use a small c program to demonstrate how compiler behaves when using Logical and Bitwise And.

Let's assume we have a program in c that uses both Bitwise and Logical And:

int a = 0;
int b = 1;
int c = 2;

if (a & b)
    c = 3;

if (a && b)
    c = 4;

The compiler will generate the following assembly opcodes (W32Dasm result for x86; I have changed the memory addresses with names for simplicity and to be more understandable):

:0229  mov , 0
:0230  mov , 1
:0237  mov , 2
// if (a & b) begins
:023E  mov eax, 
:0241  and eax,         // a bitwise and b, result stored to eax
:0244  test eax, eax       // test eax and set ZeroFlag if equals to 0
:0246  je 024F             // >---  Jump if ZeroFlag is set
:0248  mov , 3          //    |  or set c = 3
// if (a && b) begins            |
:024F  cmp , 0          // <---  compare a to 0 and sets ZeroFlag if difference is 0
:0253  je 0262             // >---  Jump if ZeroFlag is set (a == 0)
:0255  cmp , 0          //    |  compare b to 0 and sets ZeroFlag if differemce is 0
:0259  je 0262             //    |  >--- Jump if ZeroFlag is set (b == 0)
:025B  mov , 4          //    |     | or set c = 4
:0262   // <---  <---

The compiler not only uses different instructions to compare between the Logical and Bitwaise And, but at the line :0253 in if (a && b) logical comparison, we see that if a == 0 then it jumps and does not check for the rest operands.

So, I disagree to animuson's comment:

They are both the same thing, they're just used for two different things to accomplish the same task. – animuson Mar 4 '10 at 1:42

They are not the same thing and both are/(should be) used for specific tasks depending on the programs' logic/flow.