Différence entre & et && en PHP

je suis confondu avec & et && . J'ai deux PHP livres. On dit qu'ils sont les mêmes, mais l'autre dit qu'ils sont différents. Je pensais qu'ils sont les mêmes.

ne sont-ils pas les mêmes?

41
php
demandé sur Peter Mortensen 2010-03-04 04:39:28

6 réponses

& est au niveau du bit. Voir Opérateurs Bitwise . En supposant que vous faites 14 & 7 :

    14 = 1110
     7 = 0111
    ---------
14 & 7 = 0110 = 6

&& est le ET logique. Voir Opérateurs Logiques . Considérez cette table de vérité:

 $a     $b     $a && $b
false  false    false
false  true     false
true   false    false
true   true     true
76
répondu cletus 2010-03-04 01:40:29

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.)

45
répondu Matthew Flaschen 2010-10-18 23:11:57
 

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 
5
répondu Pavunkumar 2010-03-04 06:26:10

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.

3
répondu umar 2015-12-01 18:46:38

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)

en outre, si nous allons au niveau des instructions d'assemblage, nous pouvons voir cette différence et comment le compilateur parvient à gérer de sorte que le logique et && utilise cmp <var>, 0 Bitwise et utilise and <var1>, <var2> pour faire un résultat bitwise et ensuite tester si elle est de la valeur 0 . Je sais que cette question est marquée pour et comportement peut être différent de , mais je vais utiliser un petit programme pour démontrer comment le compilateur se comporte en utilisant logique et Bitwise et .

supposons que nous ayons un programme dans qui utilise à la fois Bitwise et Logical et :

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

if (a & b)
    c = 3;

if (a && b)
    c = 4;

le compilateur générera les opcodes d'assemblage suivants ( w32dasm résultat pour x86 ; j'ai changé les adresses de mémoire avec <variable> noms pour la simplicité et pour être plus compréhensible):

: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> // <---  <---

le compilateur utilise non seulement des instructions différentes pour comparer entre le logique et Bitwaise et , mais à la ligne :0253 dans if (a && b) comparaison logique, nous voyons que si a == 0 alors il saute et ne vérifie pas pour les opérandes de repos.

donc, je ne suis pas d'accord avec commentaire d'animuson :

Ils sont tous les deux la même chose, ils sont juste utilisés pour les deux choses à accomplir la même tâche. - animuson Mar 4 ' 10 à 1: 42

ils ne sont pas la même chose et tous les deux sont/ (devraient être) utilisés pour des tâches spécifiques selon la logique/le flux des programmes.

3
répondu Christos Lytras 2018-07-17 11:03:42

&& est & réalisée sur des opérandes réduit à 1 ou 0 .

(en d'autres termes, && est un opérateur bitwise sous réserve qu'il change ses opérandes. Qui est, les opérations logiques sont un sous-ensemble des opérations bit à bit.)

0
répondu blobbo 2017-07-31 21:46:48