Comparaciones de igualdad en la Programación

¡Hola HaWker! Jeff Bruchado por aquí.

Este es un artículo más de nuestra serie de artículos que va a cubrir nuestro viaje para Aprender Programación desde Cero.

Hoy será un artículo sobre un contenido más extremadamente importante para proseguir con tu aprendizaje.

Entonces, ¡por favor! Si no tienes dominio sobre lo que voy a hablar hoy, ¡lee hasta el final!

Bueno, sin más preámbulos, ¡vamos a comenzar!

Hoy, vamos a hablar sobre un tema súper usado en la Programación: Comparaciones de igualdad (Equality Comparisons).

Las Comparaciones de igualdad, o en inglés Equality Comparisons son usadas para verificar si dos valores son iguales o diferentes.

Existen dos formas de realizar comparaciones de igualdad:

El operador de igualdad simple (==) y el operador de igualdad estricta (===).

Vamos a entender cada uno de ellos en detalle.

Operador de igualdad simple (==)

El operador de igualdad simple (==) es usado para verificar si dos valores son iguales.

Antes de realizar la comparación, el operador simple intenta convertir los valores al mismo tipo antes de hacer la comparación.

Por ejemplo:

console.log(1 == 1); // true
console.log('1' == 1); // true
console.log(true == 1); // true
console.log(null == undefined); // true
console.log([] == false); // true

Como podemos ver en el ejemplo arriba, el operador de igualdad simple (==) intenta convertir los valores al mismo tipo antes de hacer la comparación.

En el primer ejemplo, 1 es comparado con 1 y ambos son del mismo tipo (number), entonces la comparación es verdadera.

En el segundo ejemplo, '1' (string) es comparada con 1 (number) y son convertidos al mismo tipo (number) antes de la comparación, entonces la comparación es verdadera.

En el tercer ejemplo, true (boolean) es comparado con 1 (number) y son convertidos al mismo tipo (number) antes de la comparación, entonces la comparación es verdadera.

En el cuarto ejemplo, null (un valor de referencia nula) es comparado con undefined (un valor de referencia no definido) y son considerados iguales, entonces la comparación es verdadera.

En el quinto ejemplo, [] (un array vacío) es comparado con false (un valor booleano) y son convertidos al mismo tipo (number) antes de la comparación, entonces la comparación es verdadera.

Bueno HaWker, como puedes percibir, este contenido tiene una densidad de informaciones relativamente alta.

Y es común que te sientas confuso con mucha información.

Por eso, recuerda que si tienes dudas, siempre envíame tu duda como respuesta a estos artículos.

Siempre voy a intentar ayudarte de la mejor forma posible.

Estoy aquí para ayudarte a evolucionar y progresar en tu carrera.

Me estoy esforzando mucho para garantizar que consiga pasar toda la información necesaria concentrada dentro de este artículo.

Pero en caso de que quieras tener acceso a algo más, y tener acceso al contenido completo de toda la secuencia que vas a recibir a lo largo del tiempo.

Puedes hacer clic en este link, sin compromiso, enfatizo que esto es solo **si realmente quieres acelerar tu desarrollo a través de ejercicios prácticos y todos los contenidos organizados y separados en un único lugar, divididos en grados de prioridad, entre lo que necesitas aprender y lo que no es tan necesario en este inicio de viaje.

Te garantizo que esto va a acelerar mucho tus estudios.

En fin, dado el mensaje para los que quieren acelerar el desarrollo dentro del área, vamos a proseguir el contenido y entender sobre el Operador de igualdad estricta (===).

Operador de igualdad estricta (===)

El operador de igualdad estricta (===) es usado para verificar si dos valores son iguales y del mismo tipo.

Él no intenta convertir los valores al mismo tipo antes de hacer la comparación.

Por ejemplo:

console.log(1 === 1); // true
console.log('1' === 1); // false
console.log(true === 1); // false
console.log(null === undefined); // false
console.log([] === false); // false

Como podemos ver en el ejemplo arriba, el operador de igualdad estricta (===) no intenta convertir los valores al mismo tipo antes de hacer la comparación.

En el primer ejemplo, 1 es comparado con 1 y ambos son del mismo tipo (number) y valor, entonces la comparación es verdadera.

En el segundo ejemplo, '1' (una string) es comparada con 1 (number) y, como son de tipos diferentes, la comparación es falsa.

En el tercer ejemplo, true (un valor boolean) es comparado con 1 (un number) y, como son de tipos diferentes, la comparación es falsa.

En el cuarto ejemplo, null (un valor de referencia nula) es comparado con undefined (un valor de referencia no definido) y, aunque sean considerados iguales por el operador de igualdad simple, son de tipos diferentes, entonces la comparación es falsa.

PS: Si no entiendes los diferentes Tipos de Datos, accede a uno de los artículos anteriores que habla sobre Tipos de Datos y reléelo.

En el quinto ejemplo, [] (un array vacío) es comparado con false (un valor boolean) y, como son de tipos diferentes, la comparación es falsa.

Conclusión

En resumen, el operador de igualdad estricta (===) es generalmente considerado más seguro que el operador de igualdad simple (==), pues él no intenta convertir los valores al mismo tipo antes de la comparación.

Es recomendado siempre usar el operador de igualdad estricta, a menos que tengas una buena razón para usar el operador de igualdad simple.

Pues bien HaWker, llegamos al fin de un artículo más.

Espero que este artículo haya agregado en tu repertorio de conocimiento sobre Programación.

Como siempre, si tienes cualquier duda o quieres explorar más algún punto, simplemente responde tu duda en este email.

¡Y recuerda, estoy aquí para ayudarte a mejorar 1% con cada nuevo artículo!

¡Sensacional HaWker! 👏🏻

Si llegaste hasta aquí, como de costumbre, por favor, responde este email con "Conseguí entender las Comparaciones de Igualdad en la Programación".

De esta forma voy a saber que esta serie de artículos está siendo útil para ti, y que estás acompañando y aprovechando.

¡Como ya sabes! Solamente un verdadero HaWker llega hasta el final.

¡Felicitaciones!

Estoy feliz de tenerte aquí.

Te veo pronto.

¡Vamos a por ello! 🦅

- Jeff Bruchado

¡Felicitaciones por llegar hasta aquí, HaWker! 🎉

En este momento que aprendiste sobre las comparaciones de igualdad en la programación, ¿qué tal testear tus conocimientos? Participa del quiz abajo y ve cuánto absorbiste de nuestro artículo.

Es una excelente manera de fijar el aprendizaje y prepararte para los próximos pasos en tu viaje de programación.

Presiona para acceder al quiz.

¡Buena suerte y diviértete!