14 curiosidades de JavaScript que todo desarrollador Front-End debe conocer

JavaScript es un lenguaje de programación muy popular, especialmente en el ámbito del desarrollo web. Sin embargo, tiene algunas peculiaridades que podrían sorprenderte.

Aquí tengo 14 curiosidades de JavaScript que quizás no conocías y que vale la pena tener en cuenta como desarrollador Front-End:

Ejecución asíncrona y single-threaded: JavaScript tiene fama de ser un lenguaje con un modelo de concurrencia single-threaded, basado en un event loop. Esto significa que solo puede realizar una tarea a la vez, pero también puede ejecutar operaciones asíncronas mediante el uso de eventos, promesas y async / await. Gracias a este modelo de ejecución, JavaScript es perfecto para aplicaciones web modernas y eficientes.
Tipado dinámico y débil: A diferencia de otros lenguajes de programación, JavaScript es un lenguaje de tipado dinámico, lo que significa que no necesitas especificar el tipo de una variable al declararla. Además, es un lenguaje de tipado débil porque permite realizar operaciones entre tipos distintos. Así, puedes sumar números con cadenas de texto, entre otros, lo que puede ser fuente de errores pero también una gran flexibilidad.
NaN es un número: Parece una contradicción, pero en JavaScript, el valor NaN (Not a Number) es de tipo number. Esto sucede porque JavaScript sigue el estándar IEEE 754 para los números de coma flotante, en el cual NaN representa el resultado de operaciones matemáticas indefinidas.
```
console.log(typeof NaN) // Output: "number"
```
0.1 + 0.2 no es igual a 0.3: JavaScript también sigue el estándar IEEE 754 en la representación de números de punto flotante. Esto implica que ciertas operaciones matemáticas pueden provocar resultados inesperados debido a las limitaciones de la representación binaria de los números.
```
console.log(0.1 + 0.2) // Output: 0.30000000000000004
console.log(0.1 + 0.2 === 0.3) // Output: false
```
Objetos casi todo: En JavaScript, casi todo es un objeto. Los arreglos, funciones y expresiones regulares son objetos con sus propias propiedades y métodos. Incluso los primitivos (a excepción de null y undefined) se tratan como objetos temporales cuando se les aplica métodos.
```
console.log(typeof [1, 2, 3]) // Output: "object"
console.log(typeof function () {}) // Output: "function" pero es también un objeto
```
Hoisting: En JavaScript, las declaraciones de variables y funciones son movidas implícitamente al inicio de su correspondiente ámbito antes de ser ejecutadas. Este comportamiento, llamado hoisting, permite utilizar variables y funciones antes de declararlas en el código, pero también puede conducir a errores si no se maneja con cuidado.
```
console.log(miVariable)
// Output: undefined (no arroja error incluso antes de declararla)
var miVariable = 42
```
Igualdad (==) vs. Estricta igualdad (===): JavaScript cuenta con dos operadores de igualdad diferentes: la igualdad abstracta (==) y la igualdad estricta (===). Mientras que la primera compara dos variables convirtiéndolas al mismo tipo antes de hacer la comparación, la segunda compara tanto el valor como el tipo de las variables, lo que evita posibles errores al comparar variables de diferentes tipos.
```
console.log(42 == '42') // Output: true (compara el valor después de convertir el tipo)
console.log(42 === '42') // Output: false (compara el valor y el tipo sin convertir)
```
Adición de Arrays y Objetos: En JavaScript, los operadores "+" y "+" están sobrecargados, lo que significa que pueden hacer cosas inesperadas al aplicarse a ciertos tipos de datos. Por ejemplo:
```
[] + [] // => ""
{} + [] // => 0
[] + {} // => "[object Object]"
```
Aunque pueda parecer extraño, esto es debido a cómo JavaScript maneja la conversión de tipos.
parseFloat y parseInt: JavaScript cuenta con dos funciones para convertir valores string en números: parseFloat y parseInt. Pero también hay un truco interesante para convertir rápidamente un string en un número:
```
;+'42' // => 42
```
Este truco utiliza el operador unario "+" para convertir implícitamente el string a un número.
Comma operator: El operador de coma es una característica bastante desconocida pero útil de JavaScript. Permite ejecutar varias expresiones en una sola declaración. El resultado final será el valor de la última expresión.
```
let a = (3, 4, 5) // a será igual a 5
```
Este operador puede ser útil cuando se requiere compactar varias asignaciones en una sola línea.
Números decimales: Como en muchos otros lenguajes de programación, JavaScript utiliza la aritmética de punto flotante para representar números decimales. Esto puede causar resultados inesperados durante operaciones matemáticas:
```
0.1 + 0.2 // => 0.30000000000000004
```
Este comportamiento es una consecuencia del estándar IEEE 754 para números de punto flotante binario y debe tenerse en cuenta al trabajar con operaciones numéricas en JavaScript.
Valores "Truthy" y "Falsy": Cada valor en JavaScript tiene una propiedad booleana implícita que determina si es "truthy" (verdadero) o "falsy" (falso). Algunos ejemplos incluyen:
```
1, -1, ' ', {} // Truthy
0, -0, NaN, undefined, null, '' // Falsy
```
Estos valores pueden ser útiles en condiciones y operaciones lógicas.
Cortocircuitos lógicos: El cortocircuito es un concepto en programación que permite evaluar expresiones de izquierda a derecha y detenerse tan pronto como se pueda determinar el resultado final. Esto es especialmente útil en JavaScript con operadores lógicos como && y ||.
```
1 || 2 // Evalúa 2 porque 1 es "truthy" y 2 es el siguiente valor.
0 && 1 // => 1 // Evalúa 0 porque 0 es "falsy" y 1 no necesita ser evaluado.
```
IIFE: Immediately Invoked Function Expression: Las IIFE son funciones que se declaran y ejecutan automáticamente. Son útiles para aislar variables del ámbito global y para crear código modular.
```
;(function () {
  // Tu código aquí
})()
```
Este patrón es útil para evitar conflictos de variables en aplicaciones JavaScript de gran escala.

Estas son tan solo algunas de las curiosidades de JavaScript que todo desarrollador Front-End debería conocer y tener en cuenta al escribir su código.

Por supuesto, hay mucho más por descubrir y aprender sobre este fascinante lenguaje de programación, pero estas características son un buen punto de partida para entender y dominar JavaScript.