caracteristicas - Diferencia entre & y &&& en PHP




descargar tutorial (6)

Estoy confundido con & && . Tengo dos libros de PHP. Uno dice que son iguales, pero el otro dice que son diferentes. Pensé que también son iguales.

¿No son los mismos?


Answers

Como dicen los demás, un single & es poco sabio. Básicamente, convierte el valor de la mano izquierda en su representación de bits, y el lado derecho también en la representación de bits, luego ejecuta un AND lógico entre ellos y genera el resultado.

Double && es verdadero o falso, (en algunos idiomas 0 o 1) si tanto el lado izquierdo como el derecho son verdaderos (o no cero).

También agregaría que esto no es solo en PHP. Es así en muchos otros muchos idiomas, como C, Java, Ruby , etc.


& es bitwise Y. Ver Operadores de Bitwise . Asumiendo que haces 14 & 7 :

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

&& es lógico AND. Ver Operadores Lógicos . Considera esta tabla de verdad:

 $a     $b     $a && $b
false  false    false
false  true     false
true   false    false
true   true     true

La respuesta de Matthew sobre cómo el operador lógico y && es la mayor diferencia; la comparación lógica se detendrá cuando encuentre algo que rompa la cadena. Además, una gran diferencia más es el resultado tipo / valor .

tl; dr

Al utilizar Logical And && , siempre devolverá un tipo / valor booleano , true o false .

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

Es importante usar valores / tipos booleanos cuando se devuelve una función con un resultado lógico, porque alguien puede usar el operador de comparación idéntico === para comparar los resultados (que es muy probable que ocurra) y fallará si usa algo como esta:

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

Nunca use Bitwise Y & cuando necesite hacer una comparación lógica y especialmente cuando devuelva valores de funciones con resultados lógicos. En su lugar, utilice la lógica y && :

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

Al comparar caracteres, Logical And && siempre resultará true , incluso con el carácter NUL , a menos que se convierta en un entero:

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

Si usa los caracteres Bitwise And & con, resultará el carácter correspondiente a la operación Bitwise And entre esos dos caracteres:

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

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

Tenga cuidado con el uso de Bitwise Y & cuando se utiliza con tipos distintos de enteros y caracteres (que son tipos especiales de enteros). Por ejemplo, si lo usa con números reales float / double , entonces puede resultar en 0 incluso si ambos operandos NO son 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)

Además, si vamos al nivel de instrucciones de ensamblaje, podemos ver esa diferencia y cómo el compilador se las arregla para manejar, por lo que Logical And && utiliza cmp <var>, 0 para comparar y no continúa ejecutándose si falla un operando; Bitwise And usa and <var1>, <var2> para obtener un resultado a nivel de bit y luego prueba si es de valor 0 . Sé que esta pregunta está etiquetada para el comportamiento de php y php puede ser diferente de c , pero usaré un pequeño programa c para demostrar cómo se comporta el compilador cuando se usa Logical y Bitwise And .

Supongamos que tenemos un programa en c que usa tanto Bitwise como Lógico :

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

if (a & b)
    c = 3;

if (a && b)
    c = 4;

El compilador generará los siguientes códigos de operación de ensamblaje ( resultado de W32Dasm para x86 ; he cambiado las direcciones de memoria con nombres de <variable> para simplificar y ser más comprensibles):

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

El compilador no solo usa instrucciones diferentes para comparar entre Logical y Bitwaise And , sino que en la línea :0253 en la comparación lógica if (a && b) , vemos que si a == 0 entonces salta y no verifica el resto operandos

Entonces, no estoy de acuerdo con el comentario de animuson :

Ambos son lo mismo, solo se usan para dos cosas diferentes para lograr la misma tarea. - Animuson Mar 4 '10 a las 1:42.

No son lo mismo y ambos son / (deberían ser) utilizados para tareas específicas dependiendo de la lógica / flujo de los programas.


 

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 

Las otras respuestas son correctas, pero incompletas. Una característica clave de AND lógico es que cortocircuita, lo que significa que el segundo operando solo se evalúa si es necesario. El manual de PHP da el siguiente ejemplo para ilustrar:

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

foo nunca será llamado, ya que el resultado es conocido después de evaluar falso. Por otro lado con

$a = (false & foo());

foo llamará foo (también, el resultado es 0 en lugar de falso).


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"




php