Diferencia entre revisiones de «Plantilla:ManuelRomero/PHP/OperadoresExpresiones»

Operadores y expresiones

¿Qué es una expresión?

Una expresión es una parte esencial de las frases en un lenguaje de programación.

Definición técnica de expresión

Es un conjunto de operadores y operandos que, al evaluarse, producen un valor. Este valor puede ser usado dentro de otras instrucciones o asignado a variables.

(: Las expresiones son piezas fundamentales en cualquier lenguaje de programación. Es importante identificar sus partes (operadores y operandos) para entender cómo funciona el código. )

Operadores

Los operadores son símbolos que realizan acciones sobre operandos y generan un resultado. Existen diferentes tipos de operadores en función del tipo de operandos y el resultado esperado.

Notas importantes

Notas importantes Algunos operadores, como los de control de errores (@), deben usarse con cuidado, ya que pueden ocultar errores importantes en el código. Los operadores de asignación compuesta permiten realizar operaciones y asignar el resultado en un solo paso. El operador de ejecución (` `) se utiliza para ejecutar comandos del sistema y devolver su salida.

Precedencia de Operadores en PHP

• La precedencia de los operadores define el orden en que se evalúan cuando hay múltiples operadores en una expresión.
• Sigue las reglas básicas de las matemáticas:

 - La multiplicación y división tienen mayor prioridad que la suma y la resta.  
 - Los paréntesis siempre tienen la mayor precedencia.

• Cuando varios operadores tienen la misma precedencia, la asociatividad determina cómo se agrupan:

 - Ejemplo (asociatividad izquierda): `1 + 2 + 3` se evalúa como `(1 + 2) + 3`.  
 - Ejemplo (asociatividad derecha): `$x = $y = $z` se evalúa como `$x = ($y = $z)`.

• Algunos operadores no tienen asociatividad y no pueden combinarse directamente.

 - Ejemplo incorrecto: `1 < 2 > 1`.  

Nota importante: Usar paréntesis puede hacer que las expresiones sean más legibles, aunque no sean necesarios.

Tabla de Precedencia de Operadores

Operadores Aritméticos

Los operadores aritméticos en PHP son similares a los de las matemáticas y realizan operaciones básicas.

$x + $y

$x - $y

$x * $y

$x / $y

$x % $y

$x ** $y

-$x

Notas importantes:

• En módulo, el signo del resultado dependerá del dividendo.

-5 % 3

-2

• El exponente eleva un número a otro. Ejemplo:

  2 ** 3

  devolverá

  8

  .

Ejemplos Prácticos

1. Preferencia de Operadores:

$num = 5 + 6 * 8 - 4 / 2;
// Mejor usar paréntesis para mayor claridad:
$num = 5 + (6 * 8) - (4 / 2);

Ejecución paso a paso:

$num = 5 + 48 - 2;
$num = 53 - 2;
$num = 51;

2. Uso del módulo:

Actividad

Buscar los números divisibles por 3 entre 1 y 100. Posible solución for ($n = 1; $n <= 100; $n++) { if ($n % 3 == 0) { echo "$n, "; } } Salida Números divisibles por 3 con una coma al final.

3. Exponenciación:

Actividad

Calcular las potencias de 2 del 1 al 15 Posible solución for ($n = 1; $n <= 15; $n++) { echo "2^$n = " . (2 ** $n) . "<br />"; }

---

Operadores de Incremento y Decremento

Los operadores de incremento y decremento permiten aumentar o reducir en 1 el valor de una variable.

++$a

$a++

--$a

$a--

Ejemplo de Diferencias entre Pre y Post:

// Pre-incremento
$a = 5;
echo "Pre-incremento: " . ++$a; // Muestra 6
 
// Post-incremento
$a = 5;
echo "Post-incremento: " . $a++; // Muestra 5
echo "Nuevo valor: " . $a; // Muestra 6

(: Cuando los operadores de incremento/decremento están en una instrucción más compleja, su posición (pre o post) puede afectar el resultado.)

Operadores de Asignación

$x = 10;

$array = ["clave" => "valor"];

$y = &$x;

$x += 5;

$x -= 3;

$x *= 2;

$x /= 4;

$x %= 3;

$y .= " mundo";

$x **= 3;

Los operadores de asignación permiten asignar un valor a una variable. Existen dos tipos principales:

• Básicos: Usan el operador "=" para asignar un valor.
• Combinados Combina un operador aritmético o de concatenación con la asignación. Siempre van precedidos por el punto antes de la operador antes de la asignación.

Operador de Asignación Básico

El operador "=" asigna un valor, pero no actúa como un igual matemático. La asignación retorna el valor que se asignó. Por ejemplo:

//Simple curiosidad que tiene consecuencias en las estructuras de control
$x = 3;
// La expresión $x = 3 tiene un valor de 3
echo $x; // Mostrará: 3

En el caso de los **arrays**, el operador "=>" se utiliza para asignar valores a claves nombradas:

$array = ["clave1" => "valor1", "clave2" => "valor2"];
echo $array["clave1"]; // Mostrará: valor1

Operadores de Asignación Combinados

Los operadores de asignación combinados permiten realizar una operación y asignar el resultado a la misma variable en un solo paso.

Ejemplo básico:

$x = 3;
$x += 5; // Suma 5 a $x, 
$x=$x+3; //Esto es la misma acción que la instrucción anterior
echo $x; // Mostrará: 8

Esto es equivalente a:

$x = $x + 5;

Otros operadores combinados:

$y = "Hola";
$y .= ", ¿Qué tal?"; // Concatenación
echo $y; // Mostrará: Hola, ¿Qué tal?

Ejemplo con Operadores de Asignación Combinados

$b = 1;
for ($a = 0; $a < 10; $a++) {
    $b *= 10; // Multiplica $b por 10 en cada iteración
    echo "Valor de \$b = " . $b . "<br>";
}

Salida del código anterior:

Valor de $b = 10
Valor de $b = 100
Valor de $b = 1000
Valor de $b = 10000
Valor de $b = 100000
Valor de $b = 1000000
Valor de $b = 10000000
Valor de $b = 100000000
Valor de $b = 1000000000
Valor de $b = 10000000000

Asignación por Referencia

La asignación por referencia permite que dos variables apunten al mismo valor, sin crear copias. Esto se realiza con el operador "&".

Ejemplo:

$x = 3;
$y = &$x; // $y apunta a la misma referencia que $x
 
echo "$x, $y"; // Mostrará: 3, 3
 
$x = 5;
echo "$x, $y"; // Mostrará: 5, 5

(: Las referencias son similares a un alias o acceso directo en el sistema de archivos.)

Operadores de Comparación

Los operadores de comparación permiten comparar dos valores y devuelven un resultado booleano (`true` o `false`). El resultado depende de los tipos de los valores comparados y de las reglas de conversión de tipos de PHP.

Tabla de Operadores de Comparación

$x == $y

$x === $y

$x != $y

$x <> $y

$x !== $y

$x < $y

$x > $y

$x <= $y

$x >= $y

Comparación Flexible (==) vs Estricta (===)

Cuando se comparan dos valores, es importante entender la diferencia entre == (comparación flexible) y === (comparación estricta).

Ejemplo:

$num = 1;
 
if ($num == true) {
    echo '$num es igual a true<br>';
}
 
if ($num === true) {
    echo "Esto nunca se ejecutará";
} else {
    echo '$num no es exactamente igual a true';
}

Salida esperada:

$num es igual a true
$num no es exactamente igual a true

Notas:

• `==` compara valores, permitiendo conversiones de tipo.
• `===` compara valores y tipos, sin conversiones.

Comparaciones Entre Tipos

La forma en que PHP compara diferentes tipos puede variar dependiendo de las reglas de conversión.

Importante: Las comparaciones entre tipos no numéricos pueden ser confusas. Consulta la [documentación oficial de comparación de tipos](http://php.net/manual/es/types.comparisons.php) para más detalles.

Operadores Lógicos

Los operadores lógicos permiten combinar o invertir valores booleanos. Son esenciales para construir expresiones condicionales complejas.

Tabla de Operadores Lógicos

$x and $y

(true and false)

$x or $y

(true or false)

$x xor $y

(true xor false)

!$x

(!true)

$x && $y

(true && false)

$x || $y

(true || false)

Notas Importantes

1. Cortocircuito:

    Si la primera condición de un operador como `&&` o `||` determina el resultado, las demás no se evalúan.  
    Ejemplo:

     $result = (false && foo()); // foo() nunca se ejecutará
     $result = (true || foo()); // foo() nunca se ejecutará

2. Diferencia entre `and` y `&&`, `or` y `||`:

    `&&` y `||` tienen mayor precedencia que `and` y `or`.
    Esto afecta cómo se agrupan las expresiones:

     $a = false || true; // Actúa como: $a = (false || true)
     $b = false or true; // Actúa como: ($b = false) or true
 
     var_dump($a, $b); // $a es true, $b es false

3. `xor`:

    Es Or exclusivo: Devuelve `true` si sólo uno de los operandos es `true`. Si ambos son `true` o ambos son `false`, devuelve `false`.
    Este operador no se usa mucho.

Ejemplos de Diferencia de Preferencia

1. Ejemplo con `and` vs `&&`:

   $x = true && false; // Actúa como: $x = (true && false)
   $y = true and false; // Actúa como: ($y = true) and false
 
   var_dump($x, $y); // $x es false, $y es true

2. Ejemplo con `or` vs `||`:

   $x = false || true; // Actúa como: $x = (false || true)
   $y = false or true; // Actúa como: ($y = false) or true
 
   var_dump($x, $y); // $x es true, $y es false

Operadores de Control de Errores

• El operador @ permite suprimir mensajes de error (si no es fatal, o sea de warning) que puedan generarse al evaluar una expresión.
• Es útil para evitar mostrar errores en ciertas situaciones, pero debe usarse con precaución.

Funcionamiento

• Cuando se coloca @ antes de una expresión, cualquier error generado por esa expresión será ignorado.
• Si la directiva [`track_errors`](http://php.net/manual/es/errorfunc.configuration.php#ini.track-errors) está activada, el último error generado se almacenará en la variable especial $php_errormsg.

Ejemplo Básico

<?php
// Intentar abrir un archivo que no existe
   $rtdo = @ (5+"25pepe")
   echo $rtdo
?>

En este ejemplo:

• Se produce un warning, ya que uno de los operadores no es un entero (pero puedo convertirlo parcialmente).

<?php
// Intentar abrir un archivo que no existe
   $rtdo = @(5+"pepe")
   echo $rtdo
?>

En este ejemplo:

• Se produce un error, y por lo tanto no actúa el operador.

Usos Típicos

1. **Acceso a claves no existentes en un array:**

   <?php
   $array = ["clave1" => "valor1"];
   $valor = @$array["clave_no_existe"];
   echo "El valor es: $valor"; // No genera error aunque la clave no exista
   ?>

2. Supresión de errores en funciones y expresiones:

   <?php
   @$resultado = 10 / "5hola"; // Suprime el warning de tipo 
   ?>

3. Abrir ficheros que no existen:

<?php
   // Intentar abrir un archivo que no existe
    $miArchivo = @file('archivo_que_no_existe')
 
?>

Limitaciones del Operador @

• El operador **@** sólo funciona con expresiones (variables, llamadas a funciones, constantes, etc.).
• No puede usarse en estructuras de control como `if`, `foreach`, o definiciones de clases o funciones.

Ejemplo Inválido:

<?php
// Esto no funcionará:
@function miFuncion() {
    echo "No se puede usar @ aquí.";
}
 
 
?>

Plantilla:Notas

Operadores Bit a Bit

Los operadores bit a bit permiten la evaluación y manipulación de bits específicos dentro de un número entero (`integer`).

Tabla de Operadores Bit a Bit

$x & $y

$x | $y

$x ^ $y

~$x

$x << $y

$x >> $y

Ejemplos Prácticos

1. Operador AND (&):

   $x = 6; // 6 en binario: 110
   $y = 3; // 3 en binario: 011
   $resultado = $x & $y; // Resultado: 2 (010 en binario)
   echo "$x & $y = $resultado"; // Mostrará: 6 & 3 = 2

2. Operador OR (|):

   $x = 6; // 6 en binario: 110
   $y = 3; // 3 en binario: 011
   $resultado = $x | $y; // Resultado: 7 (111 en binario)
   echo "$x | $y = $resultado"; // Mostrará: 6 | 3 = 7

3. Operador XOR (^):

   $x = 6; // 6 en binario: 110
   $y = 3; // 3 en binario: 011
   $resultado = $x ^ $y; // Resultado: 5 (101 en binario)
   echo "$x ^ $y = $resultado"; // Mostrará: 6 ^ 3 = 5

4. Operador NOT (~):

   $x = 6; // 6 en binario: 110
   $resultado = ~$x; // Resultado: -7 (depende de la representación complementaria a dos)
   echo "~$x = $resultado"; // Mostrará: ~6 = -7

5. Shift Left o desplazamiento a la izquierda (<<):

   $x = 2; // 2 en binario: 10
   $resultado = $x << 1; // Desplaza los bits hacia la izquierda 1 posición: 100 (4 en decimal)
   echo "$x << 1 = $resultado"; // Mostrará: 2 << 1 = 4

6. Shift Right o desplazamiento a la derecha (>>):

   $x = 4; // 4 en binario: 100
   $resultado = $x >> 1; // Desplaza los bits hacia la derecha 1 posición: 10 (2 en decimal)
   echo "$x >> 1 = $resultado"; // Mostrará: 4 >> 1 = 2

Notas Importantes

• Los operadores bit a bit trabajan directamente sobre la representación binaria de los números.
• Los desplazamientos (`<<` y `>>`) pueden ser útiles para operaciones de bajo nivel como optimización de cálculos o manejo de banderas.
• El operador `~` puede producir resultados inesperados debido a la representación de enteros en PHP (complemento a dos).

Actividad Práctica

Objetivo: Escribir un programa que: 1. Realice operaciones AND, OR, XOR y NOT con dos números. 2. Desplace un número hacia la izquierda y hacia la derecha.

Plantilla de Ejemplo:

<?php
// 1. Operaciones bit a bit
$a = 5; // 101 en binario
$b = 3; // 011 en binario
 
echo "$a & $b = " . ($a & $b) . "<br>"; // AND
echo "$a | $b = " . ($a | $b) . "<br>"; // OR
echo "$a ^ $b = " . ($a ^ $b) . "<br>"; // XOR
echo "~$a = " . (~$a) . "<br>"; // NOT
 
// 2. Desplazamiento
echo "$a << 1 = " . ($a << 1) . "<br>"; // Shift left
echo "$a >> 1 = " . ($a >> 1) . "<br>"; // Shift right
?>

Operadores de Ejecución (``)

El operador `` permite ejecutar comandos del sistema directamente desde PHP. Es equivalente a usar la función [shell_exec()](http://php.net/manual/es/function.shell-exec.php).

Funcionamiento

• Los comandos dentro de las comillas invertidas `` se ejecutan en el sistema operativo, y el resultado se devuelve como una cadena de texto.
• Es útil para interactuar con el sistema desde un script PHP, pero debe usarse con precaución, especialmente en entornos de producción.

Ejemplo Básico

El siguiente código ejecuta el comando `df` (para mostrar información sobre discos y particiones en sistemas Linux):

<?php
$Discos = `df`; // Ejecuta el comando `df`
echo "<pre>$Discos</pre>"; // Muestra el resultado en un formato legible
?>

El código anterior generará una salida similar a esta (en sistemas Linux):

Filesystem     1K-blocks     Used Available Use% Mounted on
/dev/sda5       86378608  6072360  75895384   8% /
none                   4        0         4   0% /sys/fs/cgroup
udev             4023720        4   4023716   1% /dev
tmpfs             806904     1384    805520   1% /run
none                5120        0      5120   0% /run/lock
none             4034504     6588   4027916   1% /run/shm
none              102400       28    102372   1% /run/user
/dev/sda7      101797224 40480360  56122728  42% /home

Equivalencia con shell_exec()

El operador de comillas invertidas `` es funcionalmente igual a usar la función [shell_exec()](http://php.net/manual/es/function.shell-exec.php).

Por ejemplo:

<?php
$Discos = shell_exec('df'); // También ejecuta el comando `df`
echo "<pre>$Discos</pre>";
?>

Notas Importantes

1. Restricciones del sistema:

  Si [safe_mode](http://php.net/manual/es/ini.sect.safe-mode.php#ini.safe-mode) está activado o la función `shell_exec()` está deshabilitada, el operador de ejecución no funcionará.
  Este operador sólo es funcional en entornos donde PHP tiene permisos para ejecutar comandos del sistema.

2. Compatibilidad con el sistema operativo:

  En sistemas Linux/Unix, puedes usar comandos como `ls`, `df`, `cat`, etc.
  En sistemas Windows, usa comandos como `dir`, `type`, etc.

3. Precauciones de seguridad:

  Nunca uses entradas del usuario directamente dentro del operador de ejecución.
  Usa funciones como [escapeshellcmd()](http://php.net/manual/es/function.escapeshellcmd.php) para evitar inyecciones de comandos.

Actividad Práctica

1. Escribe un programa que use el operador `` para listar los archivos del directorio actual (Linux: `ls`, Windows: `dir`). 2. Modifica el programa para mostrar el contenido de un archivo específico. 3. Usa [escapeshellcmd()](http://php.net/manual/es/function.escapeshellcmd.php) para proteger las entradas del usuario.

Plantilla de Ejemplo:

<?php
// Listar archivos en el directorio actual
$listado = `ls -al`; // En Linux/Unix
// $listado = `dir`; // En Windows
echo "<pre>$listado</pre>";
 
// Mostrar contenido de un archivo (protegido)
$archivo = escapeshellcmd("archivo.txt");
$contenido = `cat $archivo`; // En Linux/Unix
// $contenido = `type $archivo`; // En Windows
echo "<pre>$contenido</pre>";
?>