Operadores para arrays

Operadores para arrays

Ejemplo	Nombre	Resultado
$a + $b	Unión	Unión de $a y $b.
$a == $b	Igualdad	TRUE si $a i $b tienen las mismas parejas clave/valor.
$a === $b	Identidad	TRUE si $a y $b tienen las mismas parejas clave/valor en el mismo orden y de los mismos tipos.
$a != $b	Desigualdad	TRUE si $a no es igual a $b.
$a <> $b	Desigualdad	TRUE si $a no es igual a $b.
$a !== $b	No-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.

 

<?php
$a = array("a" => "apple", "b" => "banana");
$b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");

$c = $a + $b; // Unión de $a y $b
echo "Union of \$a and \$b: \n";
var_dump($c);

$c = $b + $a; // Unión de $b y $a
echo "Union of \$b and \$a: \n";
var_dump($c);
?>

Cuando sea ejecutado, este script producirá la siguiente salida:

Union of $a and $b:
array(3) {
  ["a"]=>
  string(5) "apple"
  ["b"]=>
  string(6) "banana"
  ["c"]=>
  string(6) "cherry"
}
Union of $b and $a:
array(3) {
  ["a"]=>
  string(4) "pear"
  ["b"]=>
  string(10) "strawberry"
  ["c"]=>
  string(6) "cherry"
}

Los elementos de los arrays son iguales para la comparación si éstos tienen la misma clave y valor.

 

Ejemplo #1 Comparando arrays

<?php
$a = array("apple", "banana");
$b = array(1 => "banana", "0" => "apple");

var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>

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.

<?php
$a = "Hello ";
$b = $a . "World!"; // ahora $b contiene "Hello World!"

$a = "Hello ";
$a .= "World!";     // ahora $a contiene "Hello World!"
?>

Operadores lógicos

Operadores lógicos

Ejemplo	Nombre	Resultado
$a and $b	And (y)	TRUE si tanto $a como $b son TRUE.
$a or $b	Or (o inclusivo)	TRUE si cualquiera de $a o $b es TRUE.
$a xor $b	Xor (o exclusivo)	TRUE si $a o $b es TRUE, pero no ambos.
! $a	Not (no)	TRUE si $a no es TRUE.
$a && $b	And (y)	TRUE si tanto $a como $b son TRUE.
$a || $b	Or (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.)

Ejemplo #1 Los operadores lógicos ilustrados

<?php

// --------------------
// foo() nunca será llamado ya que los operadores están en cortocircuito

$a = (false && foo());
$b = (true  || foo());
$c = (false and foo());
$d = (true  or  foo());

// --------------------
// "||" tiene una precedencia mayor que "or"

// El resultado de la expresión (false || true) es asignado a $e
// Actúa como: ($e = (false || true))
$e = false || true;

// La constante false es asignada a $f y entonces true es ignorado
// Actúa como: (($f = false) or true)
$f = false or true;

var_dump($e, $f);

// --------------------
// "&&" tiene una precedencia mayor que "and"

// El resultado de la expresión (true && false) es asignado a $g
// Actúa como: ($g = (true && false))
$g = true && false;

// La constante true es asignada a $h y entonces false es ignorado
// Actúa como: (($h = true) and false)
$h = true and false;

var_dump($g, $h);
?>

El resultado del ejemplo sería algo similar a:

bool(true)
bool(false)
bool(false)
bool(true)

Operadores de incremento/decremento

 

PHP soporta operadores estilo C de pre- y post-incremento y decremento.

Nota: Los operadores de incremento/decremento no afectan a los valores booleanos. Decrementar valores NULL tampoco tiene efecto, pero incrementarlos entonces resulta en 1.

Operadores de incremento/decremento

Ejemplo	Nombre	Efecto
++$a	Pre-incremento	Incrementa $a en uno, y luego retorna $a.
$a++	Post-incremento	Retorna $a, y luego incrementa $a en uno.
–$a	Pre-decremento	Decrementa $a en uno, luego retorna $a.
$a–	Post-decremento	Retorna $a, luego decrementa $a en uno.

Aquí hay un script simple de ejemplo:

<?php
echo "<h3>Postincremento</h3>";
$a = 5;
echo "Debe ser 5: " . $a++ . "<br />\n";
echo "Debe ser 6: " . $a . "<br />\n";

echo "<h3>Preincremento</h3>";
$a = 5;
echo "Debe ser 6: " . ++$a . "<br />\n";
echo "Debe ser 6: " . $a . "<br />\n";

echo "<h3>Postdecremento</h3>";
$a = 5;
echo "Debe ser 5: " . $a-- . "<br />\n";
echo "Debe ser 4: " . $a . "<br />\n";

echo "<h3>Predecremento</h3>";
$a = 5;
echo "Debe ser 4: " . --$a . "<br />\n";
echo "Debe ser 4: " . $a . "<br />\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 de ASCII plano (a-z y A-Z) están soportados. Incrementar o decrementar otras variables de caracteres no tiene efecto, el string original no se modifica.

Ejemplo #1 Operaciones aritméticas sobre variables de caracteres

<?php
$i = 'W';
for ($n=0; $n<6; $n++) {
echo ++$i . "\n";
}
?>

El resultado del ejemplo sería:

X
Y
Z
AA
AB
AC

Incrementar o decrementar booleanos no tiene efecto.

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

<?php
$output = `ls -al`;
echo "<pre>$output</pre>";
?>

Nota:

El operador de comillas invertidas se deshabilita cuando safe mode esta activado o shell_exec() esta desactivado.

Nota:

A diferencia de otros lenguajes, las comillas invertidas no pueden ser usadas dentro de strings entre comillas dobles.

Operadores de comparación

Los operadores de comparación, como su nombre lo indica, permiten comparar dos valores.

Operadores de comparación

Ejemplo	Nombre	Resultado
$a == $b	Igual	TRUE si $a es igual a $b después de la manipulación de tipos.
$a === $b	Idéntico	TRUE si $a es igual a $b, y son del mismo tipo.
$a != $b	Diferente	TRUE si $a no es igual a $b después de la manipulación de tipos.
$a <> $b	Diferente	TRUE si $a no es igual a $b después de la manipulación de tipos.
$a !== $b	No idéntico	TRUE si $a no es igual a $b, o si no son del mismo tipo.
$a < $b	Menor que	TRUE si $a es estrictamente menor que $b.
$a > $b	Mayor que	TRUE si $a es estrictamente mayor que $b.
$a <= $b	Menor o igual que	TRUE si $a es menor o igual que $b.
$a >= $b	Mayor o igual que	TRUE si $a es mayor o igual que $b.

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.

<?php
var_dump(0 == "a"); // 0 == 0 -> 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;
}
?>

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.

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:

<?php

$a = ($b = 4) + 5; // ahora $a es igual a 9 y $b se ha establecido en 4.

?>

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:

<?php

$a = 3;
$a += 5; // establece $a en 8, como si se hubiera dicho: $a = $a + 5;
$b = "Hola ";
$b .= "ahí!"; // establece $b en "Hola ahí!", al igual que $b = $b . "ahí!";

?>

Tener en cuenta 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.

 

Operadores aritméticos

Operadores aritméticos

Ejemplo	Nombre	Resultado
-$a	Negación	Opuesto de $a.
$a + $b	Adición	Suma de $a y $b.
$a – $b	Sustracción	Diferencia de $a y $b.
$a * $b	Multiplicación	Producto de $a y $b.
$a / $b	División	Cociente de $a y $b.
$a % $b	Módulo	Resto de $a dividido por $b.

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:

<?php

echo (5 % 3)."\n";           // muestra 2
echo (5 % -3)."\n";          // muestra 2
echo (-5 % 3)."\n";          // muestra -2
echo (-5 % -3)."\n";         // muestra -2

?>

Precedencia de operadores en PHP

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 la misma precedencia, su asociatividad decide si se evalúan a partir de la derecha o desde la izquierda – ver más abajo los ejemplos.

La siguiente tabla lista en orden la precedencia de los operadores, con los operadores de mayor precedencia en la parte superior. Los operadores en la misma línea tienen la misma precedencia, en cuyo caso su asociatividad decide cuál es el orden de evaluación.

Precedencia de operadores

Asociatividad	Operadores	Información adicional
no asociativo	clone new	clone and new
izquierda	[	array()
derecha	++ — ~ (int) (float) (string) (array) (object) (bool) @	tipos e incremento/decremento
no asociativo	instanceof	tipos
derecha	!	lógico
izquierda	* / %	aritmética
izquierda	+ – .	aritmética y string
izquierda	<< >>	bit a bit
no asociativo	< <= > >=	comparación
no asociativo	== != === !== <>	comparación
izquierda	&	bit a bit y referencias
izquierda	^	bit a bit
izquierda	|	bit a bit
izquierda	&&	lógico
izquierda	||	lógico
izquierda	? :	ternario
derecha	= += -= *= /= .= %= &= |= ^= <<= >>= =>	asignación
izquierda	and	lógico
izquierda	xor	lógico
izquierda	or	lógico
izquierda	,	muchos usos

Para operadores de igual precedencia, asociatividad izquierda significa que la evaluación procede de la izquierda a la derecha y asociatividad derecha significa lo opuesto.

Ejemplo #1 Asociatividad

 <?php
$a = 3 * 3 % 5; // (3 * 3) % 5 = 4
$a = true ? 0 : true ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2

$a = 1;
$b = 2;
$a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5

// mezclar ++ y + produce un comportamiento indefinido
$a = 1;
echo ++$a + $a++; // puede mostrar 4 o 5
?> 

El uso de paréntesis, incluso cuando no es estrictamente necesario, a menudo puede mejorar la legibilidad del código.