Différence entre & et && en PHP

les autres réponses sont correctes, mais incomplètes. Une caractéristique clé de la logique et est qu'il court-circuits, c'est-à-dire le deuxième opérande n'est évalué que si nécessaire. Le manuel PHP donne l'exemple suivant pour illustrer:

$a = (false && foo());

foo ne sera jamais appelé, puisque le résultat est connu après avoir évalué false. D'autre part avec

$a = (false & foo());

foo sera appelé (aussi, le résultat est 0 plutôt que faux.)

 

AND operation: 

& -> will do the bitwise AND operation , it just doing operation based on
      the bit values. 
&&   -> It will do logical AND operation. It is just the check the values is 
       true or false. Based on the boolean value , it will evaluation the 
       expression 

comme disent les autres, un seul & est un peu sage. Il convertit fondamentalement la valeur de gauche en sa représentation de bits, et le côté de droite en représentation de bits aussi, puis exécute logique et entre eux et affiche le résultat.

Double && est vrai ou faux, (dans certaines langues 0 ou 1) si les deux côtés gauche et droite sont vrai (ou non-zéro).

j'ajouterais aussi que ce N'est pas seulement en PHP. Il est comme cela dans beaucoup d'autres langues aussi bien, comme C, Java, Ruby , etc.

la réponse de Matthieu sur la façon dont logique et && opérateur est la plus grande différence; la comparaison logique s'arrêtera quand il trouvera quelque chose qui casse la chaîne. En outre, une autre grande différence est le type de résultat/valeur .

tl; dr

en utilisant le logique et && , il sera toujours retourner un type booléen / valeur , true ou false .

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

il est important d'utiliser type booléen / valeurs lors de la restitution d'une fonction avec un résultat logique, parce que quelqu'un peut utiliser le opérateur de comparaison identique === pour comparer les résultats (ce qui est élevé susceptible d'arriver) et il échouera si vous utilisez quelque chose comme ceci:

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

N'utilisez jamais Bitwise et & quand vous avez besoin de faire une comparaison logique et surtout quand vous retournez des valeurs à partir de fonctions avec des résultats logiques. Utilisez plutôt le logique et && :

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

lors de la comparaison des caractères, logique et && résultera toujours en true , même avec NUL caractère, à moins que si elle est convertie à un entier:

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

si vous utilisez le Bitwise et & avec des caractères, il en résultera le caractère correspondant à l'opération Bitwise et entre ces deux caractères:

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

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

méfiez-vous de l'usage du Bitwise et & lorsqu'on utilise avec des types autres que entiers et caractères (qui sont des types spéciaux d'entiers). Par exemple, si vous l'utilisez avec des nombres réels float / double , alors il peut en résulter à 0 même si les deux opérandes sont pas "1519340920 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)

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

if (a & b)
    c = 3;

if (a && b)
    c = 4;

:0229  mov <a>, 0
:0230  mov <b>, 1
:0237  mov <c>, 2
// if (a & b) begins
:023E  mov eax, <a>
:0241  and eax, <b>        // 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 <c>, 3          //    |  or set c = 3
// if (a && b) begins            |
:024F  cmp <a>, 0          // <---  compare a to 0 and sets ZeroFlag if difference is 0
:0253  je 0262             // >---  Jump if ZeroFlag is set (a == 0)
:0255  cmp <b>, 0          //    |  compare b to 0 and sets ZeroFlag if differemce is 0
:0259  je 0262             //    |  >--- Jump if ZeroFlag is set (b == 0)
:025B  mov <c>, 4          //    |     | or set c = 4
:0262  <program continues> // <---  <---