Operadores relacionales

Les dejo mi resumen de esta clase:

Operadores Relacionales

Igual, ==

No compara tipos, solo valores

Se denota con   ==

$a == $b

Idéntico, ===

Compara tipos y valores

Se denota con ===

Diferentes, ! =, ! ==

! = , no compara tipos,

! ==, compara tipos y valores,

Menor que, <

$a < $b

Mayor que, >

$a > $b

Mayor o Igual que, > =

$a ≥ $b

Menor o Igual que, < =

$a < = $b

Operador de Nave Espacial, < = >

<?php
	echo 2 <=> 1;
	echo "\n";

echo 2 <=> 1; // 1
echo 1 <=> 1; // 0
echo -50 <=> 1 //

• Si el numero de la izquierda es mayor el numero de la derecha, el resultado será 1
• Si el numero de la derecha es igual que el numero de la izquierda , el resultado será 0
• Si el numero de la izquierda es menor que el numero de la derecha, el resultado será 1

Fusión de Null, ??

$edad_pepito = 23;

echo $edad_juanito ?? edad_pepito; 
// Si la edad de Juanito no esta definida, usa la edad de pepito

echo "\n";

En Ruby al operador espacial se le conoce como Operador de comparación combinado (o al menos yo le conozco así) y funciona exactamente igual.
Por cierto, inicié mi aprendizaje de programación con Ruby y actualmente pienso que es muy cierta la frase de: “Si dominas un Lenguaje de programación, se te hará más fácil aprender otro”, este curso se me ha hecho más entendible y amigable, claro, aparte que @RetaxMaster es muy agradable para explicar.
Mi recomendación: Procuren aprender muy bien un lenguaje y luego se mudan a aprender otros que le interesen, les será mucho más fácil 😉

Operadores relacionales

Son usados en PHP para la comparación entre valores

// devuelve 'true' si $a es igual a $b después de la manipulación de tipos.
$a == $b

// devuelve 'true' si $a es igual a $b, y son del mismo tipo.
$a === $b  

// devuelve 'true' si $a no es igual a $b después de la manipulación de tipos.
$a != $b  

// devuelve 'true' si $a no es igual a $b después de la manipulación de tipos.
$a <> $b  

// devuelve 'true' si $a no es igual a $b, o si no son del mismo tipo.
$a !== $b  

// devuelve 'true' si $a es estrictamente menor que $b.
$a < $b

// devuelve 'true' si $a es estrictamente mayor que $b.
$a > $b

// devuelve 'true' si $a es menor o igual que $b.
$a <= $b

// devuelve 'true' $a es mayor o igual que $b.
$a >= $b

// Un integer menor que, igual a, o mayor que cero cuando $a es respectivamente menor que, igual a, o mayor que $b.
$a <=> $b

// El primer operando de izquierda a derecha que exista y no sea null. null si no hay valores definidos y no son null.
$a ?? $b ?? $c

No sabia de la existencia del operador nave espacial, muchas gracias Carlos!

Jamás en mi vida había escuchado del operador de la nave espacial. 😄

Increíble las curiosidades que encuentras en la documentación.

Se supone que soy un “experto en PHP” pero no me había puesto a detallar el funcionamiento de los nuevos operadores de PHP.

Es lindo, porque siempre se aprende algo nuevo.

Gracias, profe Carlos.

El operador nave espacial

El operador nave espacial se emplea para comparar dos expresiones. Devuelve -1, 0 o 1 cuando $a es respectivamente menor, igual, o mayor que $b.

<?php
// Números enteros
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

// Números decimales
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
 
// Cadenas de caracteres
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
?>

Por primera vez en todos los años que tengo en Platzi me he quedado enganchada con un curso. No quiero decir que los otros cursos no sean excelentes pero este profesor es lo mejor de lo mejor. Se entiende todo a la perfección.

Excelente que se haya incluido y explicado las comparaciones de tipos y el operador nave espacial. Con la explicación tan buena que da el instructor no quedan nada de dudas.
NO se si lo vayan a mencionar posteriormente, pero es bueno también mostrar el operador ternario, el cual considero extremadamente útil y muy buen sustituto del if en algunos casos específicos

Operador Nave Espacial

Podemos tomar como referencia una recta numerica con 0 como el origen central de negativos y positivos Si (a y b son iguales)→ Equivale a un valor neutro en caso 0

Si (a es menor que b) → Pasa a la izquierda de lo negativos osea -1

Si (b que ocupa la segunda posicion es mayor que a) → Pasa a ala derecha de los positivos en este caso 1

Referencia de la Documentacion Oficial
https://www.php.net/manual/es/migration70.new-features.php

La fusión de null ??, podemos compararla con el operador ternario:
($a > $b)? ‘Si es mayor’ : ‘No es mayor’;

<?php

// Si el numero de la izquierda es mayor que el numero de la derecha, el resutado sera 1
// Si los dos numeros son iguales te dara un 0
// Si es numero de la izquierda es menor que el numero de la deracha, elresultado sera -1

echo 2 <=> 1;
echo "\n";

echo 4 <=> 1;
echo "\n";

echo 2 <=> 100;
echo "\n";


// Si la edad de juanito no esta definida, dame la de pepito
$Edad_de_pepito = 23;
echo $Edad_de_juanito ?? $Edad_de_pepito;

Dale like si también te equivocas en el tipeo cuando estudias. ; - ).

Este ejemplo me ayudo a comprender la Nave espacial

****

Para que veas tus variables en consola y compares las condiciones de inmediato

crea esta variable e imprime arriba de tus var_dump

$valores = '$a = '. $a. ' $b = '. $b. ' $b2 = '. $b2. ' $c = '. $c. ' $d = '. $d. "\n"; 
echo $valores;

esta bueno para un:

if($edad_juanito ?? $edad_pepito){ 

}

Todo mundo ganando puntos con el “gracias” jejejej

senti un dejavu al ver esta clase…
precisamente al momento de ver el operador <=>
me parecio haberlo visto anteriormente en otro lenguaje de programacion xD

El operador de nave espacial promete muchas funciones prácticas. ¿Cuál se les ocurre?

Pero que profesor mas genial para aprender, sin tantas cosas he aprendido de una manera más práctica los operadores relacionales, de hecho los últimos dos operadores relacionales no los conocía, saludos!

la Fusion de null lo que en JS se conoce como un operador ternario , cierto?

El único confuso fue el operador null

No había escuchado hablar sobre el operador de nave espacial y tampoco Fusión de null.
Exelente clases !!!

Operador Nave espacial
Lo entendí así:
-1 0 1

<?php

echo "-10 <=> 5 Resultado " . (-10 <=> 5); // -1
echo "\n";
echo "2 <=> 2 Resultado " . (2 <=> 2); // 0
echo "\n";
echo "4 <=> 2 Resultado " . (4 <=> 2);   // 1
echo "\n";

Se lee de acuerdo a que la relación de los dos números sea verdadera.
(-1 0 1)
(-10 <=> 5) lo leo (-10 < 5) da como resultado -1
(2 <=> 2) lo leo (2 = 2) da como resultado 0
(4 <=> 2) lo leo (4 > 2) da como resultado 1

Me adentre a aprender PHP por que que he estado trabajando con ProcessMaker cuyo backend esta hecho en php, por el momento muy bien el curso.

Comparto mi apunte que he realizado de esta clase.
Adicionalmente encontré en la documentación que para el caso de Diferente podemos usar también el operador

<>

.

<?php
// Operadores relacionales en PHP
/*
  Al igual que en otros lenguajes, en PHP tenemos varios operadores relacionales
  los cuales comparan 2 o mas operandos y nos retornaran un valor 'true' o 'false' 
  y en ciertos casos algún otro valor.
*/

// Declaración de variables
$n1 = 7;
$n2 = 4;
$n2String = "4";
$n3 = 7;
$soyNull = null;

// Operador de Igualdad: == (Compara si son iguales ambos operandos)
echo("Operador de Igualdad\n");
var_dump( $n1 == $n2 ); // false
var_dump( $n2 == $n2String ); // true
var_dump( $n1 === $n3 ); // true

// Operador de Idéntico: === (Compara si son iguales ambos operandos junto a su tipo de dato)
echo("Operador de Idéntico\n");
var_dump( $n1 === $n2 ); // false
var_dump( $n2 === $n2String ); // false
var_dump( $n1 === $n3 ); // true

// Operador de Diferente: != || <> (Compara que los operandos sean diferentes)
echo("Operador de Diferente\n");
var_dump( $n1 != $n2 ); // true
var_dump( $n1 <> $n2 ); // true
var_dump( $n2 != $n2String ); // false
var_dump( $n1 != $n3 ); // false
var_dump( $n1 <> $n3 ); // false

// Operador de Diferente: !== (Compara que los valores sean diferentes junto a su tipo de dato)
echo("Operador de Diferente\n");
var_dump( $n1 !== $n2 ); // true
var_dump( $n2 !== $n2String ); // true
var_dump( $n1 !== $n3 ); // false

// Operador de menor que: < (Compara que el primer operando sea menor al segundo operando)
echo("Operador de menor que\n");
var_dump( $n1 < $n2 ); // false
var_dump( $n2 < $n1 ); // true
var_dump( $n2 < $n2String ); // false

// Operador de menor o igual que: <= (Compara que el primer operando sea menor o igual al segundo operando)
echo("Operador de menor o igual que\n");
var_dump( $n1 <= $n2 ); // false
var_dump( $n2 <= $n1 ); // true
var_dump( $n2 <= $n2String ); // true

// Operador de mayor que: > (Compara que el primer operando sea mayor al segundo operando)
echo("Operador de mayor que\n");
var_dump( $n1 > $n2 ); // true
var_dump( $n2 > $n1 ); // false
var_dump( $n2 > $n2String ); // false

// Operador de mayor o igual que: >= (Compara que el primer operando sea mayor o igual al segundo operando)
echo("Operador de mayor o igual que\n");
var_dump( $n1 >= $n2 ); // true
var_dump( $n2 >= $n1 ); // false
var_dump( $n2 >= $n2String ); // true

// Operador de nave espacial: <=> (Compara los 2 operandos y retorna -1 si el primer operando (izquierda) es menor al segundo operando (derecha), retorna 0 si ambos operandos son iguales y retorna 1 si el primer operando (izquierda) es mayor al segundo operando (derecha))
echo("Operador de nave espacial\n");
var_dump( $n2 <=> $n1 ); // -1
var_dump( $n1 <=> $n2 ); // 1
var_dump( $n2 <=> $n2String ); // 0

// Operador de fusión de null: ?? (Devuelve el primer operando (valor) si existe y no es null, de lo contrario devuelve el segundo operando)
echo("Operador de fusión de null\n");
var_dump( $soyNull); // null
var_dump( $soyNull ?? 2); // 2
var_dump( $soyNull ?? $n1 ); // 7
var_dump( $variableNoExistente ?? $otraVariableNoExistente ?? $n2 ?? $n1 ); // 4

echo(PHP_EOL);

Saludos
Nave espacial?
Fusion de null?
Genial, son nuevos para mi, que maravilloso es PHP
Gracias.

Este seria mi ejemplo de estos operadores mas los conoszco como operadores de comparacion.

<?php
$price = 200;

echo "price = $price \n";
echo "\n";

// Equal to
$value = $price == $price;
echo "price == price = $value \n";
var_dump($value);

// Equal to
$value = $price == "200";
echo "price(number) == '200'(string) = $value \n";
var_dump($value);

// Equal to/Equal type
$value = $price === 200;
echo "price(number) === 200(number) = $value \n";
var_dump($value);

// Equal to/Equal type
$value = $price === "200";
echo "price(number) === '200'(string) = $value \n";
var_dump($value);
echo "\n";

// Not Equal to
$value = $price != 100;
echo "price(number) != 100 = $value \n";
var_dump($value);

// Not Equal to/Not equal type
$value = $price !== "200";
echo "price(number) !== '200' = $value \n";
var_dump($value);
echo "\n";

// Greater than
$value = $price > 10;
echo "price > 10 = $value \n";
var_dump($value);

// Greater than or equal to
$value = $price >= $price;
echo "price >= price = $value \n";
var_dump($value);

// Less than
$value = $price < 1500;
echo "price < 1500 = $value \n";
var_dump($value);

// Less than or equal to
$value = $price <= $price;
echo "price <= price = $value \n";
var_dump($value);

// Operador nave espacial
echo "Si el numero que esta a la izquiera es mayor al numero que esta a la derecha es 1 \n";
echo "price <=> 100 = " . ($price <=> 100) . "\n";

echo "Si el numero que esta a la izquiera es igual al numero que esta a la derecha es 0 \n";
echo "price <=> price = " . ($price <=> $price) . "\n";

echo "Si el numero que esta a la izquiera es menor al numero que esta a la derecha es -1 \n";
echo "100 <=> price = " . (100 <=> $price) . "\n";

el operador de fusión no solo valida que la variable no esté definida, si no que si la variable no tiene un valor asignado (por ejemplo null) tampoco la toma en cuenta.

$edad_de_pepito = 23;
$edad_de_juanito = null;

echo $edad_de_juanito ?? $edad_de_pepito ?? edad_de_jaimito; // resultado 23

Es similar a lo que se usa en Javascript con el operador (?) para validar el contenido de una variable.

Operadores relacionales

No conocía el operador nave espacial. Muy bien explicado todo

Operador Nave Espacial

Podemos tomar como referencia una recta numerica con 0 como el origen central de negativos y positivos Si (a y b son iguales)→ Equivale a un valor neutro en caso 0

Si (a es menor que b) → Pasa a la izquierda de lo negativos osea -1

Si (b que ocupa la segunda posicion es mayor que a) → Pasa a ala derecha de los positivos en este caso 1

Operador de nave espacial: