Operadores lógicos

**Operadores logicos** **Operador lógico AND (&&):** Este operador lógico compara dos expresiones. Se debe de tener ambas expresiones verdaderas para que el resultado sea verdadero, pero si una o ambas expresiones son falsas, la sentencia completa se devolverá como falsa. **Operador lógico OR (||):** Este devuelve como *true* si cualquiera de las dos expresiones son verdaderas y false cuando ambas expresiones son falsas. Ambas expresiones pueden ser verdaderas, pero solo se necesita una para que el resultado sea verdadero. **Operador lógico NOT (!):** El operador lógico NOT no realiza ninguna comparación como lo hacen los operadores AND y OR. Este se utiliza con un símbolo "!" (signo de exclamación) para representar un operador NOT o negación.  ```js // ------- Operadores logicos ------ const numero1 = 20; const numero2 = "20"; const numero3 = 30; console.log(numero1 == numero2); // true console.log(numero1 === numero2 && numero1 != numero3) //false console.log(numero2 === numero1 || numero3 != numero1) //true ```

!(a===c) Da true porque se sabe que a no es igual a c por lo tanto da false pero se utiliza el signo de admiración para invertir la ecuación por lo tanto da true :)


Para aquellos que quieran manejar la consola desde el navegador siguiendo el ejercicio como el profe lo pueden hacer: * Conectando el JS a un archivo HTML y, * Utilizando la extensión Live Server para VS Code. **Pasos:** 1\. Crean un archivo HTML, puede ser ***index.html***. 2\. En index crean la estructura básica (esto lo pueden hacer facilmente con escribiendo ***!+ ENTER)*** 3\. Debajo del body se escribe ***script + ENTER*** y colocan el atributo ***src""***, el valor del atributo debe ser la ubicación donde tienen su archivo JS EJ: Finalmente le dan al boton de go live:  Y abren en su navegador: Finalmente oprimen F12 y verán reflejado sus console.log:  Y listo, asi es como se maneja desde navegador, si cambian de archivo JS recuerden cambiarlo también en el archivo html y guardarlo para que se vean reflejados los cambios. Esta una manera de hacerlo, pero lo pueden hacer sin problemas como lo maneja la profesora utilizando node.

Esta regresando el true ya que la ! es una negacion eso significa que si lo que esta entre parentesis es verdadero, el ! lo vuelve falso y si lo que esta entre parentesis es falso, el ! lo vuelve verdadero

 Ejercicio:  Explicación: Primero se compara lo que se encuentra dentro de los paréntesis. ***a*** tiene el valor de ***10*** (numérico). ***c*** tiene el valor de ***'10'*** (string). El operador ***===*** compara **estrictamente** los valores y sus tipos, además no convierte sus tipos automáticamente (a diferencia del operador ***==*** que sí lo hace). En este caso ***a,*** al ser de un tipo diferente a ***c,*** regresa ***false.*** Después se resuelve la siguiente operación:  El operador ***!*** devuelve el valor **contrario** de un valor booleano (***true*** o ***false***). El valor contrario de ***false*** es ***true**.* Debido a esto, el valor final de toda la expresión es ***false.***

La logica es: (a===c) ---- False pero al agregar ! !(a===c) ---- True

Devuelve true porque es la negación de ese algoritmo

# Operadores Logicos Los operadores lógicos en JavaScript se utilizan para combinar o invertir valores booleanos y son esenciales para la toma de decisiones en estructuras de control como las declaraciones `if`, `while`, y otras. 1. **AND lógico (**`&&`**)**:Devuelve `true` si ambos operandos son verdaderos. Si el primer operando es falso, devuelve ese valor; de lo contrario, devuelve el valor del segundo operando. `true && true // true` `true && false // false` `false && true // false` `false && false // false` 1. **OR lógico (**`||`**)**:Devuelve `true` si al menos uno de los operandos es verdadero. Si el primer operando es verdadero, devuelve ese valor; de lo contrario, devuelve el valor del segundo operando. `true || true // true` `true || false // true` `false || true // true` `false || false // false` 1. **NOT lógico (**`!`**)**:Invierte el valor booleano del operando. Si el operando es `true`, devuelve `false`; si el operando es `false`, devuelve `true`. `!true // false` `!false // true` Los operadores lógicos son fundamentales para controlar el flujo de ejecución en un programa y para la toma de decisiones basadas en múltiples condiciones.

Porque a === c es falso y si luego lo niegas es un true

Te regresa "true" porque "!" es negación por lo que le estas diciendo que si "a" es diferente de "c" y le pusiste "===" tres veces el signo igual por lo que JavaScript valida el valor y el tipo, el valor es el mismo pero el tipo no lo es. por eso te sale "true" por que no son iguales. no me se explicar bien pero se entiende, no?.

Hola, muy bien, pues respondiendo a la pregunta de porque la expresión "! (a===c)", ya sabemos que "a" y "c" no son iguales, ni en dato ni en valor, entonces por lo tanto ya sabemos que esa operación es "false". Entonces al operador "!" lo puedes tomar como un "no es", entonces traduciendo toda la operación quedaria "no es (false) ", "no es false", entonces tiene que ser verdadera... es una forma de verlo en termino de "frases" si asi lo queremos ver, espero esto no los confunda. XD

por que a es diferente a c al tener los === pues devuelve un valor falso pero como tienes negación ! entonces se convierte en true.


!(a === c) Primero, se evalúa si **a** es igual a **c** en tipo y valor (que es lo que está entre paréntesis). **a** tiene un valor de 10 y **c** de "10" (string). Dando como resultado 'false'. Al tener el símbolo '!', se está negando el valor. Es decir, 'false' se convierte en 'true'.

Ejercicio del minuto 3:42 - El navegador arroja true porque aunque debería arrojar false, estamos negando el resultado. Por eso arroja True

El operador logico, al validar una negacion, retorna como true el codigo !(a === c) Debido a que "a" NO es igual a "c", en tipo de dato, pero si en valor

Regresa true porque efectivamente el comando indica que si a no es igual (en tipo y valor de dato a c) entonces retorna true, si es igual, retornará false porque "!" (no es igual) no se cumple

Respuesta al test: La validación da como resultado true porque el operativo de comparación (!) es de negación, es decir, cumple su condición como verdadera si la operación estipulada es falsa. En este caso, la constante A y la constante C son comparadas con ===, y a pesar de ambas ser 10, una es un número y la otra es un string, por ende la comparación estricta (===) da como resultado falso, lo que a su vez vuelve el operador (!) verdadero.

Yo entendi lo siguiente Operador \=== : Si algo es igual a algo, tanto en valor como en el tipo de dato a = 10 c = "20" a === c : Es igual en valor pero no en tipo de variable : FALSE ! negación, por lo tanto !(a ===c ), conociendo lo que esta en paréntesis es false, pero el signo de negación afuéra del paréntesis hace que se vuelva TRUE

1. `a === c` verifica si `a` y `c` son **exactamente iguales** en valor y tipo. 2. El símbolo `!` niega el resultado de esa comparación. * Si `a === c` es `true`, entonces `!(a === c)` será `false`. * Si `a === c` es `false`, entonces `!(a === c)` será `true`. `let a = 5;` `let c = "5";` `console.log(a === c); // false, porque son de tipos diferentes (número vs string)` `console.log(!(a === c)); // true, porque la negación de false es true`

* a es diferente de c en tipo y cantidad; y lo contrario = true

!(a ===c) por que lo esta diciendo que no igual igual

La consola regresa un true en el ejercicio porque `a` no es igual a `c`. El operador estrictamente igual regresaría en consola un false, pero como tiene el operador de negación, lo convierte en un true.

`!(a === c);` En este ejercicio da true debido a que la operación lógica que está dentro del paréntesis (false) es negada por el signo de admiración.

! Este operador logico, es la contradiccion de lo que esta en el codigo, por ejemplo !(a === c) esto es true, por que cambia el valor de lo que esta escrito

La respuesta es `true`debido a la negación de una comparación errónea. La expresión `a === c`evalúa a `false`porque `a`contiene un valor numérico y `c`una cadena de texto; los tipos de datos son diferentes, por lo que la comparación estricta de igualdad ( `===`) falla. Negar esta comparación ( `!(a === c)`) invierte el resultado, produciendo `true`.

Responde true porque se está negando que a === b lo que sería la negación de false la negación de false es true

Para entender los operadores lógicos les recomiendo estudiar compuertas lógicas y tablas de verdad

Otro ejemplo de doble negación seria: Mi gato es negro Si digo "No es cierto que mi gato no es negro" entonces lo estoy afirmando

La negación de lo falso es la afirmación En logica proposicional el enunciado seria: No es cierto que "a" es igual a "c"// y como no son iguales entonces el enunciado opuesto seria Es cierto que "a" no es igual a "c" ó Es cierto que "a" es diferente de "c" Los tres enunciados están diciendo lo mismo La negación de lo falso es la afirmación !(false) = true

a es un número y c una string. El comprador devuelve false porque no coincide el tipo de datos pero el negado invierte el valor a true.

console.log(!(a === c)) true porque al ser una doble negación se vuelve en un true

**!(a === c)** Es true, porque a === c es false, pero como se esta negando con !, cambia el valor a true.

La razón por la que `!(a === b)` devuelve `true` es porque la comparación `a === b` es `false` (ya que `a = 10` y `b = 20`, y no son estrictamente iguales). El operador lógico `!` (NOT) invierte este valor, convirtiendo el resultado de `false` en `true`. Por otro lado, si usamos `!(a != b)`, la comparación `a != b` evalúa si `a` y `b` **no son iguales**, lo cual es `true` (porque `a` no es igual a `b`). El operador `!` invierte este resultado, devolviendo `false`.

Te está regresando un True porque 10 no es igual a "10", y al momento de negarlo le estarías diciendo que niegue una negacion, es decir, que lo afirmes.

"`!(a  ===  c)`" Si sólo usáramos el operador de comparación "`===`", nos arrojaría el siguiente resultado: `a  ===  c` // ***false**,* ya que dicho operador compara estrictamente tanto el valor como el tipo de dato de ambas variables. En el valor son iguales, en el tipo de dato no lo son. Ahora, si a la expresión le agregamos el operador lógico **NOT**  “`!`”, este es el resultado: `!(a  ===  c)` // ***true***, debido a que el operador **NOT** cambia a un resultado opuesto del flujo de la expresión. No importa qué expresión sea, este operador lógico voltea toda la lógica (valga la redundancia) de la expresión per se. Otro ejemplo: `a  <  b` // *true* `!(a  <  b)` // *false*

porque la interrogacion es todo lo contrario

Por que al negar la condicion dices: not true y un no es falso es verdadero

El operador ! invierte el valor lógico de la expresión que lo sigue, es decir, devuelve el valor opuesto. Por lo tanto, la comparacion de a === c, verificando tanto el valor como el tipo de dato. Sabemos que a es un numero 10 y c es un texto ‘10’ devuelve false porque los tipos de datos no coinciden. Sin embargo, al aplicar el operador !, este invierte el resultado de false a true. Por lo tanto ! (a === c) devuelve true, es decir, verdadero.

console.log (!(a === c)); porque el signo ! invierte el valor del resultado sabemos que a === c es false pero cuando le agregamos ! invertimos su valor o su resultado a true

Es bastante parecido al algerbra. Primero revisa lo que hay dentro del parentesis, y el símbolo ! fuera de él le dice "has lo contraio de lo que está dentro del parentesis"

La condición dentro del paréntesis es false, pero al tener el operador "not", esta cambia al valor contrario y se convierte en true.

!(a===c) --> True Lo que tenemos dentro del parentesis (a===c) es false pues ya vimos que no coinciden en valor y en tipo de datos, entonces con el ! lo que hacemos es negar esa respuyesta. !false, negar un falso me da como respuesta verdadero (true)

```js // Comparadores de igualdad y desigualdad // == (igualdad débil, compara solo el valor) console.log(5 == '5'); // true, porque el valor es el mismo, aunque el tipo no lo sea // === (igualdad estricta, compara valor y tipo) console.log(5 === '5'); // false, porque el tipo es diferente (number y string) console.log(5 === 5); // true, ambos son del mismo tipo y valor // != (desigualdad débil, compara solo el valor) console.log(5 != '5'); // false, porque el valor es el mismo, aunque el tipo no lo sea // !== (desigualdad estricta, compara valor y tipo) console.log(5 !== '5'); // true, porque aunque el valor es el mismo, el tipo es diferente console.log(5 !== 5); // false, ambos son del mismo tipo y valor // Comparadores de mayor y menor // > (mayor que) console.log(10 > 5); // true, 10 es mayor que 5 console.log(5 > 10); // false, 5 no es mayor que 10 // >= (mayor o igual que) console.log(10 >= 10); // true, 10 es igual a 10 console.log(10 >= 5); // true, 10 es mayor que 5 console.log(5 >= 10); // false, 5 no es mayor ni igual que 10 // < (menor que) console.log(5 < 10); // true, 5 es menor que 10 console.log(10 < 5); // false, 10 no es menor que 5 // <= (menor o igual que) console.log(5 <= 5); // true, 5 es igual a 5 console.log(5 <= 10); // true, 5 es menor que 10 console.log(10 <= 5); // false, 10 no es menor ni igual que 5 // Comparadores lógicos // && (AND lógico) console.log(true && true); // true, ambas expresiones son verdaderas console.log(true && false); // false, una de las expresiones es falsa // || (OR lógico) console.log(true || false); // true, al menos una de las expresiones es verdadera console.log(false || false); // false, ambas expresiones son falsas // ! (NOT lógico) console.log(!true); // false, invierte el valor booleano console.log(!false); // true, invierte el valor booleano // Ejemplos adicionales con condicionales let a = 10; let b = 20; if (a < b) { console.log('a es menor que b'); } else { console.log('a no es menor que b'); } // Uso combinado de comparadores let age = 25; if (age >= 18 && age <= 30) { console.log('La edad está entre 18 y 30 años'); } else { console.log('La edad no está entre 18 y 30 años'); } ```// Comparadores de igualdad y desigualdad // == (igualdad débil, compara solo el valor)console.log(5 == '5'); // true, porque el valor es el mismo, aunque el tipo no lo sea // === (igualdad estricta, compara valor y tipo)console.log(5 === '5'); // false, porque el tipo es diferente (number y string)console.log(5 === 5); // true, ambos son del mismo tipo y valor // != (desigualdad débil, compara solo el valor)console.log(5 != '5'); // false, porque el valor es el mismo, aunque el tipo no lo sea // !== (desigualdad estricta, compara valor y tipo)console.log(5 !== '5'); // true, porque aunque el valor es el mismo, el tipo es diferenteconsole.log(5 !== 5); // false, ambos son del mismo tipo y valor // Comparadores de mayor y menor // > (mayor que)console.log(10 > 5); // true, 10 es mayor que 5console.log(5 > 10); // false, 5 no es mayor que 10 // >= (mayor o igual que)console.log(10 >= 10); // true, 10 es igual a 10console.log(10 >= 5); // true, 10 es mayor que 5console.log(5 >= 10); // false, 5 no es mayor ni igual que 10 // < (menor que)console.log(5 < 10); // true, 5 es menor que 10console.log(10 < 5); // false, 10 no es menor que 5 // <= (menor o igual que)console.log(5 <= 5); // true, 5 es igual a 5console.log(5 <= 10); // true, 5 es menor que 10console.log(10 <= 5); // false, 10 no es menor ni igual que 5 // Comparadores lógicos // && (AND lógico)console.log(true && true); // true, ambas expresiones son verdaderasconsole.log(true && false); // false, una de las expresiones es falsa // || (OR lógico)console.log(true || false); // true, al menos una de las expresiones es verdaderaconsole.log(false || false); // false, ambas expresiones son falsas // ! (NOT lógico)console.log(!true); // false, invierte el valor booleanoconsole.log(!false); // true, invierte el valor booleano // Ejemplos adicionales con condicionaleslet a = 10;let b = 20; if (a < b) {    console.log('a es menor que b');} else {    console.log('a no es menor que b');} // Uso combinado de comparadoreslet age = 25;if (age >= 18 && age <= 30) {    console.log('La edad está entre 18 y 30 años');} else {    console.log('La edad no está entre 18 y 30 años');}

La respuesta al ejercicio es porque ! niega el resultado de la condición que se esta presentando dentro del paréntesis si el resultado iba a ser false lo niega y lo vuelve true lo mismo a la inversa si el resultado fuese a ser true lo niega convirtiéndolo en false

Retorna true porque niega el false que retorna la comparación de a con c.

Por que la condición dentro de los paréntesis es false y con el signo de admiración estamos negando, ergo, al negar una negación, hacemos una afirmación, por eso nos da true

* `A && B` **(AND)**:* El resultado es `true` solo si **ambos** valores son `true`. * Si alguno de los valores es `false`, el resultado es `false`. * `A || B` **(OR)**:* El resultado es `true` si **al menos uno** de los valores es `true`. * Solo es `false` si **ambos** valores son `false`. * `!A` **(NOT)**:* Este operador invierte el valor de `A`. * Si `A` es `true`, `!A` es `false`, y viceversa.


El ejercicio esta dando como resultado un "true" por que el NOT invierte el resultado original de la expresion: (a === c) es "false" !(a === c) si colocamos el simbolo de NOT da como resultado lo contrario, que en este caso seria "true".

!(a === c) Primero, se evalúa si **a** es igual a **c** en tipo y valor (que es lo que está entre paréntesis). **a** tiene un valor de 10 y **c** de "10" (string). Dando como resultado 'false'. Al tener el símbolo '!', se está negando el valor. Es decir, 'false' se convierte en 'true'.

## Operadores Lógicos * Los operadores lógicos permiten realizar comparaciones más complejas al combinar múltiples condiciones. * Existen tres operadores básicos: `&&` (y), `||` (o), y `!` (no). ## Operador Lógico Y (&&) * El operador `&&` se utiliza para comprobar si dos condiciones son verdaderas. * Ejemplo: `A && B` es verdadero si tanto `A` como `B` son verdaderos. * Permite validar múltiples condiciones simultáneamente. ## Operador Lógico O (||) * El operador `||` se utiliza para comprobar si al menos una de las dos condiciones es verdadera. * Ejemplo: `A || B` es verdadero si `A` o `B` es verdadero, o ambos. * Facilita la creación de condiciones más flexibles. ## Operador Lógico NO (!) * El operador `!` se utiliza para negar una condición. * Ejemplo: `!A` es verdadero si `A` es falso, y viceversa. * Es útil para invertir el valor de una condición. ## Ejemplos Prácticos * Definición de variables:const a = 10; const b = 20; const c = '10'; * Uso del operador `&&`:console.log(a == b && a === c); // false * Aquí `a == b` es falso y `a === c` también es falso (mismo valor pero diferente tipo de dato). * Uso del operador `||`:console.log(a != b || a === c); // true * Aquí `a != b` es verdadero, aunque `a === c` es falso. Al ser una condición `||`, solo una necesita ser verdadera para que la expresión completa sea verdadera. * Uso del operador `!`:console.log(!(a === c)); // true * Aquí `a === c` es falso, pero `!(a === c)` invierte el resultado a verdadero. ## Próximos pasos * Practicar estos operadores en la consola del navegador para entender mejor su funcionamiento. * Probar diferentes combinaciones de condiciones para observar cómo cambian los resultados. * Aplicar estos operadores en estructuras condicionales (if-else) para controlar el flujo del código según diferentes condiciones.

`!(a === c);` Esto devuelve true porque el operador de Negación NOT - ! requiere que el output sea false, y si obtenemos false entonces nos devuelve true.

Acá dejo mi nota la clase y comentario 

`!(a === c);` El resultado es `true` porque el operador `!` invierte el valor lógico de la condición. En este caso, `a === c` evalúa si `a` y `c` son iguales. Si no lo son, la expresión `a === c` será `false`, es por esto que el resultado es `true`. Esto significa que la condición no se cumple, indica que `a` no es igual a `c`.

La expresión `!(a === c)` devuelve `true` porque, dentro de los paréntesis, se está evaluando si `a` es estrictamente igual a `c` (`a === c`). Si esta comparación resulta en `false`, el operador de negación `!` invierte el resultado, convirtiéndolo en `true`. Es decir, el operador `!` simplemente niega el valor de la comparación que está dentro de los paréntesis.

porque al negar con ! invierte el resultado a la salida

!(a===c) devuelve un true debido a que la condicional "!" está negando la condición dentro de los paréntesis. me gustan mucho estos temas, los aprendí cuando estudiaba la tabla de la verdad en compuertas lógicas, perteneciente a electrónica digital, les recomiendo una breve mirada a estas tablas. && = compuerta and || = compuerta or ! = compuerta not 

Ejercicio `a===c = false` `!false = true` Respuesta: true

El operador Not, niega cualquier expresión, entonces a ===c es Falso, pero el not lo convierte en True.

Esta regresando un true, porque estamos diciendo que es lo opuesto(!).

Por qué a === c es falso, y al agregar la negación invierte el resultado. De false pasa a true.

Imagino que !(a === b) arroja un True porque el navegador interpreta que el valor de lo que está entre paréntesis es el mismo valor de !

Hola, !(a === c) -> true, dado que 'a = 10' no es exactamente igual a 'c = '10'' y dado que se encuentra un negador cambia el resultado de la condición a True.

**!(a === c)** devuelve true porque se está preguntando si "a" es estrictamente igual a "c" en tipo y valor, pero al poner el signo de admiración se invierte la pregunta, o sea, si "a" **no** es estrictamente igual a "c".

En el ejemplo la consola devuelve *true* porque compara dos valores que son de diferente tipo, eso es *false* y la negación convierte ese valor en *true*. ```js const a = 10 const b = 20 const c = "10" a != b || a === c true !(a === c) true ```

✅ Respuesta al ejercicio de la clase: **!(a === c)** 1. Primero evaluamos si **a** es igual a **c** tanto en tipo de dato como en valor. 2. Como **a** es un tipo de dato numérico **(10)** y **b** es un tipo de dato cadena **('10')**, el resultado de esta comparación nos dará **false**. 3. Luego con el operador de negación **!** invertimos el resultado de **false** a **True**.

al escribir el !() esta haciendo una negación, esta negando que a sea igual en dato y tipo de dato, y aunque es el mismo 10 uno es 'number' y el otro 'str' sin la negacion daria false pero con !() esta negando que eso sea verdad

explicación del ejercicio de la clase: !(a === c) = true esto pasas debido a que a = 10 y b = "10", al ambos ser 10 el resultado debería de ser true pero como la condición es === pide que sea exacto hasta en el tipo de dato, por lo que el resultado es FALSE y por ultimo el operador ! niega el resultado obtenido dentro del parentesis por lo que el FALSE se convierte en TRUE.

Referente a la pregunta: !(a===c) Da TRUE porque la expresión a===c es FALSE, y como con ! estamos verificando que efectivamente sea FALSE, entonces esa verificación es verdadera.

!(a === c) true La condición que esta entre parentesis es false, después este valor se niega con signo de ! el cual nos arrojaría true

el signo de admiración indica que no se aplica lo que resulte dentro del paréntesis, por ese motivo aunque dentro del paréntesis resulta en false porque a no es el mismo tipo de dato que c, el resultado es el opuesto a lo que resulte dentro del parentesis

porque la negación me esta afectando el operador de comparación que esta dentro de los parentesis haciendo que se lea como !(a === c) no es A igual en valor y tipo a C. lo cual es true

Estamos verificando estricto y estamos negando.

Está regresando un true porque ! Significa NO y le estamos diciendo A no es estrictamente igual a B (estamos validando dato y número en negación porque hay un ! Qué significa NO) y el responde true ósea eso es correcto, ellos no son estrictamente iguales en dato y número

!(a===c) Aparece como true porque es falso que A sea igual a C.

Porque a = 10 y c = "10" Sabemos de antemano que no son el mismo tipo de dato, por lo tanto la operacion: (a === c) nos dará false En cambio, al poner !(a === c), estamos preguntando: "Es a diferente que c respecto a su tipo de valor?" Y esta pregunta deberá retornar "True", ya que a sí es diferente que c en tipo de valor

Realmente arroja un true en el ejercicio dado, porque lo que estamos diciendo es la variable a NO es estrictamente igual a la variable c, lo cual es cierto.

! Antes de la operacion logica ya da a entender que se invierte la logica por ende !(a===c) es true

!(a===c) Regresa un True por que es la negativa o el valor contrario a la comparación estricta que se hace entre a y b.

La expresión indicada !(a===c) devuelve un valor true, es porque al inicio estas realizando un enunciado de negación es decir indistintamente de que la condición sea una negación al inicio de la misma estas negando y recordando el valor de que cuando ambas condiciones son iguales el resultado siempre será true.

!(a===c) da true porqué el condicional ! lo que hace es preguntar si lo que está entre parentesis es falso. como a===c es falso, !(a===c) es verdadero. a===c es como que yo diga mi nombre es Ramón. El resultado es falso porque me llamo Sebastián no Ramón. !(a===c) es como que yo diga "es mentira que mi nombre sea Ramón" lo cual es verdadero !(a===a) sería falso porqué sería como que yo dijera "es mentira que mi nombre sea Sebastián"

!(a===c) da true porqué el condicional ! lo que hace es preguntar si lo que está entre parentesis es falso. como a===c es falso, !(a===c) es verdadero. a===c es como afirmar "las peras son naranjas". Lo cual es falso !(a===c) es como afirmar "es mentira que las peras sean naranjas." Lo cual es verdadero pues en efecto las peras no son naranjas. por otro lado si dijera !(a===a) es falso porque es como decir "es mentira que las peras sean peras"

!(a === c) El resultado es true debido a que al conocer que el operador A y C son distintos, al estar haciendo la operación lógica con una negación, el resultado va a ser TRUE.

afirma que es falso la operacion de (a === c) pero al ser false la negacion confirma que coincide por eso es true.

!(a===c); true porque a === c es false, y !false es true

Devuelve un true ya que los que hace es usar la fierenciacion. Ya que en la logica se espera el false y lo niega

El NOT en operadores logicos se utiliza para negar o invertir el resultado que da una comparacion en este caso, sabemos que a y c no son completamente iguales porque son diferente tipo de dato, asi que ese resultado seria false pero al tenerlo invertido con el not muestra el true

Esta regresando un true ya que al ser una negación es como si te estuviera diciendo que de verdad es falso

Ejercicio: `!(a === c) = true` ¿Por qué ocurre esto? Primero se realiza la comparación entre A y C `(a === c)` y devuelve un false. quedando esto: `!(false)` El operador NOT (!) devuelve el valor contrario de un booleano, por lo tanto si tenemos un `false`, nos devuelve un `true`

En el ejemplo !(a ===c) es verdadero porque esta negando un tipo y valor.

Acá mis notas y desarrollo de varios ejercicios practicas para comprender estos operadores lógicos

!(a === c) regresa true porque usamos el operador de negación que convierte la sentencia falsa en verdadera y la verdadera en falsa.

El simbolo de negacion indica lo contrario. !(a === c) es False pero por la negacion da lo contrario, nos arroja True

* El resultado de a === c es "False" por ser diferente tipo de dato. * Y como el simbolo ! niega el resultado, por eso el resultado final es "True".

lo que pasa es que va por jerarquía de operaciones y entonces primero resuelve la operacion dentro de los parentesis que da como resultado una negacion para despues negarla lo cual nos da una afirmacion por lo cual nos regresa un valor true

!(a === c) En este caso, la condición que está dentro del operador no se cumple debido a que el tipo de dato no es el mismo. Entonces el operador !() que es un NO SE CUMPLE evalua esta compación y dice "Es VERDAD, no se cumple la comparación" y entonces devuelve un TRUE.

En este caso primero se evalúa la expresión del paréntesis: (a === c) dando como resultado false porque el valor de a es 10 y el de c es "10" , ademas de que el tipo de dato es diferente a es un numero y c es un string. pero el operador lógico ! niega el resultado de esta expresión por lo tanto el resultado de esta es true.

!(a===c) *// Aqui return true porq ? al comparar a con b en valor y tipo de dato*         *// returna false porq a y c no son iguales en valor y tipo pero al*         *// aplicar el not(!) el false se cambia a true*