Apuntes sobre 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 "Cadena vacía: \"$cadenaVacia\"\n"; // Imprime: ""
echo "Nulo: \"$nulo\"\n";                // También imprime: ""

// Comparación flexible (==)
// Tanto la cadena vacía como NULL se consideran falsy en PHP
// En los dos siguientes supuestos la condición se cumple (true):

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.

Nota: “Falsy” es un término informal (no oficial de PHP) que se usa en programación para describir cualquier valor que se comporta como false cuando se evalúa en un contexto booleano.

Valor ¿Es false? ¿Es “falsy”?
false Sí Sí
0 No Sí
"0" No Sí
"" (cadena vacía) No Sí
NULL No Sí
[] (array vacío) No Sí

Mas operadores de comparación. Spaceship

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

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