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?
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
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)
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 php et php comportement peut être différent de c , mais je vais utiliser un petit c programme pour démontrer comment le compilateur se comporte en utilisant logique et Bitwise et .
supposons que nous ayons un programme dans c 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.
&&
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.)