JTagua

Inicio » PHP » Operadores PHP

Category Archives: Operadores PHP

Anuncios

Tutorial PHP(26): Operadores de tipo.

instanceof se utiliza para determinar si una variable de PHP es un objeto instanciado de una cierta clase:

Ejemplo #1 Utilizando instanceof con clases

<?php
class MyClass
{
}

class NotMyClass
{
}
$a = new MyClass;

var_dump($a instanceof MyClass);
var_dump($a instanceof NotMyClass);
?>


El resultado del ejemplo sería:

bool(true)
bool(false)

instanceof también se puede utilizar para determinar si una variable es un objeto instanciado de una clase que hereda de una clase padre:

Ejemplo #2 Utilizando instanceof con clases heredadas


<?php
class ParentClass
{
}

class MyClass extends ParentClass
{
}

$a = new MyClass;

var_dump($a instanceof MyClass);
var_dump($a instanceof ParentClass);
?>


El resultado del ejemplo sería:

bool(true)
bool(true)

Para comprobar si un objeto no es una instancia de una clase, se puede usar el operador lógico not.

Ejemplo #3 Utilizando instanceof para verificar si un objeto no es una instancia de una clase


<?php
class MyClass
{
}

$a = new MyClass;
var_dump(!($a instanceof stdClass));
?>

El resultado del ejemplo sería:

bool(true)

Finalmente, instanceof también se puede utilizar para determinar si una variable es un objeto instanciado de una clase que implementa una interface:

Ejemplo #4 Utilizando instanceof para la clase

<?php
interface MyInterface
{
}

class MyClass implements MyInterface
{
}

$a = new MyClass;

var_dump($a instanceof MyClass);
var_dump($a instanceof MyInterface);
?>

El resultado del ejemplo sería:

bool(true)
bool(true)

Aunque instanceof se utiliza generalmente con un nombre de clase literal, también puede ser utilizado con otro objeto o una variable string:

Ejemplo #5 Utilizando instanceof con otras variables

<?php
interface MyInterface
{
}

class MyClass implements MyInterface
{
}

$a = new MyClass;
$b = new MyClass;
$c = 'MyClass';
$d = 'NotMyClass';

var_dump($a instanceof $b); // $b is an object of class MyClass
var_dump($a instanceof $c); // $c is a string 'MyClass'
var_dump($a instanceof $d); // $d is a string 'NotMyClass'
?>

El resultado del ejemplo sería:

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

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.

Ejemplo #6 Usar instanceof para comprobar otras variables

<?php
$a = 1;
$b = NULL;
$c = imagecreate(5, 5);
var_dump($a instanceof stdClass); // $a es un entero
var_dump($b instanceof stdClass); // $b es NULL
var_dump($c instanceof stdClass); // $c es un recurso
var_dump(FALSE instanceof stdClass);
?>

El resultado del ejemplo sería:

bool(false)
bool(false)
bool(false)
PHP Fatal error: instanceof expects an object instance, constant given

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:

Ejemplo #7 Evitando búsquedas del nombre de clase y errores fatales con instanceof en PHP 5.0

El resultado del ejemplo sería:

bool(false)

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

Anuncios

Tutorial PHP(25): Operadores de array.

Image10

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

Ver también las secciones del manual sobre el tipo array y funciones de arrays.

Tutorial PHP(24): Operadores de string.

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!"
?>

Ver también las secciones del manual sobre el tipo string y las funciones de strings.

Tutorial PHP(23): Operadores lógicos.

Image9

La razón para tener las dos variaciones diferentes de los operadores “and” y “or” es que ellos operan con precedencias diferentes.

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)

Tutorial PHP(22): 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.

Vea también la sección del manual sobre funciones de ejecución de programas, popen() proc_open() y Usando PHP desde la línea de comandos.

Tutorial PHP(21): Incremento/decremento.

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

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

Image8

Aquí hay un script simple de ejemplo:

<div>
<div>
<div><code> <?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";
?></code></div>
<div><code>

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.

Ejemplo #1 Operaciones aritméticas sobre variables de caracteres

<?php
echo '== Letras ==' . PHP_EOL;
$s = 'W';
for ($n=0; $n<6; $n++) {
echo ++$s . PHP_EOL;
}
// Los caracteres de dígitos tienen un comportamiento diferente
echo '== Dígitos ==' . PHP_EOL;
$d = 'A8';
for ($n=0; $n<6; $n++) {
echo ++$d . PHP_EOL;
}
$d = 'A08';
for ($n=0; $n<6; $n++) {
echo ++$d . PHP_EOL;
}
?>
[/code

El resultado del ejemplo sería:

== Letras ==
X
Y
Z
AA
AB
AC
== Dígitos ==
A9
B0
B1
B2
B3
B4
A09
A10
A11
A12
A13
A14

Incrementar o decrementar booleanos no tiene efecto.

Tutorial PHP(21): de ejecución.

26/12/2013 21:44 / Deja un comentario

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

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

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

Vea también la sección del manual sobre funciones de ejecución de programas, popen() proc_open() y Usando PHP desde la línea de comandos.

Tutorial PHP(20): de control de errores.

26/12/2013 21:35 / Deja un comentario

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.

</pre>
<div>
<div>
<div><code> <?php
/* Error intencional de archivo */
$my_file = @file ('non_existent_file') or
die ("La apertura de archivo ha fallado: el error fue '$php_errormsg'");

// esto funciona con cualquier expresión, no solo con funciones:
$value = @$cache[$key];
// no producirá una anotación si el índice $key no existe.</code></div>
<div><code>?></code></div>
</div>
</div>
<pre>

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

Tutorial PHP(19): de comparación.

26/12/2013 21:29 / Deja un comentario

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.

Image6

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;
}
?>

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

Image7

Ejemplo #1 Comparación boolean/null

<?php
// Booleanos y null son comparados siempre coomo bool
var_dump(1 == TRUE);  // TRUE - same as (bool)1 == TRUE
var_dump(0 == FALSE); // TRUE - same as (bool)0 == FALSE
var_dump(100 < TRUE); // FALSE - same as (bool)100 < TRUE
var_dump(-10 < FALSE);// FALSE - same as (bool)-10 < FALSE
var_dump(min(-100,-10, NULL, 10, 100); // NULL - (bool)NULL < (bool)-100 is FALSE < TRUE
?>

Ejemplo #2 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)) {
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.

Operador ternario

Otro operador condicional es el operador “?:” (o ternario).

Ejemplo #3 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'])) {
$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.

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.

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:

Ejemplo #4 Comportamiento Ternario poco obvio

<?php
// a primera vista, lo siguiente parece tener la salida de 'true'
echo (true?'true':false?'t':'f');

// sin embargo, la salida real de lo anterior es 't'
// esto se debe a que las expresiones ternarias se evalúan de izquierda a derecha

// la siguiente es una versión más obvia del mismo código anterior
echo ((true ? 'true' : false) ? 't' : 'f');

// aquí, se puede ver que la primera expresión es evaluada como 'true', que
// a su vez se evalúa como (bool)true, retornando así la rama verdadera de la
// segunda expresión ternaria.
?>

Tutorial PHP(18): Operadores de bit.

26/12/2013 21:16 / Deja un comentario

Los operadores bit a bit permiten la evaluación y la manipulación de bits específicos dentro de un integer.

Image5

El desplazamiento de bits en PHP es aritmético. Los bits desplazados por fuera de cualquiera de los extremos son descartados. Los 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. Los 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.

Sea consciente de las conversiones de tipos de datos. Si tanto los parámetros de la izquierda como los de la derecha son cadenas, el operador bit a bit operará en los valores ASCII de los caracteres.

Ejemplo #1 Operaciones AND, OR y XOR bit a bit sobre enteros.

<!--?php <br ?-->/*
 * Ignore la sección superior,
 * es sólo el formateado para hacer la salida más clara.
 */

$format = '(%1$2d = %1$04b) = (%2$2d = %2$04b)'
        . ' %3$s (%4$2d = %4$04b)' . "\n";

<code>echo <<
---------     ---------  -- ---------
resultado     valor      op prueba
---------     ---------  -- ---------
EOH;</code>
<code>/*
* Aquí están los ejemplos.
*/

$values = array(0, 1, 2, 4, 8);
$test = 1 + 4;

echo "\n AND bit a bit \n";
foreach ($values as $value) {
$result = $value & $test;
printf($format, $result, $value, '&', $test);
}

echo "\n OR inclusivo bit a bit \n";
foreach ($values as $value) {
$result = $value | $test;
printf($format, $result, $value, '|', $test);
}

echo "\n OR exclusivo (XOR) bit a bit \n";
foreach ($values as $value) {
$result = $value ^ $test;
printf($format, $result, $value, '^', $test);
}
?></code>

El resultado del ejemplo sería:

——— ——— — ———
resultado valor op prueba
——— ——— — ———
AND bit a bit
( 0 = 0000) = ( 0 = 0000) & ( 5 = 0101)
( 1 = 0001) = ( 1 = 0001) & ( 5 = 0101)
( 0 = 0000) = ( 2 = 0010) & ( 5 = 0101)
( 4 = 0100) = ( 4 = 0100) & ( 5 = 0101)
( 0 = 0000) = ( 8 = 1000) & ( 5 = 0101)

OR inclusivo bit a bit
( 5 = 0101) = ( 0 = 0000) | ( 5 = 0101)
( 5 = 0101) = ( 1 = 0001) | ( 5 = 0101)
( 7 = 0111) = ( 2 = 0010) | ( 5 = 0101)
( 5 = 0101) = ( 4 = 0100) | ( 5 = 0101)
(13 = 1101) = ( 8 = 1000) | ( 5 = 0101)

OR exclusivo (XOR) bit a bit
( 5 = 0101) = ( 0 = 0000) ^ ( 5 = 0101)
( 4 = 0100) = ( 1 = 0001) ^ ( 5 = 0101)
( 7 = 0111) = ( 2 = 0010) ^ ( 5 = 0101)
( 1 = 0001) = ( 4 = 0100) ^ ( 5 = 0101)
(13 = 1101) = ( 8 = 1000) ^ ( 5 = 0101)