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

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

Les comparto mi ejercicio:

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.

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.

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

Tabla de verdad ‘y’ (&&)

Tabla de verdad ‘o’ (||)

Operador de negación (not)

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

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)

Reto

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

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

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

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

var_dump(!$le_gusta_comer); //False

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

Bien explicado!

Les comparto mi ejercicio:

<?php
//Ejercicio con variables
$es_un_michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_2_patas = false;

//cual es el resultado?
$es_un_michi_grande && $le_gusta_comer;

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

echo"\n";

//true */

$es_un_michi_grande || $sabe_volar;

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

echo"\n";

// true*/

$sabe_volar || $tiene_2_patas;

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

echo “\n”;

//false */

!$le_gusta_comer;

/* var_dump(!$le_gusta_comer);

echo"\n";

//false */

!$le_gusta_comer || $es_un_michi_grande;

/* var_dump($le_gusta_comer || $es_un_michi_grande);

echo “\n”;

//true */

<?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?
var_dump($es_un_michi_grande && $le_gusta_comer); //True

echo "<br>";

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

echo "<br>";

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

echo "<br>";

var_dump(!$le_gusta_comer); //False

echo "<br>";

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

Resultados:

1. True
2. True
3. False
4. False
5. True

Me encantan sus ejemplos con los Michis

Pongo mis aportes!!
\

$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

reto:
1-true
2-true
3-false
4-false
5-true

RETO

$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

Este es el resultado de mi reto:

Yo lo resolví así:

<?php

$gato_es_grande     = true;
$gato_come_whiskas  = true;
$gato_vuela         = false;
$gato_tiene_2_patas = false;

echo `clear`;
echo 'El gato es grande Y come Whiskas: ';
var_export($gato_es_grande && $gato_come_whiskas);
echo "\n";
echo 'El gato es grande O vuela: ';
var_export($gato_es_grande || $gato_vuela);
echo "\n";
echo 'El gato vuela O tiene 2 patas: ';
var_export($gato_vuela || $gato_tiene_2_patas);
echo "\n";
echo 'El gato NO come Whiskas: ';
var_export(!$gato_come_whiskas);
echo "\n";
echo 'El gato NO come Whiskas O es grande: ';
var_export(!$gato_come_whiskas || $gato_es_grande);
echo "\n";
echo 'El gato NO vuela Y NO tiene 2 patas: ';
var_export(!$gato_vuela || !$gato_tiene_2_patas);
echo "\n";

La última es una demostración de que el NOT no tiene problemas de precedencia con AND o con OR.

Mi forma de resolverlo

<?php
$michi_grande = true;
$le_gusta_comer = true;
$sabe_volar = false;
$tiene_dos_patas = false;

// Cúal es el resultado?

$pregunta1 = $michi_grande and $le_gusta_comer;
$pregunta2 = $michi_grande or $sabe_volar;
$pregunta3 = $sabe_volar or $tiene_dos_patas;
$pregunta4 = !$le_gusta_comer;
$pregunta5 = !$le_gusta_comer or $michi_grande;
var_dump($pregunta1);
var_dump($pregunta2);
var_dump($pregunta3);
var_dump($pregunta4);
var_dump($pregunta5);

echo ("\n");

//resultado
bool(true) 
bool(true) 
bool(false)
bool(false)
bool(false)

Reto

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

He visto operadores lógicos en Python, Java, JavaScripts y lógica de programación.
Escuché a varios profesores y profesoras explicándolo.
Considero que esta fue la mejor explicación.
¡Crack el profe!
Cuando de clases lo voy a hacer así.

Operadores Lógicos

Al dia de hoy 03/2022 Visual Studio Code me sugiere que cambie AND por &&

Resultados:

bool(true)
bool(true)
bool(false)
bool(false)
bool(true)

<?php

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

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

echo"\n";

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

<?php

$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);
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);
bool (true)

echo “\n”;

ME QUEDO ASI

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

// ¿Cual es el resultado?

//AND
var_dump( $es_un_michi_grande && $le_gusta_comer); TRUE

//OR
var_dump( $es_un_michi_grande || $sabe_volar); TRUE
var_dump($sabe_volar || $tiene_2_patas); FALSE

//NOT Y OR
var_dump( !$le_gusta_comer); FALSE
var_dump( !$le_gusta_comer || $es_un_michi_grande); TRUE




echo "\n";

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

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

$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

//AND
echo "And:";
echo "\n";
var_dump($a && $b); //true && true = true
var_dump($a && $c); //true && false = false
echo '---------------------';
echo "\n";

//OR
echo "Or:";
echo "\n";
var_dump($a || $c); //ture || false = true
var_dump($c || $d); //false || false = false
echo '---------------------';
echo "\n";

//NOT
echo "Not:";
echo "\n";
var_dump(!$a); //NOT True ⇒ False
var_dump(!$c); //NOT False ⇒ True
echo '---------------------';
echo "\n";

//AND con NOT
echo "And con not:";
echo "\n";
var_dump(!$a && $b); // !T AND T = F
var_dump(!$a && $d); // !T AND F = F
var_dump(!$c && $d); // !F AND F = F
var_dump(!$c && !$d); // !F AND !F = T
var_dump(!$a && !$b); // !T AND !T = F
echo '---------------------';
echo "\n";

//OR con NOT
echo "Or con not:";
echo "\n";
var_dump(!$a || $b); // !T OR T = T
var_dump(!$a || $d); // !T OR F = F 
var_dump(!$c || $d); // !F OR F = T
var_dump(!$c || !$d); // !F AND !F = T
var_dump(!$a || !$b); // !T AND !T = F
echo '---------------------';
echo "\n";

$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);
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);
bool(true)

yo lo veo asi:

And es como una multiplicación, todo lo que se multiplique por false o 0 es igual a falso o 0.

$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

1. VERDADERO.
2. VERDADERO.
3. FALSO.
4. FALSO.
5. VERDADERO.

<$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
echo "\n";
var_dump($es_un_michi_grande || $sabe_volar);//true
echo "\n";
var_dump($sabe_volar || $tiene_2_patas); //false
echo "\n";
var_dump(!$le_gusta_comer);//false
echo "\n";
var_dump(!$le_gusta_comer || $es_un_michi_grande);//true> 

1. TRUE
2. TRUE
3. FALSE
4. FALSE
5. TRUE

bueno

true

true

false

false

true

Resumen aplicable al día a día

And: Las 2 condiciones se deben cumplir para retornar true

Or: Con que 1 se cumpla se retorna true

Negación: Si es true niega y retorna false y viceversa

Les dejo un video del buen FreddyVega

Qué son tablas de verdad y compuertas lógicas | PlatziLive - YouTube

Operadores lógicos explicados con agua:
https://youtu.be/-g5gduntP_M

Reto: ¿Cuál es el resultado?

código:

<?php

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

// cual es el resultado?
echo "\n";
echo "*****  Afirmaciones *****" . "\n";
echo "\n";
echo "1. Es un michi grande: Cierto" . "\n";
echo "2. Le gusta comer: Cierto" . "\n";
echo "3. Sabe volar: Claro que no! Falsooo!" . "\n";
echo "4. Tiene 2 patas: A menos que se las hayan cortado es: Falso" . "\n";

echo "\n";
echo "+++++  Operadores lógicos +++++" . "\n";
echo "\n";
echo "Es un michi grande y la gusta comer: ";
var_dump($es_un_michi_grande && $le_gusta_comer);

echo "\n";
echo "Es un michi grande o sabe volar: ";
var_dump($es_un_michi_grande || $sabe_volar);

echo "\n";
echo "Sabe volar o tiene dos patas: ";
var_dump($sabe_volar || $tiene_2_patas);

echo "\n";
echo "No le gusta comer?: ";
var_dump(!$le_gusta_comer);

echo "\n";
echo "No le gusta comer? ó Es un michi grande?: ";
var_dump(!$le_gusta_comer || $es_un_michi_grande);

echo "\n";

Resultado:

Saludos 😃

$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

AND (Las dos condiciones tienen que ser ciertas para que sea verdadera)

OR (Al menos una de las dos puede ser cierta para que sea verdadera)

NOT (Se usa para invertir el valor de una información)

<?php

$michi_grande = True;
$michi_comelon = True;
$michi_volador = False;
$michi_con_dos_patas = False;

var_dump($michi_grande && $michi_comelon);
//True

var_dump($michi_grande or $michi_volador);
//True

var_dump($michi_volador or $michi_con_dos_patas);
//False

var_dump(!$michi_comelon);
//False

var_dump(!$michi_comelon or $michi_grande);
//True

Tablas de Verdad: Son aquellas tablas que indican cuál sería el resultado esperado acerca de lo que sería verdadero o falso, dependiendo de la conexión que se realice entre ellas.
Ejemplo. Si se combina un valor verdadero con un valor que es falso, nos dará un nuevo resultado, o salida, según como estemos conectando los valores.

Conectiva Lógica de Negación:
Una proposición que es verdadera, al tener una conectiva lógica de negación se vuelve Falsa (False).

Una proposición que es falsa, al tener una conectiva lógica de negación se vuelve verdadera (True).

Conectividad Lógica de Conjunción.
Solo es verdadera si ambas proposiciones son verdaderas, y será falsa cuando uno de los valores o proposiciones es falso.

Conectividad Lógica de Disyunción Inclusiva.
Solo es falso si ambas proposiciones son falsas, y será verdadero cuando al menos uno de los valores o proposiciones es verdadero.

Conectividad Lógica de Disyunción Inclusiva.
Solo es falso si ambas proposiciones son verdaderas o falsas, y será verdadero cuando al menos uno de los valores o proposiciones es verdadero y el otro falso.

Conectividad Lógica de Condicional
Solo es falso si la primera proposición es verdadera y la segunda proposición es falsa, y será verdadera en todos los demás casos.

Conectividad Lógica de Bicondicional
Solo es Verdadero si ambas proposiciones son verdaderas o falsas, y será Falso cuando uno de los valores o proposiciones es verdadero y el otro falso.

Hola, comparto mis resultados.

// 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 (FALSE)

<code> 
    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);
	 bool(true)