Operadores de comparación

Curso de Fundamentos de JavaScript

Introducción a JavaScript

Fundamentos de JavaScript para Principiantes

Instalación y Configuración de JavaScript en Visual Studio Code

Instalación y configuración de Visual Studio Code y Node.js en Windows

Variables y Buenas Prácticas en JavaScript

Tipos de Datos en JavaScript: Primitivos y Complejos

Manipulación de Strings en JavaScript: Escritura, Concatenación y Substrings

Números y Operaciones Matemáticas en JavaScript

Conversión de Tipos en JavaScript: Implícita y Explícita

Conversión de Tipos en JavaScript: Explícita e Implícita

Estructuras de Control y Lógica

Operadores de Comparación en JavaScript: Igualdad y Desigualdad

Operadores Lógicos en Programación: AND, OR y NOT

Estructuras Condicionales: Uso de IF, ELSE y ELSE IF en JavaScript

Juego de Adivinanza: Programación con Estructuras Condicionales

Estructura y uso del condicional Switch en programación

Ciclo For: Iteración de Listas y Uso de Console.log en JavaScript

Iteración con for-of en JavaScript para arrays y strings

Iteración sobre Objetos con forIn en JavaScript

Uso del ciclo while para iteración en programación

Ciclos doWhile: Estructura y Diferencias con While

Funciones y This

Funciones en JavaScript: Cómo Calcular Precios con Descuentos

Diferencias entre Funciones y Métodos en JavaScript

Funciones Puras e Impuras en Programación: Conceptos y Ejemplos

Arrow Functions y Enlace Léxico en JavaScript

Scope y Contextos de Ejecución en JavaScript

Closures y Ámbito Léxico en JavaScript

Fundamentos del Desarrollo Web: Frontend y Backend

Manipulación de Arrays

Arrays: Propiedades, Acceso y Creación en Programación

Mutabilidad e inmutabilidad en arrays: conceptos y ejemplos prácticos

Métodos push y pop para modificar arrays en JavaScript

Métodos map y forEach en JavaScript: Uso y Ejemplos Prácticos

Métodos Filter y Reduce en JavaScript: Uso y Ejemplos Prácticos

Métodos find y findIndex en JavaScript: Uso y ejemplos prácticos

Uso del método slice para extraer porciones de un array en JavaScript

Uso del Spread Operator en JavaScript: Copia, Combinación y Más

Programación Orientada a Objetos

Programación Orientada a Objetos en JavaScript: Conceptos y Práctica

Creación y Manipulación de Objetos en JavaScript

Función constructora y gestión de instancias en JavaScript

Clases en JavaScript: Creación y Uso de Objetos con Sintaxis Moderna

Programación Orientada a Objetos en JavaScript: Clases y Prototipos

Prototipos y Herencia en JavaScript: Construcción y Uso Práctico

Métodos y herencia prototípica en JavaScript

Uso de "this" en Clases y Funciones Constructoras

Validación de Usuarios en una Red Social: Algoritmo Básico

Implementación de la Función Sign-In y Validación de Usuario

Asincronía en JavaScript

Programación Síncrona y Asíncrona en JavaScript

Promesas en JavaScript: Asincronía y Manejo de Estados

Uso de Async/Await para Promesas Asíncronas en JavaScript

Peticiones asíncronas con for await en JavaScript

Fundamentos de HTTP: Cliente-Servidor y Métodos de Petición

Peticiones HTTP en Frontend: Uso de Fetch y Análisis en Network

Peticiones HTTP en JavaScript: Fetch, GET, POST y DELETE

Envío de Datos al Servidor con JavaScript y Fetch API

Eliminar Posts con JavaScript y Delegación de Eventos

Manejo de IDs en JavaScript para eliminar artículos del DOM

Actualizaciones y Nuevas Funciones en JavaScript

No tienes acceso a esta clase

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

Si ya tienes una cuenta,

Recursos

¿Qué es la ejecución condicional en programación?

La ejecución condicional es un concepto clave en programación que nos permite tomar diferentes caminos en nuestro código según ciertas condiciones. Esto se logra mediante el uso de operadores de comparación, los cuales evalúan expresiones para determinar si son verdaderas o falsas. Esta evaluación nos facilita la toma de decisiones dentro del código, permitiendo ejecutar ciertas partes solo si las condiciones establecidas se cumplen.

¿Qué son los operadores de comparación?

Los operadores de comparación son herramientas esenciales en el desarrollo de software que permiten comparar dos valores. Dependiendo de la comparación realizada, estas herramientas devuelven un valor booleano (verdadero o falso).

¿Cómo usar los operadores de igualdad?

Existen dos tipos principales de operadores de igualdad:

Dos iguales (==): Este operador verifica si dos valores son iguales. Sin embargo, no considera el tipo de dato. Es decir, puede determinar que un número y un string son iguales si ambos representan el mismo valor numérico.

10 == "10" // Devuelve true

Tres iguales (===): Este operador, más estricto, verifica tanto el valor como el tipo de dato. Es una buena práctica utilizar este operador, ya que evita errores al asegurarse de que tanto el valor como el tipo sean idénticos.

10 === "10" // Devuelve false

¿Cómo funcionan los operadores de desigualdad?

Al igual que los operadores de igualdad, existen dos operadores que manejan la desigualdad:

Diferente (!=): Este operador comprueba si dos valores no son iguales, sin considerar el tipo de dato.

10 != "20" // Devuelve true

Diferente estricto (!==): Valida que tanto el valor como el tipo de dato sean diferentes.

10 !== "10" // Devuelve true

¿Cuándo se utilizan los operadores de mayor y menor?

Estos operadores nos ayudan a comparar valores para identificar cuál es mayor o menor, además de sus combinaciones con igualdad:

Mayor (>): Verifica si un valor es mayor que otro.

20 > 10 // Devuelve true

Menor (<): Verifica si un valor es menor que otro.

10 < 20 // Devuelve true

Mayor o igual (>=): Comprueba si un valor es mayor o igual a otro.

10 >= 10 // Devuelve true

Menor o igual (<=): Revisa si un valor es menor o igual a otro.

5 <= 10 // Devuelve true

¿Cómo aplicar operadores de comparación en la práctica?

Veamos un ejemplo práctico usando JavaScript.

Declaración de variables

Primero, declararemos algunas constantes que utilizaremos para nuestras comparaciones:

const A = 10;
const B = 20;
const C = "10";

Ejemplo de comparaciones

Validar igualdad de valores:

A == B // Devuelve false
A === C // Devuelve false

Validar desigualdad de valores:

A != B // Devuelve true
A !== C // Devuelve true

Evaluar operadores mayor y menor:

A > B // Devuelve false
A < B // Devuelve true
A >= C // Devuelve false
A <= B // Devuelve true

Estos ejemplos ilustran cómo los operadores de comparación te permiten tomar decisiones basadas en las condiciones definidas, lo que es esencial en la programación para la creación de flujos lógicos.

¡No dejes de explorar y experimentar con estos operadores para dominar cómo las condiciones pueden manipular el flujo de tu código y tomar decisiones programáticas efectivas!

Aportes 21

Preguntas 6

Ordenar por:

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

Arnol Daniel Degollado Garrocho

hace 9 meses

![](https://static.platzi.com/media/user_upload/Operadores%20de%20comparaci%C3%B3n%20en%20JavaScript-150a0071-416a-4e57-99aa-4763217b3f7f.jpg)

Christian Andres Moreno Ceballos

hace 9 meses

# Operadores de comparacion Los operadores de comparación en JavaScript se utilizan para comparar dos valores y devolver un resultado booleano (`true` o `false`). * Igualdad **(**`==`**)**:Compara dos valores para ver si son iguales, pero sin tener en cuenta el tipo de datos. * **Igualdad estricta (**`===`**)**: Compara dos valores para ver si son iguales y del mismo tipo de datos. * **Desigualdad (**`!=`**)**: Compara dos valores para ver si son diferentes, pero sin tener en cuenta el tipo de datos. * **Desigualdad estricta (**`!==`**)**: Compara dos valores para ver si son diferentes o de diferentes tipos de datos. * **Mayor que (**`>`**)**: Verifica si el valor de la izquierda es mayor que el valor de la derecha. 5 == "5" // true 5 === "5" // false 5 === 5 // true 5 != "5" // false 5 != 6 // true 5 !== "5" // true 5 !== 5 // false 6 > 5 // true 5 > 5 // false 6 >= 5 // true 5 >= 5 // true 4 < 5 // true 5 < 5 // false 4 <= 5 // true 5 <= 5 // true * **Mayor o igual que (**`>=`**)**: Verifica si el valor de la izquierda es mayor o igual que el valor de la derecha. * **Menor que (**`<`**)**: Verifica si el valor de la izquierda es menor que el valor de la derecha. * **Menor o igual que (**`<=`**)**:Verifica si el valor de la izquierda es menor o igual que el valor de la derecha. > **Conversión de tipos implícita**: Los operadores `==` y `!=` realizan conversiones de tipo implícitas antes de la comparación. Por ejemplo, `5 == "5"` es `true` porque JavaScript convierte la cadena `"5"` en el número `5` antes de compararlos.

Argenis Valdez

hace 7 meses

![]()![](https://static.platzi.com/media/user_upload/relacionales-de444761-e346-46df-a3cf-f4ebc4ad9ca5.jpg) Espero que les ayude

Michael Andres Rincon Garcia

hace 7 meses

como cuando llegas a clase y botaron a la profe xd

Jhosell

hace 9 meses

Hay un problema con la clase 9 y 10 no cargan, se salta hasta esta clase

Alejandro Mantilla

hace 9 meses

Mis apuntes ![](https://static.platzi.com/media/user_upload/image-ce2490f4-bc03-4f27-af5c-cf61f0a68f0e.jpg)

Calvin Rafael Bobadilla Fernandez

hace 9 meses

**MIS APUNTES:** ![](https://static.platzi.com/media/user_upload/image-3444201d-0a3e-4420-8f2a-625a3193eee0.jpg) ![](https://static.platzi.com/media/user_upload/image-63cfcf80-f0e3-4ab4-bb18-41c80169fd5d.jpg)

luis porteles

hace 22 días

```js // =============================== // OPERADORES DE COMPARACIÓN EN JAVASCRIPT // =============================== const A = 10; // A es un número entero const B = 20; // B es otro número entero mayor que A const C = "10"; // C es un string que representa el número 10 // == Compara solo el valor, no el tipo console.log(A == B); // false: 10 no es igual a 20 console.log(A == C); // true: el valor "10" (string) es igual a 10 (número), el tipo se ignora // === Compara tanto el valor como el tipo de dato console.log(A === C); // false: 10 (number) NO es igual a "10" (string) // != Compara si los valores son diferentes, sin importar el tipo console.log(A != B); // true: 10 es diferente a 20 console.log(A != C); // false: 10 y "10" se consideran iguales en valor // !== Compara si los valores o los tipos son diferentes console.log(A !== C); // true: 10 y "10" son diferentes en tipo (number vs string) // > Compara si A es mayor que B console.log(A > B); // false: 10 no es mayor que 20 // < Compara si A es menor que B console.log(A < B); // true: 10 es menor que 20 // <= Compara si A es menor o igual que B console.log(A <= B); // true: 10 sí es menor o igual que 20 // >= Compara si A es mayor o igual que C // JavaScript convierte "10" (string) a número para esta comparación console.log(A >= C); // true: 10 es igual a "10" después de conversión implícita ``` * **==**: Igualdad de valor. No compara el tipo. * **===**: Igualdad estricta (valor + tipo). Compara el tipo. * **!=**: Diferente en valor. No compara el tipo. * **!==**: Diferente en valor o tipo. Compara el tipo. * **>**: Mayor que. Compara el tipo (realiza conversión si es necesario). * **<**: Menor que. Compara el tipo. * **>=**: Mayor o igual que. Compara el tipo. * **<=**: Menor o igual que. Compara el tipo.

Fernando Emilio Díaz López

hace 2 meses

Con relacion a la conversion de tipos de clases pasadas, esta aplica tambien a los operadores En los operadores de diferencia e igualdad no estricta (== y !=) y comparacion (>, >= < y <=) Se realiza la conversion de tipos, es decir, los strings que contengan numero, seran convertidos a valores numericos enteros si es posible Esto no aplica con los operadores estrictos === y !==, donde no se realiza la conversion y se compara de string a numero, donde en una operacion de igualdad el resultado es false

pavel andrei ramos barragan

hace 2 meses

El operador `>=` se utiliza para verificar si el valor de la izquierda es mayor o igual al de la derecha. En el ejemplo mencionado, si A es 10 y C es también 10 (A = 10, C = 10), entonces la comparación `A >= C` resultaría en `true`. Si el ejemplo indica que es `false`, es incorrecto. Es importante tener claridad sobre los valores y el uso de los operadores de comparación para evitar confusiones. Para más ejemplos, te recomiendo revisar la lección de "Operadores de comparación" en el curso de Fundamentos de JavaScript en Platzi.

Jose Eduardo Ramos Lopez

hace 2 meses

como abrir la consola de navegación abierta

David Elias Gatica Morales

hace 3 meses

```js /* No es cierto que number no es igual a 5 la negación de la negación es la afirmación */ let number = 5 console.log(!(!number)) //true ```Les recomiendo un libro de introducción a la lógica matemática de P. Suppes S. Hill habla sobre tablas de verdad y lógica proposicional.

Jonathan Garcia

hace 3 meses

![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202025-01-21%20172652-1c5e8197-ee1f-49e2-8f64-cf382f9b4c2a.jpg)

Juan Gonzalez

hace 4 meses

```javascript // Resumen de la clase: Operadores de comparación en JavaScript const A = 10; // Ejemplo de valor A const B = 20; // Ejemplo de valor B const C = "10"; // Ejemplo de valor C como string // Comparaciones console.log(A == B); // false: A no es igual a B console.log(A === C); // false: A es un número, C es un string console.log(A != B); // true: A es diferente a B console.log(A !== C); // true: Diferente en tipo y valor console.log(A > B); // false: A no es mayor que B console.log(A < B); // true: A es menor que B console.log(A <= B); // true: A es menor o igual que B console.log(A >= C); // false: A no es mayor o igual que C ``` Este código resume las comparaciones mencionadas en la clase sobre operadores de comparación.

Jonatan Martin

hace 4 meses

veo un archivo index de html, creo que algo estoy haciendo mal. Siento que debo aprender primero HTML y CSS para poder manejar JS.

hace 6 meses

como une la consola del navegador a lo que se tiene en visual studio code ? donde explica eso?

Yamid Horacio Rodríguez

hace 6 meses

Muchas gracias por la integración de preguntas sobre la clase. Nunca paremos de aprender.

LUIS FELIPE RESTREPO ARGÜELLO

hace 6 meses

Los **Operadores de Comparación** Comparan dos valores y devuelven un valor booleano (`true` o `false`). ```js let a = 5; let b = 10; console.log(a == b); // Igualdad: false console.log(a != b); // Desigualdad: true console.log(a === b); // Estrictamente igual (tipo y valor): false console.log(a !== b); // Estrictamente desigual (tipo o valor): true console.log(a < b); // Menor que: true console.log(a > b); // Mayor que: false console.log(a <= b); // Menor o igual que: true console.log(a >= b); // Mayor o igual que: false ```let a = 5; let b = 10; console.log(a == b); // Igualdad: false console.log(a != b); // Desigualdad: true console.log(a === b); // Estrictamente igual (tipo y valor): false console.log(a !== b); // Estrictamente desigual (tipo o valor): true console.log(a < b); // Menor que: true console.log(a > b); // Mayor que: false console.log(a <= b); // Menor o igual que: true console.log(a >= b); // Mayor o igual que: false

Andrés Soret Chacin

hace 6 meses

## Ejecución Condicional * La ejecución condicional permite realizar acciones diferentes según si una condición es verdadera o falsa. * Los operadores de comparación son esenciales para crear estas condiciones. ## Operadores de Comparación * **Igualdad (==)** * Compara si dos valores son iguales. * Si son iguales, la condición es verdadera (true). * Ejemplo: `a == b` devuelve true si `a` es igual a `b`. * **Igualdad Estricta (===)** * Compara si dos valores son iguales y del mismo tipo. * Previene errores comparando tanto el valor como el tipo de dato. * Ejemplo: `a === b` devuelve true si `a` es igual a `b` y ambos son del mismo tipo. * **Desigualdad (!=)** * Compara si dos valores son diferentes. * Si son diferentes, la condición es verdadera. * Ejemplo: `a != b` devuelve true si `a` es diferente de `b`. * **Desigualdad Estricta (!==)** * Compara si dos valores son diferentes o de diferente tipo. * Previene errores comparando tanto el valor como el tipo de dato. * Ejemplo: `a !== b` devuelve true si `a` es diferente de `b` o son de diferente tipo. * **Mayor que (>)** * Compara si un valor es mayor que otro. * Ejemplo: `a > b` devuelve true si `a` es mayor que `b`. * **Menor que (<)** * Compara si un valor es menor que otro. * Ejemplo: `a < b` devuelve true si `a` es menor que `b`. * **Mayor o Igual (>=)** * Compara si un valor es mayor o igual que otro. * Ejemplo: `a >= b` devuelve true si `a` es mayor o igual que `b`. * **Menor o Igual (<=)** * Compara si un valor es menor o igual que otro. * Ejemplo: `a <= b` devuelve true si `a` es menor o igual que `b`. ## Ejemplos Prácticos * Definición de variables:const a = 10; const b = 20; const c = '10'; * Comparación de igualdad:console.log(a == b); // false console.log(a == c); // true console.log(a === c); // false * Comparación de desigualdad:console.log(a != b); // true console.log(a !== c); // true * Comparación de mayor y menor:console.log(a > b); // false console.log(a < b); // true console.log(a >= 10); // true console.log(a <= 10); // true ## Próximos pasos * Practicar estos operadores en la consola del navegador para entender mejor su funcionamiento. * Probar diferentes valores y tipos de datos para observar los resultados de las comparaciones. * Aplicar estos operadores en estructuras condicionales (if-else) para controlar el flujo del código según diferentes condiciones.

Santiago Rua Barrera

hace 8 meses

Acá les socializo mis apuntes de esta clase y el ejercicio desarrollado, de una forma más extensa aún, para validar cada uno de los operadores de comparación. Saludos! ![](https://static.platzi.com/media/user_upload/image-81216a16-3ebf-4a5d-a257-7d4d6a50a32a.jpg)

Elvis Milan

hace 9 meses

(Y)