'AND' vs '&&' como operador

Tengo una base de código donde los desarrolladores decidieron usar ANDy en ORlugar de &&y ||.

Sé que hay una diferencia en la precedencia de los operadores ( &&va antes and), pero con el marco dado ( PrestaShop para ser precisos) claramente no es una razón.

¿Qué versión está utilizando? ¿Es andmás legible que &&? ¿O no hay diferencia?

Si usas ANDy OR, eventualmente te tropezarás con algo como esto:

$this_one = true;
$that = false;

$truthiness = $this_one and $that;

¿Quieres adivinar lo que $truthinesses igual?

Si dijiste false... bzzzt, lo siento, ¡mal!

$truthinessarriba tiene el valor true. ¿Por qué? =tiene mayor precedencia que and. La adición de paréntesis para mostrar el orden implícito aclara esto:

($truthiness = $this_one) and $that

Si usó en &&lugar del andprimer ejemplo de código, funcionaría como se esperaba y sería false.

Como se discute en los comentarios a continuación, esto también funciona para obtener el valor correcto, ya que los paréntesis tienen mayor prioridad que =:

$truthiness = ($this_one and $that)

Dependiendo de cómo se use, puede ser necesario e incluso útil. http://php.net/manual/en/language.operators.logical.php

// "||" has a greater precedence than "or"

// The result of the expression (false || true) is assigned to $e
// Acts like: ($e = (false || true))
$e = false || true;

// The constant false is assigned to $f and then true is ignored
// Acts like: (($f = false) or true)
$f = false or true;

Pero en la mayoría de los casos parece más un gusto de desarrollador, como cada vez que ocurre esto que he visto en el marco de CodeIgniter como @Sarfraz ha mencionado.

Por seguridad, siempre hago paréntesis entre mis comparaciones y las espacio. De esa manera, no tengo que depender de la precedencia del operador:

if( 
    ((i==0) && (b==2)) 
    || 
    ((c==3) && !(f==5)) 
  )

La precedencia difiere entre && y y (&& tiene mayor precedencia que y), algo que causa confusión cuando se combina con un operador ternario. Por ejemplo,

$predA && $predB ? "foo" : "bar"

devolverá una cadena mientras que

$predA and $predB ? "foo" : "bar"

devolverá un booleano .

Dado que andtiene una precedencia inferior a la =que puede usar en la asignación de condiciones:

if ($var = true && false) // Compare true with false and assign to $var
if ($var = true and false) // Assign true to $var and compare $var to false

Permítanme explicar la diferencia entre “y” - “&&” - "&".

"&&" y "y" ambos son operaciones lógicas AND y hacen lo mismo, pero la precedencia del operador es diferente.

La precedencia (prioridad) de un operador especifica cuán "estrechamente" une dos expresiones. Por ejemplo, en la expresión 1 + 5 * 3, la respuesta es 16 y no 18 porque el operador de multiplicación ("*") tiene mayor prioridad que el operador de suma ("+").

Si los mezcla en una sola operación, podría obtener resultados inesperados en algunos casos , siempre recomiendo usar &&, pero esa es su elección.

Por otro lado, "&" es una operación AND a nivel de bits . Se utiliza para la evaluación y manipulación de bits específicos dentro del valor entero.

Ejemplo si lo haces (14 y 7) el resultado sería 6.

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

¿Qué versión está utilizando?

Si los estándares de codificación para la base de código particular para la que escribo el código especifican qué operador debe usarse, definitivamente lo usaré. Si no es así, y el código dicta cuál debe usarse (no es frecuente, se puede solucionar fácilmente), entonces lo usaré. De lo contrario, probablemente && .

¿Es 'y' más legible que '&&'?

¿Es más legible para usted ? ¡La respuesta es sí y no dependiendo de muchos factores, incluido el código que rodea al operador y, de hecho, la persona que lo lee!

|| hay ~ diferencia?

Si. Ver operadores lógicos para ||y operadores bit a bit para ~.

Supongo que es cuestión de gustos, aunque (por error) mezclarlos podría causar algunos comportamientos no deseados:

true && false || false; // returns false

true and false || false; // returns true

Por lo tanto, usando && y || es más seguro porque tienen la más alta prioridad. En cuanto a la legibilidad, diría que estos operadores son lo suficientemente universales.

ACTUALIZACIÓN : Sobre los comentarios que dicen que ambas operaciones devuelven falso ... bueno, de hecho el código anterior no devuelve nada, lamento la ambigüedad. Para aclarar: el comportamiento en el segundo caso depende de cómo se use el resultado de la operación. Observe cómo la precedencia de los operadores entra en juego aquí:

var_dump(true and false || false); // bool(false)

$a = true and false || false; var_dump($a); // bool(true)

La razón $a === truees porque el operador de asignación tiene prioridad sobre cualquier operador lógico, como ya se explicó muy bien en otras respuestas.

Aquí hay un pequeño ejemplo de contador:

$a = true;
$b = true;
$c = $a & $b;
var_dump(true === $c);

salida:

bool(false)

Diría que este tipo de error tipográfico es mucho más probable que cause problemas insidiosos (de la misma manera que =vs ==) y es mucho menos probable que se note que adn/ rotypos, que marcará como errores de sintaxis. También encuentro y / o es mucho más fácil de leer. FWIW, la mayoría de los marcos PHP que expresan una preferencia (la mayoría no) especifican y / o. Tampoco me he encontrado con un caso real y no inventado en el que hubiera importado.

Otro buen ejemplo usando ifdeclaraciones sin =operaciones de asignación.

if (true || true && false); // is the same as:
if (true || (true && false)); // TRUE

y

if (true || true AND false); // is the same as:
if ((true || true) && false); // FALSE

porque ANDtiene una precedencia más baja y, por lo tanto, ||una precedencia más alta.

Estos son diferentes en los casos de true, false, falsey true, true, false. Consulte https://ideone.com/lsqovs para obtener un ejemplo detallado.