Operadores
Un operador es algo que toma uno más valores (o
expresiones, en la jerga de programación) y produce otro valor (de modo que la
construcción en si misma se convierte en una expresión).
Los operadores se pueden agrupar de acuerdo con el número de valores que toman. Los operadores
unarios toman sólo un valor, por ejemplo ! (el
operador lógico de negación) o
++ (el
operador de incremento).
Los operadores binarios toman dos valores, como los familiares
operadores aritméticos
+ (suma) y - (resta), y la
mayoría de los operadores de PHP entran en esta categoría. Finalmente, hay sólo
un operador
ternario, ? :, el cual toma tres valores; usualmente a este se
le refiere simplemente como "el operador ternario" (aunque podría
tal vez llamarse más correctamente como el operador condicional).
Una lista completa de operadores de PHP sigue en la sección
Precedencia de Operadores.
La sección también explica la precedencia y asociatividad de los operadores, las cuales gobiernan
exactamente cómo son evaluadas expresiones que contienen varios diferentes
operadores.
Precedencia de operadores
La precedencia de un operador indica qué tan "estrechamente" se unen dos
expresiones juntas. Por ejemplo, en la expresión 1 +
5 * 3 , la respuesta es 16 y no
18 porque el operador de multiplicación ("*")
tiene una precedencia mayor que el operador de adición ("+").
Los paréntesis pueden ser usados para forzar la precedencia, si es necesario. Por
ejemplo: (1 + 5) * 3 se evalúa como
18.
Cuando los operadores tienen igual precedencia su asociatividad decide
cómo se agrupan. Por ejemplo "-" tiene asociatividad a izquierda, así
1 - 2 - 3 se agrupa como (1 - 2) - 3
y se evalúa a -4. "=", por otra parte, tiene
asociatividad a derecha, así $a = $b = $c se agrupa como
$a = ($b = $c).
Los operadores de igual precedencia que no son asociativos no pueden usarse
unos junto a otros, por ejemplo, 1 < 2 > 1 es
ilegal en PHP. La expresión 1 <= 1 == 1, por otro
lado, es legal, ya que el operador == tiene menos
precedencia que el operador <=.
El uso de paréntesis, incluso cuando no es estrictamente necesario, a menudo puede
aumentar la legibilidad del código haciendo grupos explícitamente en lugar de confiar
en la precedencia y asociatividad implícitas del operador.
La siguiente tabla enumera los operadores en orden de precedencia, con
los de más alta precedencia al inicio. Los operadores en la misma línea
tienen igual precedencia, en cuyo caso la asociatividad decide el agrupamiento.
Precedencia de operadoresAsociatividadOperadoresInformación adicionalno asociativoclonenewclone and newizquierda[arrayderecha**aritméticaderecha++--~(int)(float)(string)(array)(object)(bool)@
tipos e incremento/decremento
no asociativoinstanceof
tipos
derecha!
lógico
izquierda*/%
aritmética
izquierda+-.
aritmética&listendand;
stringizquierda<<>>
bit a bit
no asociativo<<=>>=
comparación
no asociativo==!====!==<><=>
comparación
izquierda&
bit a bit&listendand;
referenciasizquierda^
bit a bit
izquierda|
bit a bit
izquierda&&
lógico
izquierda||
lógico
derecha??
comparación
izquierda? :
ternario
derecha=+=-=*=**=/=.=%=&=|=^=<<=>>==>
asignación
izquierdaand
lógico
izquierdaxor
lógico
izquierdaor
lógico
izquierda,muchos usos
Asociatividad
$a = 5, $b = 5
?>
]]>
La precedencia y asociatividad de los operadores solamente determinan cómo
se agrupan las expresiones, no especifican un orden de evaluación. PHP no
especifica (en general) el orden en que se evalúa una expresión
y se debería evitar el código que se asume un orden específico de evaluación,
ya que el comportamiento puede cambiar entre versiones de PHP o dependiendo de
código circundante.
Orden de evaluación no definido
]]>
Aunque = tiene una precedencia menor que
la mayoría de los demás operadores, PHP aun permitirá expresiones
similares a lo siguiente: if (!$a = foo()),
en cuyo caso el valor devuelto de foo() es
puesto en $a.
Operadores aritméticos
¿Recuerda la aritmética básica de la escuela? Estos funcionan
igual que aquellos.
Operadores aritméticosEjemploNombreResultado-$aNegaciónOpuesto de $a.$a + $bAdiciónSuma de $a y $b.$a - $bSustracciónDiferencia de $a y $b.$a * $bMultiplicaciónProducto de $a y $b.$a / $bDivisiónCociente de $a y $b.$a % $bMóduloResto de $a dividido por $b.$a ** $bExponenciaciónResultado de elevar $a a la potencia $bésima. Introducido en PHP 5.6.
El operador de división ("/") devuelve un valor flotante a menos que los dos operandos
sean integers (o strings que se conviertan a integers) y los números
sean divisibles, en cuyo caso será devuelto un valor integer.
Los operandos del módulo se convierten en integers (por extracción de la parte
decimal) antes del procesamiento.
El resultado del operador módulo % tiene el mismo signo
que el dividendo — es decir, el resultado de $a % $b
tendrá el mismo signo que $a. Por ejemplo:
]]>
Véase también la página del manual sobre
funciones matemáticas.
Operadores de asignación
El operador básico de asignación es "=". Se podría inclinar a pensar
primero que es como un "igual a". No lo es. Realmente significa que el
operando de la izquierda se establece con el valor de la expresión de la
derecha (es decir, "se define como").
El valor de una expresión de asignación es el valor asignado. Es
decir, el valor de "$a = 3" es de 3. Esto permite hacer algunas cosas
intrincadas:
]]>
Para arrays, asignar un valor a una clave con nombre se realiza utilizando
el operador "=>". La precedencia
de este operador es la misma que otros operadores de asignación.
Además del operador básico de asignación, existen "operadores
combinados" para todos los de aritmética
binaria, unión de arrays y operadores de strings que permiten usar un valor en una
expresión y entonces establecer su valor como el resultado de esa expresión. Por
ejemplo:
]]>
Observe que la asignación copia la variable original en la nueva
(asignación por valor), por lo que los cambios en una no afectarán a la
otra. Esto también puede tener relevancia si se necesita copiar algo
como un gran array dentro de un bucle estrecho.
Una excepción al comportamiento usual de la asignación por valor en PHP ocurre
con objects los cuales son asignados por referencia en PHP 5.
Los objetos pueden ser explícitamente copiados por medio de la palabra clave
clone.
Asignación por referencia
La asignación por referencia también está soportada, utilizando la
sintaxis "$var = &$othervar;".
Asignación por referencia significa que ambas variables terminan apuntando a los
mismos datos y nada es copiado en ninguna parte.
Asignación por referencia
]]>
Desde PHP 5, el operador new
retorna una referencia automáticamente, así que asignar el resultado de
new por referencia, resulta
en un mensaje E_DEPRECATED en PHP 5.3 y posteriores y
un mensaje E_STRICT en versiones anteriores.
Por ejemplo, éste código resultará en una advertencia:
]]>
Más información sobre referencias y sus usos potenciales se puede encontrar en
la sección del manual
Referencias Explicadas
Operadores bit a bit
Los operadores bit a bit permiten la evaluación y la manipulación de bits
específicos dentro de un integer.
Operadores bit a bitEjemploNombreResultado$a & $bAnd (y)Los bits que están activos en ambos $a y $b son activados.$a | $bOr (o inclusivo)Los bits que están activos ya sea en $a o en $b son activados.$a ^ $bXor (o exclusivo)
Los bits que están activos en $a o en $b, pero no en ambos, son activados.
~ $aNot (no)
Los bits que están activos en $a son desactivados, y viceversa.
$a << $bShift left(desplazamiento a izquierda)
Desplaza los bits de $a, $b pasos a la izquierda (cada paso
quiere decir "multiplicar por dos").
$a >> $bShift right (desplazamiento a derecha)
Desplaza los bits de $a, $b pasos a la derecha (cada paso
quiere decir "dividir por dos").
El desplazamiento de bits en PHP es aritmético.
Los bits desplazados por fuera de cualquiera de los extremos son descartados.
Desplazamientos de izquierda tienen ceros desplazados a la derecha mientras que el
bit de signo es desplazado fuera a la izquierda, es decir que no se conserva el
signo de un operando.
Desplazamientos a la derecha tienen copias del bit de signo desplazado a la izquierda,
es decir que se conserva el signo de un operando.
Utilice paréntesis para garantizar la
precedencia deseada.
Por ejemplo, $a & $b == true evalúa
la equivalencia y luego el bit a bit, mientras que
($a & $b) == true evalúa el bit a bit y
luego la equivalencia.
Si los operandos para los operadores &, | y
^ son string, la operación se realizará
con los valores ASCII de los caracteres que componen dichos string, y el
resultado será también un string. En todos los demás casos, ambos operandos serán
convertidos a valores de tipo integer
y el resultado será también un integer.
Si el operando del operados ~ es un string, la
operación se realizará con valores los ASCII de los caracteres que componen
dicho string, y el resultado también será un string; en caso contrario, el operando y
el resultado serán tratados como valores de tipo integer.
Ambos operandos y el resultado de lo operadores << y
>> siempre son tratados como valores de tipo integer.
El ajuste ini error_reporting utiliza valores a nivel de bit,
lo que ofrece una demostración del mundo real de desactivar
bits. Para mostrar todos los errores, a excepción de los avisos,
las instrucciones del archivo php.ini dicen utilizar:
E_ALL & ~E_NOTICE
Esto funciona iniciando con E_ALL:
00000000000000000111011111111111
Luego se toma el valor de E_NOTICE ...
00000000000000000000000000001000
... y se invierte por medio de ~:
11111111111111111111111111110111
Finalmente, se utiliza AND (&) para encontrar los bits que se
activaron en ambos valores:
00000000000000000111011111110111
Otra forma de lograrlo es mediante XOR (^)
para encontrar los bits que están activados en sólo el primer valor o en el otro:
E_ALL ^ E_NOTICE
error_reporting también se puede utilizar para demostrar la activación de bits.
La forma para mostrar sólo los errores y los errores recuperables es:
E_ERROR | E_RECOVERABLE_ERROR
Este proceso combina E_ERROR
00000000000000000000000000000001
y
00000000000000000001000000000000
usando el operador OR (|)
para obtener los bits activados en cualquiera de estos valores:
00000000000000000001000000000001Operaciones AND, OR y XOR bit a bit sobre integers
]]>
&example.outputs;
Operaciones XOR bit a bit sobre strings
]]>
Desplazamiento de bits sobre integers
> $places;
p($res, $val, '>>', $places, 'copia del bit de signo desplazado hacia el lado izquierdo');
$val = 4;
$places = 2;
$res = $val >> $places;
p($res, $val, '>>', $places);
$val = 4;
$places = 3;
$res = $val >> $places;
p($res, $val, '>>', $places, 'bits desplazados fuera del lado derecho');
$val = 4;
$places = 4;
$res = $val >> $places;
p($res, $val, '>>', $places, 'mismo resultado que arriba; no se puede desplazar más allá del 0');
echo "\n--- DESPLAZAMIENTO DE BITS A LA DERECHA SOBRE ENTEROS NEGATIVOS ---\n";
$val = -4;
$places = 1;
$res = $val >> $places;
p($res, $val, '>>', $places, 'copia del bit de signo desplazado al lado izquierdo');
$val = -4;
$places = 2;
$res = $val >> $places;
p($res, $val, '>>', $places, 'bits desplazados fuera del lado derecho');
$val = -4;
$places = 3;
$res = $val >> $places;
p($res, $val, '>>', $places, 'mismo resultado que arriba; no se puede desplazar más allá del -1');
echo "\n--- DESPLAZAMIENTO DE BITS A LA IZQUIERDA SOBRE ENTEROS POSITIVOS ---\n";
$val = 4;
$places = 1;
$res = $val << $places;
p($res, $val, '<<', $places, 'ceros rellenan en el lado derecho');
$val = 4;
$places = (PHP_INT_SIZE * 8) - 4;
$res = $val << $places;
p($res, $val, '<<', $places);
$val = 4;
$places = (PHP_INT_SIZE * 8) - 3;
$res = $val << $places;
p($res, $val, '<<', $places, 'bit de signo resulta desplazado fuera');
$val = 4;
$places = (PHP_INT_SIZE * 8) - 2;
$res = $val << $places;
p($res, $val, '<<', $places, 'bit de signo desplazado fuera del lado izquierdo');
echo "\n--- DESPLAZAMIENTO DE BITS A LA IZQUIERDA SOBRE ENTEROS NEGATIVOS ---\n";
$val = -4;
$places = 1;
$res = $val << $places;
p($res, $val, '<<', $places, 'ceros rellenan en el lado derecho');
$val = -4;
$places = (PHP_INT_SIZE * 8) - 3;
$res = $val << $places;
p($res, $val, '<<', $places);
$val = -4;
$places = (PHP_INT_SIZE * 8) - 2;
$res = $val << $places;
p($res, $val, '<<', $places, 'bits desplazados fuera del lado izquierdo, incluyendo el bit de signo');
/*
* Ignore this bottom section,
* it is just formatting to make output clearer.
*/
function p($res, $val, $op, $places, $note = '') {
$format = '%0' . (PHP_INT_SIZE * 8) . "b\n";
printf("Expression: %d = %d %s %d\n", $res, $val, $op, $places);
echo " Decimal:\n";
printf(" val=%d\n", $val);
printf(" res=%d\n", $res);
echo " Binary:\n";
printf(' val=' . $format, $val);
printf(' res=' . $format, $res);
if ($note) {
echo " NOTE: $note\n";
}
echo "\n";
}
?>
]]>
&example.outputs.32bit;
> 1
Decimal:
val=4
res=2
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000000010
NOTE: copia del bit de signo desplazado hacia el lado izquierdo
Expression: 1 = 4 >> 2
Decimal:
val=4
res=1
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000000001
Expression: 0 = 4 >> 3
Decimal:
val=4
res=0
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000000000
NOTE: bits desplazados fuera del lado derecho
Expression: 0 = 4 >> 4
Decimal:
val=4
res=0
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000000000
NOTE: mismo resultado que arriba; no se puede desplazar más allá del 0
--- DESPLAZAMIENTO DE BITS A LA DERECHA SOBRE ENTEROS NEGATIVOS ---
Expression: -2 = -4 >> 1
Decimal:
val=-4
res=-2
Binary:
val=11111111111111111111111111111100
res=11111111111111111111111111111110
NOTE: copia del bit de signo desplazado al lado izquierdo
Expression: -1 = -4 >> 2
Decimal:
val=-4
res=-1
Binary:
val=11111111111111111111111111111100
res=11111111111111111111111111111111
NOTE: bits desplazados fuera del lado derecho
Expression: -1 = -4 >> 3
Decimal:
val=-4
res=-1
Binary:
val=11111111111111111111111111111100
res=11111111111111111111111111111111
NOTE: mismo resultado que arriba; no se puede desplazar más allá del -1
--- DESPLAZAMIENTO DE BITS A LA IZQUIERDA SOBRE ENTEROS POSITIVOS ---
Expression: 8 = 4 << 1
Decimal:
val=4
res=8
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000001000
NOTE: ceros rellenan en el lado derecho
Expression: 1073741824 = 4 << 28
Decimal:
val=4
res=1073741824
Binary:
val=00000000000000000000000000000100
res=01000000000000000000000000000000
Expression: -2147483648 = 4 << 29
Decimal:
val=4
res=-2147483648
Binary:
val=00000000000000000000000000000100
res=10000000000000000000000000000000
NOTE: bit de signo resulta desplazado fuera
Expression: 0 = 4 << 30
Decimal:
val=4
res=0
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000000000
NOTE: bit de signo desplazado fuera del lado izquierdo
--- DESPLAZAMIENTO DE BITS A LA IZQUIERDA SOBRE ENTEROS NEGATIVOS ---
Expression: -8 = -4 << 1
Decimal:
val=-4
res=-8
Binary:
val=11111111111111111111111111111100
res=11111111111111111111111111111000
NOTE: ceros rellenan en el lado derecho
Expression: -2147483648 = -4 << 29
Decimal:
val=-4
res=-2147483648
Binary:
val=11111111111111111111111111111100
res=10000000000000000000000000000000
Expression: 0 = -4 << 30
Decimal:
val=-4
res=0
Binary:
val=11111111111111111111111111111100
res=00000000000000000000000000000000
NOTE: bits desplazados fuera del lado izquierdo, incluyendo el bit de signo
]]>
&example.outputs.64bit;
> 1
Decimal:
val=4
res=2
Binary:
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000010
NOTE: copia del bit de signo desplazado hacia el lado izquierdo
Expression: 1 = 4 >> 2
Decimal:
val=4
res=1
Binary:
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000001
Expression: 0 = 4 >> 3
Decimal:
val=4
res=0
Binary:
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000000
NOTE: bits desplazados fuera del lado derecho
Expression: 0 = 4 >> 4
Decimal:
val=4
res=0
Binary:
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000000
NOTE: mismo resultado que arriba; no se puede desplazar más allá del 0
--- DESPLAZAMIENTO DE BITS A LA DERECHA SOBRE ENTEROS NEGATIVOS ---
Expression: -2 = -4 >> 1
Decimal:
val=-4
res=-2
Binary:
val=1111111111111111111111111111111111111111111111111111111111111100
res=1111111111111111111111111111111111111111111111111111111111111110
NOTE: copia del bit de signo desplazado al lado izquierdo
Expression: -1 = -4 >> 2
Decimal:
val=-4
res=-1
Binary:
val=1111111111111111111111111111111111111111111111111111111111111100
res=1111111111111111111111111111111111111111111111111111111111111111
NOTE: bits desplazados fuera del lado derecho
Expression: -1 = -4 >> 3
Decimal:
val=-4
res=-1
Binary:
val=1111111111111111111111111111111111111111111111111111111111111100
res=1111111111111111111111111111111111111111111111111111111111111111
NOTE: mismo resultado que arriba; no se puede desplazar más allá del -1
--- DESPLAZAMIENTO DE BITS A LA IZQUIERDA SOBRE ENTEROS POSITIVOS ---
Expression: 8 = 4 << 1
Decimal:
val=4
res=8
Binary:
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000001000
NOTE: ceros rellenan en el lado derecho
Expression: 4611686018427387904 = 4 << 60
Decimal:
val=4
res=4611686018427387904
Binary:
val=0000000000000000000000000000000000000000000000000000000000000100
res=0100000000000000000000000000000000000000000000000000000000000000
Expression: -9223372036854775808 = 4 << 61
Decimal:
val=4
res=-9223372036854775808
Binary:
val=0000000000000000000000000000000000000000000000000000000000000100
res=1000000000000000000000000000000000000000000000000000000000000000
NOTE: bit de signo resulta desplazado fuera
Expression: 0 = 4 << 62
Decimal:
val=4
res=0
Binary:
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000000
NOTE: bit de signo desplazado fuera del lado izquierdo
--- DESPLAZAMIENTO DE BITS A LA IZQUIERDA SOBRE ENTEROS NEGATIVOS ---
Expression: -8 = -4 << 1
Decimal:
val=-4
res=-8
Binary:
val=1111111111111111111111111111111111111111111111111111111111111100
res=1111111111111111111111111111111111111111111111111111111111111000
NOTE: ceros rellenan en el lado derecho
Expression: -9223372036854775808 = -4 << 61
Decimal:
val=-4
res=-9223372036854775808
Binary:
val=1111111111111111111111111111111111111111111111111111111111111100
res=1000000000000000000000000000000000000000000000000000000000000000
Expression: 0 = -4 << 62
Decimal:
val=-4
res=0
Binary:
val=1111111111111111111111111111111111111111111111111111111111111100
res=0000000000000000000000000000000000000000000000000000000000000000
NOTE: bits desplazados fuera del lado izquierdo, incluyendo el bit de signo
]]>
Desplazar un integer por valores mayores o iguales al ancho del tipo long integer
del sistema resultará en un comportamiento indefinido. En otras palabras, no desplace
más de 31 bit en sistemas de 32 bit, y no desplace más de 63 bit en sistemas
de 64 bit.
Use funciones de la extensión gmp para
manipular a nivel de bit números mayores que PHP_INT_MAX.
Ver también
pack,
unpack,
gmp_and,
gmp_or,
gmp_xor,
gmp_testbit,
gmp_clrbitOperadores de comparación
Los operadores de comparación, como su nombre lo indica, permiten comparar
dos valores. Puede también estar interesado en ver
las tablas de comparación de tipos,
ya que muestran ejemplos de las varias comparaciones relacionadas con tipos.
Operadores de comparaciónEjemploNombreResultado$a == $bIgual&true; si $a es igual a $b después de la manipulación de tipos.$a === $bIdéntico
&true; si $a es igual a $b, y son del mismo
tipo.
$a != $bDiferente&true; si $a no es igual a $b después de la manipulación de tipos.$a <> $bDiferente&true; si $a no es igual a $b después de la manipulación de tipos.$a !== $bNo idéntico
&true; si $a no es igual a $b, o si no son del mismo
tipo.
$a < $bMenor que&true; si $a es estrictamente menor que $b.$a > $bMayor que&true; si $a es estrictamente mayor que $b.$a <= $bMenor o igual que&true; si $a es menor o igual que $b.$a >= $bMayor o igual que&true; si $a es mayor o igual que $b.$a <=> $bNave espacial
Un integer menor que, igual a, o mayor que cero cuando
$a es respectivamente menor que, igual a, o mayor
que $b. Disponible a partir de PHP 7.
$a ?? $b ?? $cFusión de null
El primer operando de izquierda a derecha que exista y no sea &null;.
&null; si no hay valores definidos y no son &null;. Disponible a partir de PHP 7.
Si se compara un número con un string o la comparación implica strings
numéricos, entonces cada string es
convertido en un número
y la comparación realizada numéricamente. Estas reglas también se aplican a la sentencia
switch. La
conversión de tipo no tiene lugar cuando la comparación es === o !== ya que
esto involucra comparar el tipo así como el valor.
true
var_dump("1" == "01"); // 1 == 1 -> true
var_dump("10" == "1e1"); // 10 == 10 -> true
var_dump(100 == "1e2"); // 100 == 100 -> true
switch ("a") {
case 0:
echo "0";
break;
case "a": // nunca alcanzado debido a que "a" ya ha coincidido con 0
echo "a";
break;
}
?>
]]>
1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1
// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1
// Objects
$a = (object) ["a" => "b"];
$b = (object) ["a" => "b"];
echo $a <=> $b; // 0
$a = (object) ["a" => "b"];
$b = (object) ["a" => "c"];
echo $a <=> $b; // -1
$a = (object) ["a" => "c"];
$b = (object) ["a" => "b"];
echo $a <=> $b; // 1
// only values are compared
$a = (object) ["a" => "b"];
$b = (object) ["b" => "b"];
echo $a <=> $b; // 1
?>
]]>
Para varios tipos, la comparación se realiza de acuerdo a la siguiente
tabla (en orden).
La comparación con varios tiposTipo de operando 1Tipo de operando 2Resultadonull o stringstringConvierte &null; en "", comparación numérica o léxicabool o nullcualquieraConvierte ambos lados a bool, &false; < &true;objectobjectLas clases internas pueden definir su propia comparación, diferentes clases
son incomparables, la misma clase - comparan propiedades en la misma forma que
los arrays (PHP 4), PHP 5 tiene su propia explicación
string, resource o numberstring, resource o numberTraducir las cadenas y recursos a números, matemática usualarrayarrayUn array con menos elementos es menor, si una clave del operando 1 no se
encuentra en el operando 2 entonces los arrays son incomparables, de otra forma - compara
valor por valor (ver el siguiente ejemplo)objectcualquieraobject es siempre mayorarraycualquieraarray es siempre mayor
Comparación boolean/null
]]>
Transcripción de la comparación estándar de arrays
count($op2)) {
return 1; // $op1 > $op2
}
foreach ($op1 as $key => $val) {
if (!array_key_exists($key, $op2)) {
return null; // uncomparable
} elseif ($val < $op2[$key]) {
return -1;
} elseif ($val > $op2[$key]) {
return 1;
}
}
return 0; // $op1 == $op2
}
?>
]]>
Ver también strcasecmp,
strcmp,
operadores de array,
y la sección del manual sobre
tipos.
Comparación de números de punto flotante
Debido a la forma en que son representados internamente los floats, no
se deben probar por igualdad dos floats.
Ver la documentación de float para más información.
Operador ternario
Otro operador condicional es el operador "?:" (o ternario).
Asignación de un valor predeterminado
]]>
La expresión (expr1) ? (expr2) : (expr3)
evalúa a expr2 si
expr1 se evalúa como &true; y a
expr3 si
expr1 se evalúa como &false;.
A partir de PHP 5.3, es posible dejar de lado la parte media del operador
ternario. La expresión expr1 ?: expr3 retorna
expr1 si expr1
se evalúa como &true; y expr3 si es de otra manera.
Por favor note que el operador ternario es una expresión, y que
no evalúa a una variable, sino al resultado de una expresión. Esto
es importante saberlo si se desea retornar una variable por referencia.
La sentencia return $var == 42 ? $a : $b; en una
función con retorno-por-referencia no funcionará por lo que se ha mencionado y una advertencia es
generada en versiones posteriores de PHP.
Es recomendable evitar el "apilamiento" expresiones ternarias. El
comportamiento de PHP al utilizar más de un operador ternario en una única
sentencia no es evidente:
Comportamiento Ternario poco obvio
]]>
Operadores de control de errores
PHP soporta un operador de control de errores: el signo de arroba (@). Cuando
se antepone a una expresión en PHP, cualquier mensaje de error que pueden
ser generado por esa expresión será ignorado.
Si se ha establecido una función controladora de errores personalizada con
set_error_handler entonces todavía será
llamada, pero este controlador de errores personalizado puede (y debe) llamar a error_reporting
el cual devolverá 0 cuando la llamada que provocó el error fue precedida por el signo @.
Si la propiedad
está activada, cualquier mensaje de error generado por la expresión
será guardada en la variable
$php_errormsg.
Esta variable se sobrescribe en cada error, así que se debe comprobar antes si
se desea utilizar.
]]>
El operador @ trabaja sólo sobre
expresiones. Una simple regla
de oro es: si se puede tomar el valor de algo, entonces se le puede anteponer
el operador @. Por ejemplo, puede anteponerse a variables,
a llamadas a funciones e includes, constantes y
así sucesivamente. No puede anteponerse a definiciones de función o clase,
ni a estructuras condicionales como if y
&foreach;, y así sucesivamente.
Ver también error_reporting y la sección del manual sobre
funciones de Manejo de Errores y Registros.
En la actualidad, el operador de prefijo "@" para control de errores deshabilitará incluso
el reporte de errores en casos de fallos críticos que terminarán la ejecución del
script. Entre otras cosas, esto quiere decir que si se usa "@" para
eliminar los errores de una cierta función y ésta no se encuentra
disponible o ha sido escrita de forma incorrecta, el script se detendrá en ese punto
sin indicación de por qué.
Operadores de ejecución
PHP soporta un operador de ejecución: las comillas invertidas (``). ¡Note que
estas no son las comillas sencillas! PHP intentará ejecutar el
contenido entre las comillas invertidas como si se tratara de un comando del shell; la salida será
retornada (es decir, no será simplemente volcada como salida; puede ser
asignada a una variable). El uso del operador de comillas invertidas es idéntico
al de shell_exec.
$output";
?>
]]>
El operador de comillas invertidas se deshabilita cuando &safemode; esta activado
o shell_exec esta desactivado.
A diferencia de otros lenguajes, las comillas invertidas no tienen un significa especial
dentro de string entre comillas dobles.
Vea también la sección del manual sobre funciones
de ejecución de programas, popenproc_open y
Usando PHP desde la
línea de comandos.
Operadores de incremento/decremento
PHP soporta operadores estilo C de pre- y post-incremento
y decremento.
Los operadores de incremento/decremento solamente afectan a números y strings.
Los arrays, objects y resources no se ven afectados.
Decrementar valores &null; tampoco tiene efecto, pero incrementarlos entonces
resulta en 1.
Operadores de incremento/decrementoEjemploNombreEfecto++$aPre-incrementoIncrementa $a en uno, y luego retorna $a.$a++Post-incrementoRetorna $a, y luego incrementa $a en uno.--$aPre-decrementoDecrementa $a en uno, luego retorna $a.$a--Post-decrementoRetorna $a, luego decrementa $a en uno.
Aquí hay un script simple de ejemplo:
Postincremento";
$a = 5;
echo "Debe ser 5: " . $a++ . " \n";
echo "Debe ser 6: " . $a . " \n";
echo "
";
$a = 5;
echo "Debe ser 4: " . --$a . " \n";
echo "Debe ser 4: " . $a . " \n";
?>
]]>
PHP sigue la convención de Perl cuando trabaja con operaciones aritméticas
sobre variables de caracteres y no la de C. Por ejemplo, en PHP y Perl
$a = 'Z'; $a++; convierte $a en 'AA', mientras que en C
a = 'Z'; a++; convierte a en '['
(el valor ASCII de 'Z' es 90, el valor ASCII de '[' es 91).
Nótese que las variables de caracteres pueden ser incrementadas pero no decrementadas y
aun así sólo caracteres y dígitos de ASCII puro (a-z, A-Z y 0-9) están soportados.
Incrementar o decrementar otras variables de caracteres no tiene efecto, el
string original no se modifica.
Operaciones aritméticas sobre variables de caracteres
]]>
&example.outputs;
Incrementar o decrementar booleanos no tiene efecto.
Operadores lógicos
Operadores lógicosEjemploNombreResultado$a and $bAnd (y)&true; si tanto $a como $b son &true;.$a or $bOr (o inclusivo)&true; si cualquiera de $a o $b es &true;.$a xor $bXor (o exclusivo)&true; si $a o $b es &true;, pero no ambos.! $aNot (no)&true; si $a no es &true;.$a && $bAnd (y)&true; si tanto $a como $b son &true;.$a || $bOr (o inclusivo)&true; si cualquiera de $a o $b es &true;.
La razón para tener las dos variaciones diferentes de los operadores
"and" y "or" es que ellos operan con precedencias diferentes. (Ver
Precedencia
de operadores.)
Los operadores lógicos ilustrados
]]>
&example.outputs.similar;
Operadores para strings
Existen dos operadores para datos tipo string. El primero es el
operador de concatenación ('.'), el cual retorna el resultado de concatenar sus
argumentos derecho e izquierdo. El segundo es el operador de asignación sobre
concatenación ('.='), el cual añade el argumento del lado derecho al
argumento en el lado izquierdo. Por favor consulte Operadores de
asignación para más información.
]]>
Ver también las secciones del manual sobre el
tipo string y las
funciones de strings.
Operadores para arrays
Operadores para arraysEjemploNombreResultado$a + $bUniónUnión de $a y $b.$a == $bIgualdad&true; si $a i $b tienen las mismas parejas clave/valor.$a === $bIdentidad&true; si $a y $b tienen las mismas parejas clave/valor en el mismo
orden y de los mismos tipos.$a != $bDesigualdad&true; si $a no es igual a $b.$a <> $bDesigualdad&true; si $a no es igual a $b.$a !== $bNo-identidad&true; si $a no es idéntica a $b.
El operador + devuelve el array del lado derecho añadido
al array del lado izquierdo; para las claves que existan en ambos arrays, serán utilizados
los elementos del array de la izquierda y serán ignorados los elementos correspondientes del
array de la derecha.
"apple", "b" => "banana");
$b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");
$c = $a + $b; // Unión de $a y $b
echo "Unión de \$a y \$b: \n";
var_dump($c);
$c = $b + $a; // Unión de $b y $a
echo "Unión de \$b y \$a: \n";
var_dump($c);
$a += $b; // Unión de $a += $b es $a y $b
echo "Unión de \$a += \$b: \n";
var_dump($a);
?>
]]>
Cuando sea ejecutado, este script producirá la siguiente salida:
string(5) "apple"
["b"]=>
string(6) "banana"
["c"]=>
string(6) "cherry"
}
Unión de $b y $a:
array(3) {
["a"]=>
string(4) "pear"
["b"]=>
string(10) "strawberry"
["c"]=>
string(6) "cherry"
}
Unión de $a += $b:
array(3) {
'a' =>
string(5) "apple"
'b' =>
string(6) "banana"
'c' =>
string(6) "cherry"
}
]]>
Los elementos de los arrays son iguales para la comparación si éstos tienen la
misma clave y valor.
Comparando arrays
"banana", "0" => "apple");
var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>
]]>
Ver también las secciones del manual sobre el
tipo array y
funciones de arrays.
Operadores de tipoinstanceof se utiliza para determinar si una variable de PHP
es un objeto instanciado de una cierta
clase:
Utilizando <literal>instanceof</literal> con clases
]]>
&example.outputs;
instanceof también se puede utilizar para determinar si una variable
es un objeto instanciado de una clase que hereda de una clase padre:
Utilizando <literal>instanceof</literal> con clases heredadas
]]>
&example.outputs;
Para comprobar si un objeto no es una instancia de una clase, se
puede usar el operador lógico
not.
Utilizando <literal>instanceof</literal> para verificar si un objeto <emphasis>no</emphasis> es una
instancia de una clase
]]>
&example.outputs;
Finalmente, instanceof también se puede utilizar para determinar si
una variable es un objeto instanciado de una clase que implementa una
interface:
Utilizando <literal>instanceof</literal> para la clase
]]>
&example.outputs;
Aunque instanceof se utiliza generalmente con un nombre de clase literal,
también puede ser utilizado con otro objeto o una variable string:
Utilizando <literal>instanceof</literal> con otras variables
]]>
&example.outputs;
instanceof no lanza ningún error si la variable que está siendo comprobada no es
un objeto, simplemente devuelve &false;. Las constantes, sin embargo, no está permitidas.
Usar <literal>instanceof</literal> para comprobar otras variables
]]>
&example.outputs;
Hay algunas trampas a tener en cuenta. Antes de versión de PHP 5.1.0,
instanceof llamaría a __autoload
si el nombre de clase no existía. Además, si la clase no estaba cargada,
un error fatal ocurriría. Esto se puede solucionar mediante una referencia
de clase dinámica o una variable string que contenga el nombre de la clase:
Evitando búsquedas del nombre de clase y errores fatales con <literal>instanceof</literal> en PHP 5.0
]]>
&example.outputs;
El operador instanceof fue introducido en PHP 5.
Antes de esta época se utilizaba is_a, pero
desde entonces is_a se ha quedado obsoleto en favor de
instanceof. Tenga en cuenta que a partir de PHP 5.3.0,
is_a ya no está obsoleto.
Ver también get_class y
is_a.