Apuntes sobre Php

Lleva décadas en el obituario y sigue aquí.

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.

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

$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 con formato consistente ($snake_case o $lowerCamelCase). Y recuerda: = asigna, no compara; para comparar usa == o ===.

Operador de Concatenación

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

<?php

$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: Para cadenas que se repiten mucho, una constante mejora la legibilidad:

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

$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 comprobando el divisor antes de operar:

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

$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 (++$a): cambia el valor y devuelve el nuevo. Post-incremento ($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

$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. == convierte tipos automáticamente y puede dar resultados inesperados:

<?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 siempre === con datos de formularios. Las comparaciones estrictas son más seguras y predecibles.

Nota: ”Falsy” es un término informal que describe cualquier valor que se comporta como false en un contexto booleano, sin ser false propiamente dicho.

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: Este operador puede estar deshabilitado en servidores con configuración restrictiva. Valida siempre cualquier entrada del usuario para evitar inyecciones de comandos:

<?php
$comando = filter_input(INPUT_GET, "cmd", FILTER_SANITIZE_FULL_SPECIAL_CHARS) ?? "";
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

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

Nota: Prefiere && y || sobre and y or: tienen mayor precedencia y son la convención habitual. En expresiones complejas, añade paréntesis para dejar clara la intención:

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

Recapitulación

  • = asigna; == compara valor; === compara valor y tipo. Usa siempre === con datos externos.
  • El operador . concatena cadenas; .= concatena y asigna en un solo paso.
  • Operadores aritméticos: +, -, *, /, %. Comprueba que el divisor no sea cero antes de dividir.
  • Pre-incremento (++$a) cambia el valor antes de usarlo; post-incremento ($a++) lo usa primero y luego lo cambia.
  • Valores "falsy": false, 0, "0", "", null, []. Con == todos se comportan como false; con === no.
  • Operadores lógicos: prefiere && y || sobre and y or.
  • El operador spaceship (<=>) devuelve -1, 0 o 1 según la comparación.
  • Para desactivar las conversiones automáticas de tipo usa declare(strict_types=1) al inicio del archivo (ver lección de Variables).

En la próxima lección: printf() y sprintf(): formatear cadenas con precisión, controlar decimales, anchuras y más.

TOP