Usuario:ManuelRomero/ProgramacionWeb/Sintaxis/expresiones

LENGUAJE PHP: EL LENGUAJE EN GENERAL

¡El servidor te responde

PHP Un lenguaje de script al lado del servidor

Introducción  | Sintaxis | Escribiendo  | Declaraciones  | Estructuras de control  | Expresiones  | Más sobre sintaxis  | funciones propias de php | Ejercicios  | Práctica  | Volver

Operadores y expresiones

¿Qué es una expresión?

Son partes de las frases de un lenguaje de programación Definición Es un conjunto de operador/es y operando/s que se evalúan y dan como resultado un valor

Notas importantes

Una expresión tiene un tipo asociado En php el tipo lo marca el operador Los operandos se intentan adaptar al tipo No es una instrucción, es parte de ella

Operadores

• Son símbolos que realizan acciones sobre operandos y dan como resultado un valor
• Tenemos diferentes tipos de operadores en función del tipo de operandos y del resultado

OPERADORES HABITUALES EN PHP

TIPO DE OPERADOR	OPERADOR	Tipo de Expresión
Operadores aritméticos	+ - * / % **	Numérica
Operadores lógicos	AND OR && || !	Lógica
Operadores de comparación	== != << < > <= >= <=> ??	Lógica
Operadores de auto incremento/decremento	++$a $a++ --$a $a--	Numérica
Operadores de string: concatenación	. .=	String

OTROS OPERADORES MENOS HABITUALES

TIPO DE OPERADOR	OPERADOR	Tipo de Expresión
Operadores asignación simple	=	valor asignado
Operadores asignación compuesta	+= *= -= %= **= .=	numérico
Operadores asignación por referenica	&	Valor referenciado
Operadores bit a bit	& | ^ ~ << >>	numérico
Operador de control de errors	@	no retorna, anula comunicaicón de errores si se produjeran
Operador de ejecución	``	resultado del comando ejecutado

Operadores de expresiones numéricas

Puntos clave

Intervienen con valores numéricos y retorna un número como resultado de su evaluación

1. Aritméticos (+,-,*,/,%,**)
2. Autoincremente/decremento(++ --)
3. Asignación compuesta (los aritmétcios segidos de una asignación += -= *= ....)

Puntos clave

1.- Operadores aritméticos Cuando haya varios en una operación, hay que tener cuidado con la preferencia. Mejor esplicitarla con paréntesis

Qué ejecutaría el siguiente código

$num = 5+6*8-4/2; Mejor ponerlo así $num = 5+(6*8)-(4/2); Ejecución $num = 5+6*8-4/2; echo "<h1>Valor de número $num</h1>"; $num = 5+(6*8)-(4/2); $num = 5+48-2; $num = 53-2; echo "<h1>Valor de número $num</h1>"; Salida

• El operador quizá menos utilizado es el módulo(%) y el exponente(**).

(: El módulo se usa mucho para ver si un número es o no divisible por otro.)

Actividad

Buscar todos los números divisibles por 3 del 1 al 100 Posible solución $lista = null; for($n=1; $n<=100; $n++){ if ($n%3==0) $lista.="$n, "; } echo "<h1>$lista</h1>"; Salida (: En el ejemplo anterior, al final sale una coma de más, que ya veremos cómo quitarla.)

El exponente consiste en elevar un número a otro

Actividad

Obtenerlo las diferentes potencias de 2 hasta elevarlo a 15 21 22 23...215 Posible solución for($n=1; $n<=15; $n++){ echo "2<sup>$n</sup>=".(2**$n)."<br />"; } Salida

Autoincremente / Decremento

• el ++, -- son valores de autoincremeto y autodecremento, pueder ser pre o post
• El el caso pre, primero incrementa y luego toma el valor
• El el caso post, primero toma el valor y luego incrementa

Puntos clave

Title: forma de usar los operadores Pre es anteponiendo el operador ++$a; --$a Post es posponiéndolo $a++; $a--;

Para muchos casos es lo mismo hacerlo pre que post. Esto ocurre cuando en la instrucción solo haga eso

$a=5;
$a++;
echo "Valor de a es $a";

Es igual que

$a=5;
++$a;
echo "Valor de a es $a";

En ambos casos la salida dará el valor 6

Pero

$a=5;
echo "Valor de a es ".++$a."<br />";
echo "Valor de a es $a<br />";

No es igual que

$a=5;
echo "Valor de a es ".$a++."<br />";
echo "Valor de a es $a<br />";

Pregunta

Lo ves claro

}}

Realiza el siguiente programa Entendiendo qué hace

//Declara una variable entera y asigna el valor 4   //Usando el operador unario, incrementa una unidad y compáralo con el valor 5 //Muestra un mensaje mostrando su valor   //Compáralo con el valor 4 y decrementa en una unidad , muestra información de que no es igual y muestra el valor //Analiza la salida y prueba deferentes situaciones

Operadores

$a=5;
if ($a++==5)
    echo '$a que vale '.$a.' dice que vale 5 ???? <br>'
        . 'Esto es por que primero compara y luego incrementa<br>';
 
echo 'ahora $a vale '.$a.'<br>';
 
if (++$a==6)
    echo 'esto nunca saldrá ya que $a se incrementa antes de comparar';
else
    echo 'efectivamente ahora $a ya no vale 6 sino '.$a.'<br>';
?>

Operadores

• El código anterior genera la siguiente salida

 $a que vale 6 dice que vale 5 ???? 
 Esto es por que primero compara y luego incrementa
 ahora $a vale 6
 efectivamente ahora $a ya no vale 6 sino 7

Operadores con asignación en una misma variable

• Cuando la variable donde asignamos el resultado de la expresión forma parte de la expresión, la podemos simplificar
• Veamos el siguiente ejemplo

$a=$a*5;

• Es igual que hacer

$a*=5;

• Esto lo podemos hacer con cualquiera de los operadores aritméticos

Operadores comparación (==,<,>,>=,<=,<>,!=,===,!==)

Este tipo de operadores genera un booleano como resultado de evaluar la expresión

Puntos clave

== operador de comparación igual que (mismo valor) === operador de comparación exactamente igual que (mismo valor y tipo)

Operador == Vs ===

$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';

Operador == vs ===

• El código anterior generaría la siguiente salida

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

• Ver la sección comparación de tipos de la página oficial

http://php.net/manual/es/language.operators.comparison.php

operadores de concatenacón( .) concatena cadena de caracteres.

El operador + no está sobre cargado, observa el siguiente código

$nombre="Maria";
$apellido = " de la Oh";
 
$nombreCompleto = $nombre.$apellido;
echo "el valor de nombre completo es $nombreCompleto ---<br>";
 
$nombreCompleto = $nombre+$apellido;
echo "el valor de nombre completo es $nombreCompleto --<br>";

La salida del código anterior sería

el valor de nombre completo es Maria de la Oh ---
el valor de nombre completo es 0 --

Operadores de asignación (= , =>)

Se pueden combinar con los aritméticos (+=, *=, ...) y con los de concatenación (.=)

En este caso el valor de la variable de la izquierda se toma como primero operando

Operador de asignación

<?php
$b=1;
for ($a=0;$a<10;$a++){
    $b*=10;
    echo 'valor de $b ='.$b.'<br>';
}
?>

• El código anterior genera la siguiente salida

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

Operadores de ejecución (``)

PHP proporciona un operador especial que permite ejecutar sentencias

• Observa el siguiente código

<?php
$Discos = `df`;
echo "<pre>$Discos</pre>";
?>

• El código anterior generará la siguiente salida

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

Invocando funciones del sistema

• El operador anterior (comillas invertidas) es igual que la función shell_exec()

http://php.net/manual/es/function.shell-exec.php

Operadores lógicos (and,&&, or, ||, xor !)

http://php.net/manual/es/language.operators.logical.php

Funcionan por cortocircuito

El operador xor da verdad si los operando son de diferente valor uno true y el otro false

La notación and y && representan el mismo operador, igual ocurre con or y ||

• La diferencia entre los operadores es la prioridad

http://php.net/manual/es/language.operators.precedence.php

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.

Notas importantes sobre expresiones en PHP

Una expresión tiene un tipo asociado. Este tipo depende del resultado de su evaluación. En PHP, el operador determina el tipo de la expresión en muchos casos. Los operandos intentan adaptarse al tipo esperado por el operador mediante conversiones automáticas (casting implícito). Una expresión no es una instrucción completa, sino parte de ella. Por ejemplo: //Instruccion: $resultado = 5+3; // Expresión => 5+3 // Operador => + // Operandos => el 5 y el 3 // Resultado => 8 //Tipo de expresión => Aritmética, lo marca el operador

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

OPERADORES HABITUALES EN PHP

Tipo de Operador	Operador	Tipo de Expresión
Operadores aritméticos	+ - * / % **	Numérica
Operadores lógicos	AND OR && || !	Lógica
Operadores de comparación	== != < > <= >= <=> ??	Lógica
Operadores de auto incremento/decremento	++$a $a++ --$a $a--	Numérica o String
Operadores de string (concatenación)	. .=	String

OTROS OPERADORES MENOS HABITUALES

Tipo de Operador	Operador	Tipo de Expresión
Operadores de asignación simple	=	Valor asignado
Operadores de asignación compuesta	+= -= *= /= %= **= .=	Numérica
Operadores de asignación por referencia	&	Valor referenciado
Operadores bit a bit	& | ^ ~ << >>	Numérica
Operador de control de errores	@	Silencia errores
Operador de ejecución	`comando`	Resultado del comando ejecutado

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

Precedencia y Asociatividad de Operadores en PHP

Asociatividad	Operadores
No asociativo	`clone`, `new`
Izquierda	`[`
Derecha	`**`
Derecha	`++`, `--`, `~`, `(int)`, `(float)`, `(string)`, `(array)`, `(object)`, `(bool)`, `@`
No asociativo	`instanceof`
Derecha	`!`
Izquierda	`*`, `/`, `%`
Izquierda	`+`, `-`, `.`
Izquierda	`<<`, `>>`
No asociativo	`<`, `<=`, `>`, `>=`
No asociativo	`==`, `!=`, `===`, `!==`, `<>`
Izquierda	`&`
Izquierda	`^`
Izquierda	`
Izquierda	`&&`
Izquierda	`	`
Izquierda	`?:`
Derecha	`=`, `+=`, `-=`, `*=`, `**=`, `/=`, `.=`, `%=`, `&=`, `/=`, `^=`, `<<=`, `>>=`, `=>`
Izquierda	`and`
Izquierda	`xor`
Izquierda	`or`
Izquierda	`,`

Operadores Aritméticos

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

Operadores Aritméticos

Operación	Representación	Descripción
Suma	$x + $y	Devuelve la suma de $x y $y.
Resta	$x - $y	Devuelve la diferencia entre $x y $y.
Multiplicación	$x * $y	Devuelve el producto de $x y $y.
División	$x / $y	Devuelve el cociente de $x dividido por $y. Si ambos son divisibles, devuelve un entero; de lo contrario, un flotante.
Módulo	$x % $y	Devuelve el resto de dividir $x entre $y. Si $x o $y son flotantes, se transforman en enteros antes de la operación.
Exponenciación	$x ** $y	Eleva $x a la potencia de $y.
Negación	-$x	Cambia el signo de $x.

Notas importantes:

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

Ejemplo:

-5 % 3

devolverá

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

Incremento y Decremento

Tipo	Representación	Descripción
Pre-incremento	++$a	Incrementa el valor de $a antes de usarlo.
Post-incremento	$a++	Usa el valor de $a y luego lo incrementa.
Pre-decremento	--$a	Decrementa el valor de $a antes de usarlo.
Post-decremento	$a--	Usa el valor de $a y luego lo decrementa.

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

Tabla de Operadores de Asignación en PHP

Categoría	Operador	Ejemplo	Descripción
Asignación básica	=	$x = 10;	Asigna el valor de la derecha a la variable de la izquierda.
Asignación básica (arrays)	=>	$array = ["clave" => "valor"];	Asigna un valor a una clave en un array asociativo.
Asignación por referencia	&	$y = &$x;	Asigna una referencia a otra variable, ambas apuntan al mismo valor.
Asignación compuesta	+=	$x += 5;	Suma 5 al valor de $x y asigna el resultado a $x.
Asignación compuesta	-=	$x -= 3;	Resta 3 al valor de $x y asigna el resultado a $x.
Asignación compuesta	*=	$x *= 2;	Multiplica $x por 2 y asigna el resultado a $x.
Asignación compuesta	/=	$x /= 4;	Divide $x entre 4 y asigna el resultado a $x.
Asignación compuesta	%=	$x %= 3;	Asigna a $x el resto de la división de $x entre 3.
Asignación compuesta (concatenación)	.=	$y .= " mundo";	Concatena " mundo" al valor de $y y asigna el resultado a $y.
Asignación compuesta (exponenciación)	**=	$x **= 3;	Eleva $x a la potencia de 3 y asigna el resultado a $x.

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

Operadores de Comparación

Ejemplo	Nombre	Resultado
$x == $y	Igual	Devuelve `true` si $x y $y tienen el mismo valor, independientemente del tipo.
$x === $y	Idéntico	Devuelve `true` sólo si $x y $y tienen el mismo valor y el mismo tipo.
$x != $y	Distinto	Devuelve `true` si $x y $y son diferentes, independientemente del tipo.
$x <> $y	Distinto	Igual que `!=`.
$x !== $y	No idéntico	Devuelve `true` si $x y $y no son iguales o no son del mismo tipo.
$x < $y	Menor que	Devuelve `true` si $x es menor que $y.
$x > $y	Mayor que	Devuelve `true` si $x es mayor que $y.
$x <= $y	Menor o igual que	Devuelve `true` si $x es menor o igual que $y.
$x >= $y	Mayor o igual que	Devuelve `true` si $x es mayor o igual que $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.

Comparación Entre Tipos

$x	$y	Resultado
_null_ o _string_	_string_	_null_ se convierte en `""`, luego se compara numéricamente o léxicamente.
_bool_ o _null_	cualquiera	Ambos valores se convierten a booleanos. `false` < `true`.
_object_	_object_	Dos objetos son iguales si tienen los mismos atributos y valores. Son idénticos si además apuntan a la misma instancia.
_string_, _resource_ o _number_	_string_, _resource_ o _number_	Se convierten a números y se comparan matemáticamente.
_array_	_array_	Se comparan elemento por elemento. Si los arrays tienen distinto número de elementos o claves no coincidentes, son incomparables.
_object_	cualquiera	Los objetos son siempre mayores que otros tipos.
_array_	cualquiera	Los arrays son siempre mayores que otros tipos.

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

Operadores Lógicos en PHP

Operador	Descripción	Ejemplo	Resultado
$x and $y	Devuelve `true` si ambos $x y $y son `true`.	(true and false)	`false`
$x or $y	Devuelve `true` si al menos uno de $x o $y es `true`.	(true or false)	`true`
$x xor $y	Devuelve `true` si sólo uno de $x o $y es `true`.	(true xor false)	`true`
!$x	Devuelve `true` si $x es `false`.	(!true)	`false`
$x && $y	Igual que `and`, pero con mayor precedencia.	(true && false)	`false`
$x || $y	Igual que `or`, pero con mayor precedencia.	(true || false)	`true`

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í.";
}
 
 
?>

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

Operadores Bit a Bit

Ejemplo	Nombre	Descripción
$x & $y	And	Realiza una operación AND entre cada bit de $x y $y.
$x | $y	Or	Realiza una operación OR entre cada bit de $x y $y.
$x ^ $y	Xor	Realiza una operación XOR entre cada bit de $x y $y.
~$x	Not	Invierte todos los bits de $x.
$x << $y	Shift left	Desplaza los bits de $x hacia la izquierda $y posiciones.
$x >> $y	Shift right	Desplaza los bits de $x hacia la derecha $y posiciones.

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