Apuntes php

PHP: Porque a veces necesitas un poco de caos en tu vida.

Lección: Operadores en PHP

Los operadores son los elementos que permiten a nuestro programa decidir lógicamente, permitiéndonos asignar valores, realizar cálculos, comparar datos, y controlar el flujo. En esta lección, exploraremos los operadores de PHP, agrupados por su funcionalidad.

Introducción

Los operadores son símbolos que realizan operaciones sobre uno o más valores (llamados operandos).
Por ejemplo, el operador + suma dos números, mientras que = asigna un valor a una variable. PHP ofrece una amplia variedad de operadores, desde aritméticos hasta lógicos, cada uno con reglas específicas.


Nota: Usa declare(strict_types=1) para evitar errores de tipo en operaciones, especialmente al comparar valores. 

<?php
declare(strict_types=1);
?>

Esto asegura que PHP no realice conversiones automáticas de tipos, lo que puede llevar a errores.

Operador de Asignación

El operador = asigna un valor a una variable. Es el más básico y usado en PHP:

<?php
declare(strict_types=1);

$ciudad = "Madrid";    // Asigna una cadena
$mi_numero = 123;      // Asigna un entero
$var1 = $var2 = 0;     // Asigna 0 a ambas variables
?>

Nota:: - Usa nombres de variables en minúsculas o con un formato consistente (por ejemplo, $snake_case o $lowerCamelCase) para mejorar la legibilidad.
- Recuerda: El operador = no compara; para comparaciones, usa == o ===.

Operador de Concatenación

El operador . une cadenas de texto, mientras que .= concatena y asigna al mismo tiempo:

<?php
declare(strict_types=1);

$nombre = "Jorge";
$apellido = "Pérez";
$nombre_completo = $nombre . " " . $apellido;
echo $nombre_completo . "\n"; // Imprime: Jorge Pérez

$mensaje = "uno, dos, tres";
$mensaje .= ", cuatro, cinco, seis";
echo $mensaje . "\n"; // Imprime: uno, dos, tres, cuatro, cinco, seis
?>

Nota: - Usa constantes para cadenas repetitivas: 

<?php
const ESPACIO = " ";
$nombre_completo = $nombre . ESPACIO . $apellido;
?>

Si los datos vienen de un formulario, verifica su tipo antes de usarlos. Si esperas texto, usa (string). Si esperas un número, usa (int) o is_numeric():

<?php
$nombre = (string)$_POST["nombre"] ?? "";
?>

Operadores Aritméticos

Los operadores aritméticos realizan cálculos matemáticos: suma (+), resta (-), multiplicación (*), división (/), y módulo (%):

<?php
declare(strict_types=1);

$num1 = 10;
$num2 = 5;

echo "Suma: " . ($num1 + $num2) . "\n";          // Imprime: Suma: 15
echo "Resta: " . ($num1 - $num2) . "\n";         // Imprime: Resta: 5
echo "Multiplicación: " . ($num1 * $num2) . "\n"; // Imprime: Multiplicación: 50
echo "División: " . ($num1 / $num2) . "\n";      // Imprime: División: 2
echo "Módulo: " . ($num1 % $num2) . "\n";        // Imprime: Módulo: 0

$num3 = 7;
echo "Módulo de 10 entre 7: " . ($num1 % $num3) . "\n"; // Imprime: Módulo de
                                                        // 10 entre 7: 3
?>

Nota: - Evita divisiones por cero verificando el divisor 

<?php
if ($num2 !== 0) {
    echo $num1 / $num2;
} else {
    echo "Error: División por cero\n";
}
?>

Operadores de Incremento y Decremento

Los operadores ++ y -- aumentan o disminuyen el valor de una variable en 1. Pueden usarse antes (pre) o después (post) de la variable:

<?php
declare(strict_types=1);

$a = 5;
echo "Pre-incremento: " . (++$a) . "\n"; // Imprime: 6 ($a = 6)
echo "Valor actual: $a\n";               // Imprime: 6

$b = 5;
echo "Post-incremento: " . ($b++) . "\n"; // Imprime: 5 ($b = 6)
echo "Valor actual: $b\n";                // Imprime: 6

$c = 5;
echo "Pre-decremento: " . (--$c) . "\n"; // Imprime: 4 ($c = 4)
$d = 5;
echo "Post-decremento: " . ($d--) . "\n"; // Imprime: 5 (pero si
                                          // volvieramos a imprimir $d, valdría 4)
?>

Nota: - Pre-incremento/decremento (++$a, --$a): Cambia el valor y lo devuelve. -
Post-incremento/decremento ($a++, $a--): Devuelve el valor original y luego lo cambia.
- Úsalos con cuidado en expresiones complejas para evitar confusión.

Operadores de Comparación

Los operadores de comparación devuelven un valor booleano (true o false) al comparar dos valores:

  • ==: Igualdad (solo compara el valor).
  • ===: Identidad (compara valor y tipo).
  • != o <>: Desigualdad.
  • <, >, <=, >=: Menor, mayor, menor o igual, mayor o igual. 
<?php
declare(strict_types=1);

$num_string = "123";
$num_int = 123;

var_dump($num_string == $num_int);   // bool(true)
var_dump($num_string === $num_int);  // bool(false)
var_dump(10 != 5);                   // bool(true)
var_dump(5 < 10);                    // bool(true)
var_dump(10 > 5);                    // bool(true)
var_dump(5 <= 5);                    // bool(true)
var_dump(10 >= 5);                   // bool(true)
?>

Nota: - Usa === y !== para comparaciones estrictas, especialmente con datos de formularios, ya que == puede convertir tipos automáticamente: 

<?php //En PHP, el número 0 se evalúa como false en contextos booleanos.
     // cualquier número distinto de 0 es true

$entrada = "0"; // $entrada contiene una cadena con el valor "0"
                // Aunque parece un número, sigue siendo un string

if ($entrada == false) { // Comparación flexible (==)
// PHP convierte "0" a un valor falsy (false)
    echo "¡Cuidado! Esto se evalúa como true con ==  \n";
// Se ejecuta porque "0" equivale a false en comparación flexible
}

if ($entrada === false) { // Comparación estricta (===)
// Evalúa tanto el valor como el tipo de dato
    echo "Esto no se ejecuta con ===  \n";
// No se ejecuta porque "0" es una cadena, no un booleano
}
?>

En PHP, tanto una cadena vacía ("") como NULL aparententemente son valores "sin contenido", pero se comportan de manera diferente en comparaciones y contextos booleanos. Es importante porque si una función espera un valor de retorno, NULL puede indicar "sin datos", mientras que "" puede significar "dato vacío".
En comparaciones flexibles (==), una cadena vacía ("") y NULL pueden actuar igual, pero NO son iguales en comparaciones estrictas (===). La función isset() distingue NULL de valores vacíos, porque un NULL significa que la variable no está definida.
Un ejemplo a ver si queda claro:

<?php
$cadenaVacia = ""; // Cadena vacía (string vacío)
$nulo = NULL; // Valor NULL (sin contenido)

echo "Valor original de \$cadenaVacia: \"$cadenaVacia\"\n";
echo "Valor original de \$nulo: NULL\n";

// Comparación flexible (==)
// Tanto la cadena vacía como NULL se consideran falsy en PHP
if ($cadenaVacia == false) {
    echo "¡Cuidado! Una cadena vacía ('') se evalúa como false con ==\n";
}

if ($nulo == false) {
    echo "¡Atención! NULL también se evalúa como false con ==\n";
}

// Comparación estricta (===)
// Se verifica tanto el valor como el tipo
if ($cadenaVacia === false) {
    echo "Esto NO se ejecuta porque un valor vacío no es un valor nulo\n";
}

if ($nulo === false) {
    echo "Esto NO se ejecuta porque NULL es un tipo especial, no un booleano\n";
}

// Conversión explícita a booleano
var_dump((bool) ""); // bool(false)
var_dump((bool) NULL); // bool(false)
var_dump((bool) "texto"); // bool(true)
?>

Nota: - Usa === para evitar sorpresas con tipos de datos. - Las comparaciones estrictas son más seguras, especialmente al trabajar con datos de formularios.

  • Spaceship (<=>): Compara dos valores, devolviendo -1 (menor), 0 (igual), o 1 (mayor): 
<?php
echo 5 <=> 10; // Imprime: -1
?>

Operador de Ejecución

El operador de ejecución (`, backticks) ejecuta comandos del sistema operativo y devuelve su salida como cadena. Es equivalente a shell_exec(): 

<?php
$output = `ls -l`; // En Linux/Unix
// $output = `dir`; // En Windows
echo "<pre>$output</pre>";
?>

Nota: - Seguridad: Este operador puede estar deshabilitado en servidores seguros (safe_mode o funciones restringidas). Recuerda validar cualquier entrada del usuario para evitar inyecciones: 

<?php
$comando = filter_input(INPUT_GET, "cmd", FILTER_SANITIZE_STRING) ?? "";
if (in_array($comando, ["ls", "dir"])) {
    $output = `$comando`;
    echo "<pre>$output</pre>";
}
?>

usa <pre> para mostrar la salida formateada.

Operadores Lógicos

Los operadores lógicos combinan o niegan expresiones booleanas:

  • and o &&: Verdadero si ambos operandos son true.
  • or o ||: Verdadero si al menos un operando es true.
  • xor: Verdadero si exactamente un operando es true.
  • !: Niega el valor booleano.
<?php
declare(strict_types=1);

$edad = 25;
$tiene_licencia = true;

if ($edad >= 18 && $tiene_licencia) {
    echo "Puede conducir.\n";
} else {
    echo "que vaya andando.\n";
}

$es_admin = true;
$es_editor = false;

if ($es_admin || $es_editor) {
    echo "Tiene permisos de publicación.\n";
}

var_dump(true xor false); // bool(true)
var_dump(true xor true);  // bool(false)
var_dump(!false);         // bool(true)
?>

Notas: - Usa && y || en lugar de and y or por su mayor precedencia, que es más común en otros lenguajes. - Usa paréntesis en expresiones complejas para claridad: 

<?php
if (($edad >= 18) && ($tiene_licencia === true)) {
    echo "Condición clara\n";
}
?>

Operadores a Nivel de Bit

Los operadores a nivel de bit manipulan la representación binaria de los números. Pero seguro que si necesitases usarlos, no estarías leyendo estos apuntes !
Algunos usos son manejar permisos, colores (en hexadecimal), o en general datos binarios.

Siguiente

Formatear cadenas con precisión usando printf() y sprintf().

TOP