Bienvenido a la séptima lección de nuestro curso básico de PHP 8. Hoy vamos a descubrir los operadores lógicos y de comparación, esas herramientas mágicas que te dejan evaluar condiciones y hacer que tu programa tome decisiones. Si ya dominas los operadores aritméticos, esto es el siguiente nivel para que tu código piense por sí mismo. Todo va a ser súper claro, práctico y con ejemplos que te van a encantar. ¡Prepárate y arrancamos! 

Los operadores lógicos son como los árbitros de tu código: trabajan con valores booleanos (true o false) y te ayudan a combinar o cambiar condiciones. Imagina que son los que dicen «sí, haz esto» o «no, mejor aquello». Con ellos puedes unir varias ideas y decidir qué pasa en tu programa. Aquí tienes los principales en PHP: 

• && o and (Y): Es true solo si ambas condiciones son ciertas. Si una falla, todo es false. 
• || o or (O): Es true si al menos una condición es cierta. Basta con un «sí» para ganar. 
• xor (O exclusivo): Es true si solo una condición es cierta, pero no las dos a la vez. 
• ! (No): Da la vuelta al valor, cambiando true a false y viceversa. 

Dato clave: PHP lee de izquierda a derecha y respeta un orden (primero !, luego &&, luego ||). Si quieres controlarlo, usa paréntesis como en matemáticas. 

¡Manos a la obra! Vamos a crear un programa para ver cómo funcionan estos operadores en acción. Arranca XAMPP, revisa que Apache esté en verde y sigue estos pasos: 

1. Abre Visual Studio Code y ve a tu carpeta curso_php8 en C:\xampp\htdocs. 
2. Crea un archivo nuevo llamado operadores_logicos.php. 
3. Copia este código: 

<?php 
    $a = true; 
    $b = true; 
 
    echo "true && true: "; 
    var_dump($a && $b); // true 
    echo "<br>"; 
 
    echo "true || true: "; 
    var_dump($a || $b); // true 
    echo "<br>"; 
 
    echo "true xor true: "; 
    var_dump($a xor $b); // false 
    echo "<br>"; 
 
    echo "!true: "; 
    var_dump(!$a); // false 
    echo "<br>"; 
 
    // Cambiando valores 
    $a = true; 
    $b = false; 
 
    echo "true && false: "; 
    var_dump($a && $b); // false 
    echo "<br>"; 
 
    echo "true || false: "; 
    var_dump($a || $b); // true 
    echo "<br>"; 

    echo "true xor false: "; 
    var_dump($a xor $b); // true 
    
    echo "<br>"; 
    echo "!false: "; 
    var_dump(!$b); // true 
    echo "<br>"; 
?>

4. Guarda y abre tu navegador en http://localhost/curso_php8/operadores_logicos.php. 

Verás algo como:

true && true: bool(true)

true || true: bool(true)

true xor true: bool(false)

!true: bool(false)

true && false: bool(false)

true || false: bool(true)

true xor false: bool(true)

!false: bool(true)

• Usamos var_dump() para ver el resultado y el tipo (bool significa booleano). 
• Con &&, ambas deben ser true para que salga true. Si una es false, todo falla. 
• Con ||, con que una sea true, ya ganas. 
• xor es más exigente: solo es true si los valores son diferentes (uno true y otro false). 
• ! es como un interruptor: cambia lo que sea al opuesto. 

Prueba cambiar $a y $b a otros valores (false y false, por ejemplo) y recarga para ver cómo cambian los resultados. 

Los operadores de comparación son como balanzas: comparan dos valores (números, textos, lo que sea) y te dicen si son iguales, mayores o menores, devolviendo true o false. Son los que te ayudan a decidir cosas como «¿es este número mayor que aquel?» o «¿son estas dos cosas iguales?». Aquí están los más usados: 

• > (Mayor que): $a > $b 
• < (Menor que): $a < $b 
• >= (Mayor o igual): $a >= $b 
• <= (Menor o igual): $a <= $b 
• == (Igual): $a == $b 
• != (Diferente): $a != $b 

Extra: Hay también === (igual en valor y tipo) y !== (diferente en valor o tipo), pero los veremos más adelante cuando hablemos de tipos estrictos. 

Añade este código al final de tu archivo operadores_logicos.php: 

$c = 10; 
$d = 4; 
 
echo "10 > 4: "; 
var_dump($c > $d); // true 
echo "<br>"; 
 
echo "10 < 4: "; 

var_dump($c < $d); // false 
echo "<br>"; 
 
echo "10 >= 4: "; 
var_dump($c >= $d); // true 
echo "<br>"; 
 
echo "10 <= 4: "; 
var_dump($c <= $d); // false 
echo "<br>"; 
 
echo "10 == 4: "; 
var_dump($c == $d); // false 
echo "<br>"; 
 
echo "10 != 4: "; 

var_dump($c != $d); // true 
echo "<br>"; 
 
// Probando igualdad 
$c = 5; 
$d = 5; 
 
echo "5 == 5: "; 
var_dump($c == $d); // true 
echo "<br>"; 

Recarga la página y mira los resultados. ¿Ves cómo compara $c y $d en cada caso? Es como si PHP te dijera «sí, esto es cierto» o «no, esto no cuadra». 

Lo más divertido pasa cuando juntas ambos tipos de operadores. Mira este ejemplo práctico, añádelo al archivo: 

<?php 

$edad = 20; 
$tiene_licencia = true; 
 
$puede_conducir = $edad >= 18 && $tiene_licencia; 
echo "¿Puede conducir? "; 
var_dump($puede_conducir); // true 

echo "<br>"; 
 
$edad = 16; 
$puede_conducir = $edad >= 18 && $tiene_licencia; 
echo "¿Y ahora, puede conducir? "; 
var_dump($puede_conducir); // false 

?> 

Aquí usamos `>=` para comparar y `&&` para unir dos condiciones: la edad mínima y tener licencia. Si una falla, todo es `false`. 

¡Tu turno de brillar! Ve a curso_php8 en VS Code y prueba estos retos: 

1. ¿Puede votar? Crea votar.php:  

<?php 
    $edad = 17; 
    $puede_votar = $edad >= 18; 
    echo "¿Puede votar? "; 
    var_dump($puede_votar); 
?> 

Cambia $edad a distintos valores (15, 18, 20) y revisa cómo cambia el resultado. 

2. ¿Es programador completo? Crea programador.php:  

<?php 
    $sabe_frontend = true; 
    $sabe_backend = false; 
    $es_completo = $sabe_frontend && $sabe_backend; 
    echo "¿Es programador completo? "; 
    var_dump($es_completo); 
?>

Juega con true y false para ver cuándo es true. 

3. ¿Descanso o trabajo? Crea descanso.php:  

<?php 
    $es_finde = true; 
    $esta_lloviendo = false; 
    $descansa = $es_finde || $esta_lloviendo; 
    echo "¿Descansa hoy? "; 
    var_dump($descansa); 
?>

Ejecuta cada uno en localhost/curso_php8/ y revisa los resultados. 

• Paréntesis al rescate: Si combinas mucho (como $a > 5 && $b < 10), usa paréntesis para que sea claro. 
• Prueba paso a paso: Si algo no funciona, usa var_dump() para ver qué está devolviendo cada parte. 
• xor es raro: Úsalo solo cuando necesites que una sola condición sea cierta, no ambas. 

Lo que aprendiste hoy, estrella: 

• Lógicos, tus jueces: Trabajan con true o false para decidir: 
  • && (Y): Todo tiene que ser true para ganar. 
  • || (O): Con un true ya la haces. 
  • xor: Solo uno true, no los dos. 
  • ! (No): Da la vuelta a lo que sea. 
• Comparación, tus balanzas: Miran valores y dicen sí o no: 
  • > (mayor), < (menor), >= (mayor o igual), <= (menor o igual), == (igual), != (diferente). 
• Probar es la clave: Con var_dump() viste si tus condiciones dan en el clavo. 
• Juntarlos es poder: Hiciste cosas como $edad >= 18 && $tiene_licencia. ¡Decisiones al instante! 
• Practicaste a lo grande: Checaste si alguien vota, si es pro completo o si toca descanso. ¡Tú mandas! 
• Consejo del crack: Usa paréntesis cuando combines mucho, así no te enredas. 

Ahora sabes cómo usar operadores lógicos y de comparación para evaluar condiciones y darle cerebro a tu código. Esto es la base para lo que viene: las estructuras condicionales como if-else, que usaremos en la próxima lección para ejecutar acciones según estas evaluaciones. Si quieres saber más, échale un ojo a php.net o déjame un comentario con tus dudas.