Psy3com - Cuentos de terror

Operadores aritméticos

¿Recuerda la aritmética básica de la escuela? Estos funcionan igual que aquellos.

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.

- Pág. 1 de 18 -
 Psy3com - Cuentos de terror

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

?>

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;

- Pág. 2 de 18 -
 Psy3com - Cuentos de terror

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

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.

Ejemplo #1 Asignación por referencia

<?php

$a = 3;

$b = &$a; // $b es una referencia para $a

print "$a\n"; // muestra 3

print "$b\n"; // muestra 3

$a = 4; // cambia $a

print "$a\n"; // muestra 4

print "$b\n"; // muestra 4 también, dado que $b es una referencia para $a, la cual ha

// sido cambiada

?>

- Pág. 3 de 18 -
 Psy3com - Cuentos de terror

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:

<?php

class C {}

/* La siguiente línea genera el siguiente mensaje de error:

* Deprecated: Assigning the return value of new by reference is deprecated in...

*/

$o = &new C;

?>

Operadores 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ón

Ejemplo Nombre Resultado

$a == $b Igual TRUE si $a es igual a $b después de la manipulación de tipos.

- Pág. 4 de 18 -
 Psy3com - Cuentos de terror

Operadores de comparación

Ejemplo Nombre Resultado

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

Menor o
$a <= $b TRUE si $a es menor o igual que $b.
igual que

Mayor o
$a >= $b TRUE si $a es mayor o igual que $b.
igual que

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

- Pág. 5 de 18 -
 Psy3com - Cuentos de terror

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;

?>

Para varios tipos, la comparación se realiza de acuerdo a la siguiente tabla (en orden).

La comparación con varios tipos

Tipo de Tipo de
Resultado
operando 1 operando 2

null o
string Convierte NULL en "", comparación numérica o léxica
string

bool o null cualquiera Convierte en bool, FALSE < TRUE

Las clases internas pueden definir su propia comparación, diferentes clases

object object son incomparables, la misma clase - comparan propiedades en la misma forma

que los arrays (PHP 4), PHP 5 tiene su propia explicación

Traducir las cadenas y recursos a números, matemática usual

string, string,

- Pág. 6 de 18 -
 Psy3com - Cuentos de terror

La comparación con varios tipos

Tipo de Tipo de
Resultado
operando 1 operando 2

resource o resource o

number number

Un array con menos elementos es menor, si una clave del operando 1 no se

array array encuentra en el operando 2 entonces los arrays son incomparables, de otra

forma - compara valor por valor (ver el siguiente ejemplo)

object cualquiera object es siempre mayor

array cualquiera array es siempre mayor

Ejemplo #1 Transcripción de la comparación estándar de arrays

<?php

// Arrays son comparados de esta forma con los operadores de comparación estándar

function standard_array_compare($op1, $op2)

if (count($op1) < count($op2)) {

return -1; // $op1 < $op2

} elseif (count($op1) > count($op2)) {

return 1; // $op1 > $op2

foreach ($op1 as $key => $val) {

if (!array_key_exists($key, $op2)) {

- Pág. 7 de 18 -
 Psy3com - Cuentos de terror

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.

Advertencia

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

Ejemplo #2 Asignación de un valor predeterminado

<?php

// Ejemplo de uso para: Operador Ternario

$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];

// Lo anterior es idéntico a esta sentencia if/else

if (empty($_POST['action'])) {

- Pág. 8 de 18 -
 Psy3com - Cuentos de terror

$action = 'default';

} else {

$action = $_POST['action'];

?>

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.

Nota: Por favor note que el operador ternario es una sentencia, y que no evalúa a una variable, pero si al
resultado de una sentencia. 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.

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

<?php

/* Error intencional de archivo */

$my_file = @file ('non_existent_file') or

die ("La apertura de archivo ha fallado: el error fue '$php_errormsg'");

- Pág. 9 de 18 -
 Psy3com - Cuentos de terror

// esto funciona con cualquier expresión, no solo con funciones:

$value = @$cache[$key];

// no producirá una anotación si el índice $key no existe.

?>

Nota: 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.

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.

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

- Pág. 10 de 18 -
 Psy3com - Cuentos de terror

Eje
Nombre Efecto
mplo

++$ Pre- Incrementa $a en uno, y luego retorna

a incremento $a.

$a+ Post- Retorna $a, y luego incrementa $a en

+ incremento uno.

Pre- Decrementa $a en uno, luego retorna

--$a
decremento $a.

Post- Retorna $a, luego decrementa $a en

$a--
decremento 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>";

- Pág. 11 de 18 -
 Psy3com - Cuentos de terror

$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 lógicos

- Pág. 12 de 18 -
 Psy3com - Cuentos de terror

Operadores lógicos

Ejem
Nombre Resultado
plo

$a
And (y) TRUE si tanto $a como $b son TRUE.
and $b

$a or Or (o TRUE si cualquiera de $a o $b es

$b inclusivo) TRUE.

$a Xor (o TRUE si $a o $b es TRUE, pero no

xor $b exclusivo) ambos.

! $a Not (no) TRUE si $a no es TRUE.

$a
And (y) TRUE si tanto $a como $b son TRUE.
&& $b

$a || Or (o TRUE si cualquiera de $a o $b es

$b inclusivo) 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

// --------------------

- Pág. 13 de 18 -
 Psy3com - Cuentos de terror

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

- Pág. 14 de 18 -
 Psy3com - Cuentos de terror

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

<?php

$a = "Hello ";

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

$a = "Hello ";

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

Operadores para arrays

Operadores para arrays

Ejem
Nombre Resultado
plo

- Pág. 15 de 18 -
 Psy3com - Cuentos de terror

Operadores para arrays

Ejem
Nombre Resultado
plo

$a +
Unión Unión de $a y $b.
$b

$a ==
Igualdad TRUE si $a i $b tienen las mismas parejas clave/valor.
$b

$a Identida TRUE si $a y $b tienen las mismas parejas clave/valor en el mismo orden y de los

=== $b d mismos tipos.

$a != Desigual
TRUE si $a no es igual a $b.
$b dad

$a <> Desigual
TRUE si $a no es igual a $b.
$b dad

$a No-
TRUE si $a no es idéntica a $b.
!== $b identidad

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");

- Pág. 16 de 18 -
 Psy3com - Cuentos de terror

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

- Pág. 17 de 18 -
 Psy3com - Cuentos de terror

var_dump($a === $b); // bool(false)

?>

- Pág. 18 de 18 -