Introducción a JavaScript
¿Por qué aprender JavaScript?
¡Hola Mundo! en Mac
¡Hola Mundo! en Windows
Anatomía de una variable
Tipos de datos en JavaScript
Creación de strings
Operadores aritméticos
Conversión de tipos: Type Casting y Coerción
Conversión de tipos explícita e implícita
Estructuras de Control y Lógica
Operadores de comparación
Operadores lógicos
Ejecución condicional: if
Ejercicio: Adivina el número
Ejecución condicional: switch
Loop: for
Loop: for of
Loop: for in
Loop: while
Loop: do while
Funciones y This
Anatomía de una función
Funciones vs Métodos
Funciones puras e impuras
Arrow function y enlace léxico
Contextos de ejecución y scope chain
¿Qué es Closure?
Preguntas a Desarrolladores Senior: ¿Por qué aprender Desarrollo Web?
Manipulación de Arrays
Introducción a Arrays
Mutabilidad e inmutabilidad de Arrays
Modificación básica del final con push( ), pop( )
Iteración con map( ) y forEach( )
Filtrado y reducción con filter( ) y reduce( )
Búsqueda de elementos con find( ) y findIndex( )
Crear copias con slice( )
Spread operator: casos de uso
Programación Orientada a Objetos
Anatomía de un Objeto
Trabajando con objetos en JavaScript
Función constructora
¿Qué es una clase?
Prototipos y herencias
Herencia en la práctica
Prototipos en la práctica
this en JavaScript
Proyecto: Crea una red social
Proyecto: Crea una red social parte 2
Asincronía en JavaScript
¿Cómo funciona el JavaScript Engine?
Promesas en JavaScript
Usando Async y await en JavaScript
For await of
¿Cómo funciona la web?
¿Cómo funciona HTTP?
Método GET en JavaScript
Método POST en JavaScript
Método DELETE en JavaScript
Importancia del id en el método DELETE
ECMAScript 6 y tus siguientes pasos
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Operadores lógicos
11/55Recursos
Aportes 69
Preguntas 1
Ordenar por:
**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 :)
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
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
# 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
Devuelve true porque es la negación de ese algoritmo
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`
!(a===c) da true porque en efecto no son iguales en valor y tipo
Prácticamente si el operador hablara diría:
"Mijo, esta madre es diferente una de otra, tome su true"
Acá dejo mi nota la clase y comentario
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*
```js
const a = 10
const b = 20
const c = '10'
!(a === c) /* Esta arroja como
resultado TRUE, porque lo que
está dentro de paréntesis es
FALSE (a no es igual a c en tipo)
sin embargo, al inicio estamos
colocando el signo de negación,
de esta forma 'cambiamos el
resultado'
o negamos el resultado.
```
en la evalacion se pide que "a" sea exactamente igual a "c" pero que tiene un "no" entonce la evaluacion seria que "a" no sea exactamnte igual a "c" entonces es verdadero por que "a" no es exactamente igual a "c"
Creo que el !(a===c) trata de decir que 'No es correcto afirmar que a es igual igual a c' te esta negando por así decirlo
const a = 10;
const b = 20;
const c = "10";
!(a === c)
por un lado; la expresion a === c es falsa porque son diferentes en tipos de datos, y por otro lado el simbolo ! esta negando toda la expresion dentro del parentesis, esta diciento esto no es cierto, entonces se interpreto que la expresion es verdadera, porque en efecto eso no es cierto..
en resumen ! dice esto "(a === c)" no es cierto, y eso es verdadero porque esto (a === c) es falso...
El resultado de !(a === c) es true, porque el resultado que esta dentro del parentesis es false y el operador logico de ! es negación, quiere decir si la primera expresión es false, la negative de false es true. Citando en matematicas, negativo por negativo es positivo.
Porque el negado cambia el resultado de la comparación que es false dejándola como true
facil estas pidiendo que no sea igual y al cumplir ese requisito te lanza true
Hice un ejercicio basado en los dos temas que vimos: Operadores condicionales y Operadores Lógicos:Me cuentan el resultado que les dio! :D
Esta es lo que dice MDN acerca de los operadores logicos.
El ultimo operador no lo conocia y no se en que casos se aplique.
```js
const a = 10
const b = 20
const c = "10"
console.log(!(a===c))
/* a = 10 es igual en valor a c = "10" SI
a = 10 es igual en tipo a c = "10" NO
Entonces a===c, da como resultado FALSE
El operador lógico ! indica negación por ende
!(a===c) -> !(FALSE) -> TRUE
*/
```
En el ejercicio de practica aparece True porque no se cumple la condición ya que el valor de C es una cadena de caracteres, mientras que que el valor de A si es de tipo numerico
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"
por el signo ! no
!(a === c) // Da true porque invierte el valor.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?