No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Operadores lógicos: ¿qué son las tablas de verdad?

15/24
Recursos

Los operadores lógicos nos ayudan a combinar dos o más afirmaciones para definir si una oración es cierta o falsa. Su uso está basado en las tablas de verdad.

Estructura básica

En la mayoría de sus usos se necesitan al menos dos afirmaciones y un operador:

Ejemplo de una oración usando un operador lógico

Tipos de operadores lógicos

En programación, los tipos de operadores más usados son: AND (Y lógico), OR (O lógico) y NOT (Negación lógica).

Y (And)

Se utiliza para verificar si dos afirmaciones son ciertas. Si ambas afirmaciones son ciertas, entonces la oración completa es cierta. Si una de ellas es falsa, entonces la oración completa es falsa.

Operador Y (And) en PHP

En PHP para representar este operador podemos usar la palabra reservada and o && (doble ampersand):

// Las siguientes líneas son para visualización mas no para que las ejecutes en tu PC
# Opción 1:
$valor_1 and $valor_2
# Opción 2:
$valor_1 && $valor_2

Tabla de verdad con el operador AND

Entonces si evaluamos 2 variables con el operador lógico Y (AND) podremos obtener estos posibles resultados dependiendo del valor que almacenen estas:

Valor 1 Valor Operador Valor 2 Resultado
Verdadero AND Verdadero Verdadero
Verdadero AND Falso Falso
Falso AND Verdadero Falso
Falso AND Falso Falso

Este tipo de tablas son las conocidas tablas de verdad. Es importante saber que no es necesario memorizarlas, sino más bien aprender la forma en la que las generamos. Veamos unos ejemplos:

  • ¿Los gatos son felinos AND tienen 4 patas? El resultado es Verdadero, pues ambas afirmaciones son verdaderas.
<?php
# Ejemplo en PHP
# ----------------
# Declaración de variables:
$gatos_felinos = true;
$gatos_tienen_4_patas = true;

var_dump( $gatos_felinos and $gatos_tienen_4_patas ); # Se imprimirá en consola/navegador el tipo de dato y valor de la evaluación.

echo "\n"; # Salto de línea.
# ----------------
# Impresión en consola/navegador:
# bool(true)
  • ¿Los gatos son aves AND tienen 4 patas? Es Falso, pues, los gatos no son aves, por tanto, basta que una afirmación sea falsa para que el resultado sea Falso.
<?php
# Ejemplo en PHP
# ----------------
# Declaración de variables:
$gatos_aves = false;
$gatos_tienen_4_patas = true;

var_dump( $gatos_aves and $gatos_tienen_4_patas ); # Se imprimirá en consola/navegador el tipo de dato y valor de la evaluación.

echo "\n"; # Salto de línea.
# ----------------
# Impresión en consola/navegador:
# bool(false)
  • ¿Los gatos vuelan AND programan con PHP? Es Falso, pues, los gatos no vuelan. Basta que una afirmación no sea verdad para decir que nuestro resultado será falso. Esto a pesar de que puede haber gatos muy cool que programen en PHP 😎 (¡Es broma! 😅).
<?php
# Ejemplo en PHP
# ----------------
# Declaración de variables:
$gatos_vuelan = false;
$gatos_programan_con_PHP = false;

var_dump( $gatos_vuelan and $gatos_programan_con_PHP ); # Se imprimirá en consola/navegador el tipo de dato y valor de la evaluación.

echo "\n"; # Salto de línea.
# ----------------
# Impresión en consola/navegador:
# bool(false)

O (Or)

Se usa para verificar si al menos una afirmación es cierta. Si al menos una de ellas es cierta, entonces la oración es cierta, de lo contrario, es falsa.

Operador O (Or) en PHP

En PHP se puede representar usando or o también ||:

// Las siguientes líneas son para visualización mas no para que las ejecutes en tu PC
# Opción 1:
$valor_1 or $valor_2
# Opción 2:
$valor_1 || $valor_2

Tabla de verdad con el operador OR

Si evaluamos 2 variables con el operador lógico O (OR) podremos obtener estos posibles resultados dependiendo del valor que almacenen estas:

Valor 1 Valor Operador Valor 2 Resultado
Verdadero OR Verdadero Verdadero
Verdadero OR Falso Verdadero
Falso OR Verdadero Verdadero
Falso OR Falso Falso

Veamos unos ejemplos empleando este operador OR:

  • ¿Los gatos son felinos OR tienen 4 patas? Es Verdadero, pues ambas afirmaciones son verdaderas.
<?php
# Ejemplo en PHP
# ----------------
# Declaración de variables:
$gatos_felinos = true;
$gatos_tienen_4_patas = true;

var_dump( $gatos_felinos or $gatos_tienen_4_patas ); # Se imprimirá en consola/navegador el tipo de dato y valor de la evaluación.

echo "\n"; # Salto de línea.
# ----------------
# Impresión en consola/navegador:
# bool(true)
  • ¿Los gatos son aves OR tienen 4 patas? Si bien es cierto que los gatos no son aves, sí tienen 4 patas, por tanto, al tener una afirmación verdadera, el resultado será Verdadero.
<?php
# Ejemplo en PHP
# ----------------
# Declaración de variables:
$gatos_aves = false;
$gatos_tienen_4_patas = true;

var_dump( $gatos_aves or $gatos_tienen_4_patas ); # Se imprimirá en consola/navegador el tipo de dato y valor de la evaluación.

echo "\n"; # Salto de línea.
# ----------------
# Impresión en consola/navegador:
# bool(true)
  • ¿Los gatos vuelan OR tienen 6 colas? Al ser ambas afirmaciones falsas, el resultado esta evaluación es Falso.
<?php
# Ejemplo en PHP
# ----------------
# Declaración de variables:
$gatos_vuelan = false;
$gatos_tienen_6_colas = false;

var_dump( $gatos_vuelan or $gatos_tienen_6_colas ); # Se imprimirá en consola/navegador el tipo de dato y valor de la evaluación.

echo "\n"; # Salto de línea.
# ----------------
# Impresión en consola/navegador:
# bool(false)

No (Not)

Se emplea para invertir el valor de una afirmación. Por ejemplo, si una afirmación es verdadera, al negarlo el resultado será Falso, lo mismo pasa a la inversa.

Operador No (Not) en PHP

Usamos el signo de exclamación ! antes de la variable que queremos negar:

// La siguiente línea es para visualización mas no para que las ejecutes en tu PC
!$valor

Tabla de verdad con el operador NOT

Los posibles resultados de la tabla de verdad usando este operador serían:

Operador Valor Resultado
NOT Verdadero Falso
NOT Falso Verdadero

Comprobémoslo con unos ejemplos:

  • ¿NOT los gatos son aves? La afirmación es falsa, pues los gatos no son aves, pero como tenemos el operador Not negando esto, el resultado cambia a ser Verdadero. Otra forma de leer esto sería: ¿Los gatos NO son aves? Y obtendremos el mismo resultado.
<?php
# Ejemplo en PHP
# ----------------
# Declaración de variables:
$gatos_aves = false;

var_dump( !$gatos_aves ); # Se imprimirá en consola/navegador el tipo de dato y valor de la evaluación.

echo "\n"; # Salto de línea.
# ----------------
# Impresión en consola/navegador:
# bool(true)
  • ¿NOT los gatos tienen 4 patas? Los gatos Sí tienen 4 patas; sin embargo, tenemos al operador Not negando nuestra afirmación, por tanto, el resultado será Falso. Una vez más, otra forma de leer esto sería: ¿Los gatos NO tienen 4 patas?
<?php
# Ejemplo en PHP
# ----------------
# Declaración de variables:
$gatos_tienen_4_patas = true;

var_dump( !$gatos_tienen_4_patas ); # Se imprimirá en consola/navegador el tipo de dato y valor de la evaluación.

echo "\n"; # Salto de línea.
# ----------------
# Impresión en consola/navegador:
# bool(false)

Reto: análisis de operadores lógicos

¿Cuál es el resultado de estas operaciones? ¡Déjalo en la sección de aportes de la clase!

<?php
// Suponiendo estas variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer
$es_un_gato_grande || $sabe_volar
$sabe_volar || $tiene_2_patas
!$le_gusta_comer
!$le_gusta_comer || $es_un_gato_grande

Contribución creada por: Martín Álvarez

Aportes 166

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Operadores Lógicos

Son los operadores que nos ayudan a combinar dos o mas afirmaciones para definir si una oración es cierta o falsa. Su uso esta basado en tablas de verdad.

AND (y)

Se usa para verificar si dos afirmaciones son ciertas, entonces la oración completa es cierta. Si una de ellas es falsa, entonces, la oración completa es falsa.

true AND true = True

false AND true = False

true AND false = False

false AND false = False

Se escribe así:

  • $valor_1 and $valor_2
  • $valor_1 && $valor_2

OR (o)

Si una de las 2 afirmaciones es cierta, entonces la oración completa es cierta. Si solo una de ellas es falsa, entonces, la oración completa es cierta.

true OR true = True

false OR true = True

true OR false = True

false OR false = False

Se escribe así:

  • $valor_1 or $valor_2
  • $valor_1 || $valor_2

NOT (no)

Se usa para invertir el significado de una oración

NOT True ⇒ False

NOT False ⇒ True

Hola ! Estos son mis resultados del reto


<?php
$es_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

//AND
var_dump($es_michi_grande && $le_gusta_comer);
bool(true)

//OR
var_dump($es_michi_grande || $sabe_volar);
bool(true)

//OR
var_dump($sabe_volar || $tiene_2_patas);
bool(false)

//NOT
var_dump(!$le_gusta_comer);
bool(false)

//NOT+AND
var_dump(!$le_gusta_comer && $es_michi_grande);
bool(false)

echo ("\n");

Un pequeño aporte directo de la documentación de PHP

En PHP los operadores tienen un orden para ejecutarse, igual que pasa en matemáticas donde la multiplicación se resuelve primero que la suma. Lo que pasa en el experimento que nos hizo volar la cabeza es que el operador and se ejecuta después del operador de asignación =

($resultado = $michis_4_patas) and $michis_programan_con_PHP;

La parte que dejé entre paréntesis se ejecuta primero que el and porque el operador = tiene la prioridad, entonces la variable solo está tomando el valor de $michis_4_patas. Si usamos && funciona de la manera esperada por tiene mayor prioridad (precedencia) que and.
Aquí podemos ver el orden de los operaciones de PHP:

Les comparto mi ejercicio:

Solución del Reto


  1. true
  2. true
  3. false
  4. false
  5. true

Operadores lógicos

Los Operadores Lógicos son elementos usados para la evaluación de
Expresiones, confirmando si estas son verdaderas o falsas. Una Expresión
consta de al menos dos Afirmaciones, como podría ser «Los seres humanos no
pueden vivir sin oxígeno»
o «One-Punch Man tiene una frondosa cabellera».
Una Afirmación no es mas que una oración que puede contener una verdad o una
falsedad.

La evaluación de expresiones se pueden reducir a las tablas de verdad; las
cuales operan sobre expresiones de dos afirmaciones. PHP usa los operadores
and y or para las tablas de verdad ‘y’ y ‘o’ respectivamente.

Tabla de verdad ‘y’ (and)

Use el operador and para comprobar, sí ambas afirmaciones en una expresión
son verdad toda la expresión es verdad, pero sí una de las afirmaciones es
falsa toda la expresión es falsa.

Valor Operador Valor Resultado
true and true true
true and false false
false and true false
false and false false

Tabla de verdad ‘o’ (or)

Use el operador or para comprobar, sí al menos una de las afirmaciones en una
expresión es verdad toda la expresión es verdad, pero sí ambas afirmaciones son
falsas toda la expresión es falsa.

Valor Operador Valor Resultado
true or true true
true or false true
false or true true
false or false false

PHP también soporta los operadores && y || para las evaluaciones y y o
respectivamente.

Tabla de verdad ‘y’ (&&)

Valor Operador Valor Resultado
true && true true
true && false false
false && true false
false && false false

Tabla de verdad ‘o’ (||)

Valor Operador Valor Resultado
true || true true
true || false true
false || true true
false || false false

Operador de negación (not)

Para negar o invertir el valor de una afirmación se usa el operador ‘no’ (!).

Operador Valor Resultado
! true false
! false true

El código PHP siguiente está probando la diferencia entre los operadores and y &&.

$result1 = true and false;
$result2 = true && false;

var_dump($result1); // bool(true)
var_dump($result2); // bool(false)

El operador and tiene una precedencia más baja que =, lo que significa que en realidad se asigna el valor true a $result1 antes de que se evalúe el operador and. Esto significa que $result1 se asigna true y luego se ignora el valor false. Por lo tanto, var_dump($result1) muestra bool(true).

Por otro lado, && tiene una precedencia más alta que =, lo que significa que $result2 se asigna con el resultado de la operación lógica true && false, que es false. Por lo tanto, var_dump($result2) muestra bool(false).

// variables
$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// resul
$es_un_michi_grande && $le_gusta_comer;
True
$es_un_michi_grande || $sabe_volar;
True
$sabe_volar || $tiene_2_patas;
False
!$le_gusta_comer 
False
!$le_gusta_comer || $es_un_michi_grande;
True
Esto es lo mismo que la Electrónica Analógica, ES LA MISMA MICHI PERO REVOLCADA 😂
  1. true
  2. true
  3. false
  4. false
  5. true

Reto

Reto
<?php

// Variables

$es_un_michi_grande =true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// Ejercicios

$es_un_michi_grande && $le_gusta_comer;

$es_un_michi_grande || $sabe_volar;

$sabe_volar || $tiene_2_patas;

$le_gusta_comer;

$le_gusta_comer || $es_un_michi_grande;

// Resultados

var_dump($es_un_michi_grande && $le_gusta_comer);

# bool(false)

var_dump($es_un_michi_grande || $sabe_volar);

# bool(true)

var_dump($sabe_volar || $tiene_2_patas);

# bool(false)

var_dump($le_gusta_comer);

# bool(true)

var_dump($le_gusta_comer || $es_un_michi_grande);

# bool(true)
!Hola, estos son mis resultados del reto: ![](https://static.platzi.com/media/user_upload/image-6f098720-db35-4119-8804-59ef7d79aa9d.jpg)
// XOR = ^var\_dump($michis\_felinos ^ $michis\_4\_patas); #Bool False Así es con el operador disyuntivo por si no lo consideraron.

Respuesta:
//¿Cuál es el resultado?

$es_un_michi_grande && $le_gusta_comer; //True
$es_un_michi_grande || $sabe_volar; //True
$sabe_volar || $tiene_2_patas; //false
!$le_gusta_comer; //False
!$le_gusta_comer || $es_un_michi_grande;//True
![](https://twitter.com/Portico_AEFCFT/status/1314178303423520768/photo/1)

<?php
// Suponiendo estas variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer ------> TRUE
$es_un_gato_grande || $sabe_volar ---------> TRUE
$sabe_volar || $tiene_2_patas -----------> FALSE
!$le_gusta_comer ------------> FALSE
!$le_gusta_comer || $es_un_gato_grande --------> TRUE

  1. true
  2. true
  3. false
  4. false
  5. true
![](https://static.platzi.com/media/user_upload/image-4c750da3-4f1c-4158-9a6a-6eccf1c5a19b.jpg)
````txt
![](https://static.platzi.com/media/user_upload/image-31ca03bf-b38b-479b-b966-1eda47da542b.jpg)
```js
\

Mi Solución:

<?php
// Suponiendo estas variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer     // True
$es_un_gato_grande || $sabe_volar         // True
$sabe_volar || $tiene_2_patas             // False
!$le_gusta_comer                          // False
!$le_gusta_comer || $es_un_gato_grande    // True
// Suponiendo estas variables $es\_un\_gato\_grande = true; $le\_gusta\_comer = true; $sabe\_volar = false; $tiene\_2\_patas = false; // ¿Cuál es el resultado? var\_dump($es\_un\_gato\_grande && $le\_gusta\_comer); bool(true) var\_dump($es\_un\_gato\_grande || $sabe\_volar); bool(true) var\_dump($sabe\_volar || $tiene\_2\_patas); bool(false) var\_dump(!$le\_gusta\_comer);bool(false)var\_dump(!$le\_gusta\_comer || $es\_un\_gato\_grande); bool(true)
<?php
//variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;
// resultado
$es_un_gato_grande && $le_gusta_comer = true;
$es_un_gato_grande || $sabe_volar = true;
$sabe_volar || $tiene_2_patas = false;
!$le_gusta_comer = false;
!$le_gusta_comer || $es_un_gato_grande = true;
> 

Como hago para sacar el OR en programación? 😦

TRUE TRUE FALSE FALSE TRUE
Homework * True * True * False * False * True Thank you Carlos
Esas dos *rayitas verticales*, se llaman **barras verticales**
¡Reto resuelto! //Suponiendo estas variables $es\_un\_michi\_grande = true; $le\_gusta\_comer = true; $sabe\_volar = false; $tiene\_2\_patas = false; //¿Cuál es el resultado? $es\_un\_michi\_grande && $le\_gusta\_comer = true $es\_un\_michi\_grande || $sabe\_volar = true $sabe\_volar || $tiene\_2\_patas = false !$le\_gusta\_comer = false !$le\_gusta\_comer || $es\_un\_michi\_grande = true
<?php
// Suponiendo estas variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer		    //true
$es_un_gato_grande || $sabe_volar		        //true
$sabe_volar || $tiene_2_patas			        //false
!$le_gusta_comer				                //false		
!$le_gusta_comer || $es_un_gato_grande	        //true	
\
php tiene varias cosas en común con javascript, estos operadores lógicos por ejemplo... la intuición me dice que aprender ambos a la vez no debería ser confuso. ¿ustedes que creen?
![](https://static.platzi.com/media/user_upload/image-14debe1f-1d9a-4538-976b-71318dad0c90.jpg)![](https://static.platzi.com/media/user_upload/image-e4de9929-4889-46a0-9af3-0f23096c6f26.jpg)
RESULTADOS DEL RETO: 1= TRUE 2= TRUE 3= FALSE 4= FALSE 5= TRUE

Operadores Lógicos

.
Los operadores lógicos en PHP se utilizan para comparar expresiones lógicas y producir un valor booleano (verdadero o falso) como resultado. Los operadores lógicos más comunes en PHP son && (y), || (o) y ! (no).

El operador && (y) devuelve true solo si ambas expresiones a ambos lados del operador son verdaderas. Por ejemplo:

$edad = 25;
$tiene_carro = true;

if ($edad > 18 && $tiene_carro) {
    echo "Puedes conducir";
} else {
    echo "No puedes conducir";
}

En este ejemplo, se utiliza el operador && para verificar si la edad es mayor que 18 y si la persona tiene un carro. Solo si ambas expresiones son verdaderas, se imprimirá “Puedes conducir”.

El operador || (o) devuelve true si al menos una de las expresiones a ambos lados del operador es verdadera. Por ejemplo:

$es_hombre = false;
$es_mayor = true;

if ($es_hombre || $es_mayor) {
    echo "Puede ingresar";
} else {
    echo "No puede ingresar";
}

En este ejemplo, se utiliza el operador || para verificar si la persona es hombre o si es mayor de edad. Si al menos una de las expresiones es verdadera, se imprimirá “Puede ingresar”.

El operador ! (no) devuelve true si la expresión a su derecha es falsa. Por ejemplo:

$es_hombre = false;

if (!$es_hombre) {
    echo "Es mujer";
} else {
    echo "Es hombre";
}

En este ejemplo, se utiliza el operador ! para verificar si la persona es hombre. Si la expresión $es_hombre es falsa, se imprimirá “Es mujer”.

En resumen, los operadores lógicos en PHP son herramientas útiles para comparar expresiones lógicas y producir resultados booleanos. Se pueden utilizar en combinación con declaraciones condicionales (if, else, elseif) para controlar el flujo del programa.

Reto de la clase

<?php
// Suponiendo estas variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer //True
$es_un_gato_grande || $sabe_volar // True
$sabe_volar || $tiene_2_patas // False
!$le_gusta_comer // False
!$le_gusta_comer || $es_un_gato_grande //True
//Solución

//Reto

//Suponiendo estas variables

$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?

var_dump($es_un_michi_grande && $le_gusta_comer);
//bool(true)

var_dump($es_un_michi_grande || $sabe_volar);
//bool(true)

var_dump($sabe_volar || $tiene_2_patas);
//bool(false)

var_dump(!$le_gusta_comer);
//bool(false)

var_dump(!$le_gusta_comer || $es_un_michi_grande);
//true(true)
$es_un_michi_grande = true;
$le_gusta_comer_al_michi = true;
$sabe_volar_el_michi = false;
$tiene_dos_patas_el_michi = false;


var_dump ($es_un_michi_grande and $le_gusta_comer_al_michi); **"true"**

var_dump ($es_un_michi_grande or $sabe_volar_el_michi); **"true"**

var_dump($sabe_volar_el_michi or $tiene_dos_patas_el_michi);**"false"**

var_dump (!$le_gusta_comer_al_michi);**"false"**

var_dump(!$le_gusta_comer_al_michi || $es_un_michi_grande);**"true"**

echo"\n";

Estimados estos son los resultados de mi reto:

leyendo la documentacion encontre algo muy curioso, el operador xor este funciona viendo si alguna de las condiciones es verdadera retornara true pero si todas las condiciones da true devuelve false,

Es parecido a or pero excluyendo las condiciones donde por ejemplo las dos condiciones sean verdaderas.

se veria algo asi

True xor False => true
False xor False => False
True xor True => False

aqui la fuente https://www.php.net/manual/es/language.operators.logical.php

Les dejo mi código que hice para esta clase:

<?php
$michis_felinos = true;
$michis_4_patas = true;
$michis_vuelan = false;
$michis_programan_con_PHP = false;

//AND
echo "************Operador AND************";
echo "\n";

    echo "Los michis son felinos y tienen 4 patas? ";
    var_dump( $michis_felinos && $michis_4_patas );

echo "\n";

//OR
echo "************Operador OR************";
echo "\n";

    echo "Los michis son felinos o vuelan? ";
    var_dump( $michis_felinos || $michis_vuelan );

echo "\n";

//NOT
echo "************Operador NOT************";
echo "\n";

    echo "Los michis no tienen 4 patas? ";
    var_dump( !$michis_4_patas );

echo "\n";

PostData: Que les parece? 😁

Los michis son felinos y tienen 4 patas?
Falso

$es_un_muchi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_dos_patas = false;

echo"<hr>";

var_dump($es_un_muchi_grande && $le_gusta_comer);
echo “<br>”;
var_dump($es_un_muchi_grande || $sabe_volar);
echo “<br>”;
var_dump($sabe_volar || $tiene_dos_patas);
echo “<br>”;
var_dump(!$le_gusta_comer);
echo “<br>”;
var_dump(
!$le_gusta_comer || $es_un_muchi_grande);

Solución del reto

<?php
// Suponiendo estas variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer  // true
$es_un_gato_grande || $sabe_volar  // true
$sabe_volar || $tiene_2_patas  // false
!$le_gusta_comer  // false
!$le_gusta_comer || $es_un_gato_grande  // true
$es_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

var_dump($es_michi_grande && $le_gusta_comer);
var_dump($es_michi_grande || $sabe_volar);
var_dump($sabe_volar || $tiene_2_patas);
var_dump(!$le_gusta_comer);
var_dump(!$le_gusta_comer || $es_michi_grande);
bool(true)
bool(true)
bool(false)
bool(false)
bool(true)

5/5

$es_un_gato_grande && $le_gusta_comer
// true
$es_un_gato_grande || $sabe_volar
// true
$sabe_volar || $tiene_2_patas
// false
!$le_gusta_comer
// false
!$le_gusta_comer || $es_un_gato_grande
// true

<?php
$es_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

//AND
var_dump($es_michi_grande && $le_gusta_comer);
bool(true)

//OR
var_dump($es_michi_grande || $sabe_volar);
bool(true)

//OR
var_dump($sabe_volar || $tiene_2_patas);
bool(false)

//NOT
var_dump(!$le_gusta_comer);
bool(false)

//NOT+AND
var_dump(!$le_gusta_comer && $es_michi_grande);
bool(false)

echo ("\n");

la explicación con michis no la entendi jajajajaj xD, pero bueno al menos ya tenía claro los operadores logicos jejejej xD

Me cae muy bien el profe Ratzink, gracias maestrìsimo, que bueno escuchar sus cursos.

Mis respuestas al reto:

<?php
// Suponiendo estas variables

$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?

$es_un_gato_grande && $le_gusta_comer //true
$es_un_gato_grande || $sabe_volar //true
$sabe_volar || $tiene_2_patas //false
!$le_gusta_comer //false
!$le_gusta_comer || $es_un_gato_grande //true

Buenas noches:

Este fue mi resultado del ejercicio

<?php

// Suponiendo estas variables
$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$a = $es_un_michi_grande && $le_gusta_comer; //True
$b = $es_un_michi_grande || $sabe_volar; //True
$c = $sabe_volar || $tiene_2_patas; // False
$d = !$le_gusta_comer; //False
$e = !$le_gusta_comer || $es_un_michi_grande; // True

var_dump($a, $b, $c, $d, $e);

?>

// Suponiendo estas variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer => TRUE
$es_un_gato_grande || $sabe_volar => TRUE
$sabe_volar || $tiene_2_patas => FALSE
!$le_gusta_comer => FALSE
!$le_gusta_comer || $es_un_gato_grande => TRUE

$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer // Respuesta: TRUE
$es_un_gato_grande || $sabe_volar // Respuesta: TRUE
$sabe_volar || $tiene_2_patas // Respuesta: FALSE
!$le_gusta_comer // Respuesta: FALSE
!$le_gusta_comer || $es_un_gato_grande // Respuesta: TRUE

Mi aporte

<?php

$michisFelinos = true;
$michis4Patas = true;
$michisVuelan = false;
$michisPrograman = false;

var_dump($michisFelinos && $michis4Patas); //true

echo "<br>";

var_dump($michisPrograman && $michisFelinos);//false

echo "<br>";

var_dump($michisPrograman || $michisVuelan); //false

echo "<br>";

var_dump($michisPrograman or $michisFelinos); //true

echo "<br>";

var_dump(!$michisPrograman and !$michisFelinos); //false

echo "<br>";

-Los michis no vuelan
-Also los Michis
😄

muy buena profe capo

Cuando se concatenan es bueno tener en cuenta una “separacion” con parentesis de las sentencias. En esta clase no se ve, pero es algo como:

$es_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

var_dump($tiene_2_patas && $le_gusta_comer || !$sabe_volar)
//imprime: bool(false);

Pero es un poco complejo saber por qué dio false, realmente ocurre porque se empieza a comparar de izquierda a derecha y esto se podría interpretar como:

var_dump(false && true || false);
// que debería separase como:
var_dump((false && true) || false);

En este ejempolo sea como sea y pongase donde se pongan los parentesis va a dar falso, pero para que como humanos lo podamos entender debería quedar asi:

if (
($tiene_2_patas && $le_gusta_comer)
|| !$sabe_volar
){…}

Buen día

Aqui dandole al reto

<?php
$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

//¿Cual es el resultado?
var_dump($es_un_michi_grande && $le_gusta_comer); // bool(true)
echo “<br>”;
var_dump($es_un_michi_grande || $sabe_volar);// bool(true)
echo “<br>”;
var_dump($sabe_volar || $tiene_2_patas);//bool(false)
echo “<br>”;
var_dump(!$le_gusta_comer);//bool(false)
echo “<br>”;
var_dump(!$le_gusta_comer || $es_un_michi_grande);// bool(true)
echo “<br>”;

$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer //rpta: true
$es_un_gato_grande || $sabe_volar //rpta: true
$sabe_volar || $tiene_2_patas //rpta: false
!$le_gusta_comer // rpta: false
!$le_gusta_comer || $es_un_gato_grande //rpta: true

![](

1.- true
2.- true
3.- false
4.- false
5.- true

Reto:
$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_valor = false;
$tiene_2_patas = false;

//¿Cuál es el resultado?
$es_un_michi_grande && $le_gusta_comer // True
$es_un_michi_grande || $sabe_valor // True
$sabe_volar || $tiene_2_patas // False
!$le_gusta_comer // False
!$le_gusta_comer || $es_un_michi_grande // False

Ejercicio:

$es_un_michi_grande && $le_gusta_comer
Es true

$es_un_michi_grande || $sabe_volar
Es true

$sabe_volar || $tiene_2_patas
Es false

!$le_gusta_comer
Es false

!$le_gusta_comer || $es_un_michi_grande
Es true

en el experimento estás asignando 2 variables a la variable resultado, no se está comparando, se esta agregando michis_4_patas y michis_programan_con_PHP a resultado

El operador AND devuelve verdadero si los dos statements son verdaderos y falso si al menos unos de los statements es falso.

El operador OR devuelve verdadero si unos de los dos statements es verdadero y falso si ambos son falsos

Mi Reto

<?php
// Suponiendo estas variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer; // True
$es_un_gato_grande || $sabe_volar; // True
$sabe_volar || $tiene_2_patas; // True
!$le_gusta_comer; // False
!$le_gusta_comer || $es_un_gato_grande; // True

1.- true
2.- true
3.- false
4.- false
5.- true

ez

var_dump($es_un_michi_grande && $le_gusta_comer);
//true
var_dump($es_un_michi_grande || $sabe_volar);
//true
var_dump($sabe_volar || $tiene_2_patas);
//false
var_dump(!$le_gusta_comer);
//false
var_dump(!$le_gusta_comer || $es_un_michi_grande);
//true

Hola.

1 = true
2 = true
3 = false
4 = false
5 = true

Resultado:

<?php
// Suponiendo estas variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer
//(bool)true

$es_un_gato_grande || $sabe_volar
//(bool)true

$sabe_volar || $tiene_2_patas
//(bool)false

!$le_gusta_comer
//(bool)false

!$le_gusta_comer || $es_un_gato_grande
//(bool)true

Este fue mi resultado del reto 💚

	// Suponiendo estas variables
$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false; 
$tiene_2_patas = false;
	// ¿Cuál es el resultado?
$es_un_michi_grande && $le_gusta_comer == true
$es_un_michi_grande || $sabe_volar == true
$sabe_volar || $tiene_2_patas == false
!$le_gusta_comer == false
!$le_gusta_comer || $es_un_michi_grande == true```

Reto: análisis de operadores lógicos

$es_un_gato_grande && $le_gusta_comer = True
$es_un_gato_grande || $sabe_volar = True
$sabe_volar || $tiene_2_patas = False
!$le_gusta_comer = False
!$le_gusta_comer || $es_un_gato_grande = True

<?php

$michis_felinos = true;
$michis_4patas = true;
$michis_vuelas = false;
$michis_programan_php = false;

//&& = and; || = or ! = not

var_dump ($michis_4patas && $michis_felinos);
echo “<br>”;
var_dump ($michis_4patas || $michis_programan_php);
echo “<br>”;
var_dump ($michis_4patas && $michis_vuelas);
echo “<br>”;
var_dump(! $michis_vuelas);
echo “<br>”;
var_dump(!$michis_vuelas && $michis_4patas);

  1. true
  2. true
  3. false
  4. false
  5. true

$es_un_gato_grande && $le_gusta_comer resultado true
$es_un_gato_grande || $sabe_volar
resultado true
!$le_gusta_comer
resultado false
!$le_gusta_comer || $es_un_gato_grande
resultado true

Reto
$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

//Resultado

var_dump($es_un_michi_grande && $le_gusta_comer); //true
var_dump($es_un_michi_grande || $sabe_volar);//true
var_dump($sabe_volar || $tiene_2_patas);//false
var_dump(!$le_gusta_comer);//false
var_dump(!$le_gusta_comer || $es_un_michi_grande);//true

echo “\n”;

//¿Cual es el resultado?

  • true
  • true
  • false
  • false
  • true

Para los que quedan con la duda sobre la diferencia entre usar ‘AND’ o ‘&&’ consegui este codigo.

<?php
  
// Expression to use && operator
$bool = TRUE && FALSE;
  
// Display the result of && operation
echo ($bool ? 'TRUE' : 'FALSE'), "\n";
  
// Expression to use AND operator
$bool = TRUE and FALSE;
  
// Display the result of AND operation
echo ($bool ? 'TRUE' : 'FALSE'), "\n"; 
?>

Se debe a la precedencia que tenga el operador (alta / baja). Se entiende mejor con el siguiente ejem.

1 + 5 * 3 , la respuesta es 16 y no 18 porque el operador de multiplicación ("*") tiene una precedencia mayor que el operador de adición ("+").

//Suponiendo estas variables
$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

//¿Cual es el resultado?

//result: true
$es_un_michi_grande && $le_gusta_comer

//result: true
$es_un_michi_grande || $sabe_volar

//result:false
$sabe_volar || $tiene_2_patas

//result:false
!$le_gusta_comer

//result:true
!$le_gusta_comer || $es_un_michi_grande

Reto de operadores lógicos como resultado tendremos operaciones boleanas con su respectivo true || false.

reto_operadores.php

<?php

$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Caul es el resultado? 
var_dump($es_un_michi_grande && $le_gusta_comer); //bool(true)
var_dump($es_un_michi_grande || $sabe_volar); //bool(true)
var_dump($sabe_volar || $tiene_2_patas); //bool(false)
var_dump(!$le_gusta_comer); //bool(flase)
var_dump($le_gusta_comer || $es_un_michi_grande); //bool(true)

/* referencias.
&& operador and(y) también conocido como conjunción.
|| operador or (o) también conocido como disyunción.
! operador not (no) también conocido como negación.
== es igual 
!= es distinto
<,<=,>,>= menor, menor o igual, mayor, mayor o igual
*/

Mitad del curso y sigo pensando que PHP es fácil 😁

Mis resultados:

$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

var_dump ( $es_un_michi_grande && $le_gusta_comer); //true
var_dump ( $es_un_michi_grande || $sabe_volar); //true
var_dump ( $sabe_volar || $tiene_2_patas); //false
var_dump( !$le_gusta_comer ); //false
var_dump( !$le_gusta_comer || $es_un_michi_grande ); //true

los michis vuelan or programan en PHP or tienen 6 patas or son Felinos = true

hola estos son mi resultados

$es_un_gato_grande && $le_gusta_comer; true
$es_un_gato_grande || $sabe_volar; true
$sabe_volar || $tiene_2_patas; false
!$le_gusta_comer; false
!$le_gusta_comer || $es_un_gato_grande; true

RETO
$es_un_michi_grande && $le_gusta_comer = true;
$es_un_michi_grande || $sabe_volar = true;
$sabe_volar || $tiene_2_patas = false;
!$le_gusta_comer = false;
!$le_gusta_comer || $es_un_michi_grande = true;

<?php

$es_un_michi_grande = true; 
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

$es_un_michi_grande && $le_gusta_comer;
var_dump($es_un_michi_grande && $le_gusta_comer); //True

$es_un_michi_grande || $sabe_volar;
var_dump($es_un_michi_grande || $sabe_volar); //True

$sabe_volar || $tiene_2_patas;
var_dump($sabe_volar || $tiene_2_patas); //False

!$le_gusta_comer; 
var_dump(!$le_gusta_comer); //False

!$le_gusta_comer || $es_un_michi_grande;
var_dump(!$le_gusta_comer || $es_un_michi_grande); //True

echo "\n";

<?> 

Solicitud a PHP

<?php

// variables
$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

var_dump($es_un_michi_grande && $sabe_volar);
var_dump($sabe_volar || $tiene_2_patas);
var_dump(!$le_gusta_comer);
var_dump(!$le_gusta_comer || $es_un_michi_grande);

?>

Respuesta:
bool(false)
bool(false)
bool(false)
bool(true)

Mi respuesta del reto es la siguiente:

<?php
// Suponiendo estas variables
$es_un_gato_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

// ¿Cuál es el resultado?
$es_un_gato_grande && $le_gusta_comer // True - Verdadero
$es_un_gato_grande || $sabe_volar // True - Verdadero
$sabe_volar || $tiene_2_patas // False - Falso
!$le_gusta_comer // False - Falso
!$le_gusta_comer || $es_un_gato_grande // True - Verdadero

fue interesante ver como en el minuto 8:26 , evaluó una variable inexistente y al ser con | | se evaluó sin problema ni error , también quedo esperando la diferencia del uso de && y el and del ultimo ejemplo.

respuestas:
$es_un_michi_grande && $le_gusta_comer true
$es_un_michi_grande | | $sabe_volar true
$sabe_volar | | $tiene_2_patas false
!$le_gusta_comer false
!$le_gusta_comer | | $es_un_michi_grande true

HI
LA SOLUCION ES:

  1. true
  2. true
  3. false
  4. false
  5. true