tutorial sirve que programacion para lenguaje descargar caracteristicas php

sirve - php tutorial



Diferencia entre & y &&& en PHP (6)

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.

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?

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

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.

&& se realiza & ejecuta en operandos reducidos a 1 o 0 .

(En otras palabras, && es un operador bitwise bajo la advertencia de que cambia sus operandos. Es decir, las operaciones lógicas son un subconjunto de operaciones bitwise).

& 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

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