JavaScript
Acerca de JavaScript
JavaScript es un lenguaje bastante particular. Nació en 1995 sin más pretensión que la de agregarle algo de interactividad a las páginas de HTML pero con el tiempo fue sumando cada vez más complejidad hasta llegar a ser un lenguaje de programación a la misma altura que los más avanzados.
Sin embargo, por sus orígenes modestos, y por algunas rarezas propias del lenguaje, hasta el día de hoy sigue siendo despreciado por muchos programadores "serios" que lo consideran un lenguaje menor.
Otro problema con JavaScript es su nombre. Al usar el término "Java" (que es el nombre de un lenguaje de programación muy distinto a JS) podría pensarse que JavaScript es el hermano menor de Java, cuando en realidad tienen muy poco en común. Esta similaridad de nombres sigue generando confusión hasta el día de hoy (sobre todo entre los recruiters 🙄️).
Originalmente, JavaScript se llamaba LiveScript, un nombre que le sienta mucho mejor. Pero por una tonta razón por parte de los ejecutivos de Netscape (la empresa que desarrolló JS en esa época) ese nombre fue descartado porque pensaron que asociarlo con Java le daba más prestigio 🤦♂️️
Por otro lado, en comparación con otros lenguajes JavaScript es relativamente lento. Esto es porque para poder ejecutarse necesita primero ser interpretado (ya sea por el browser o por Node.js) y al mismo tiempo que es ejecutado va siendo traducido a código máquina (el código que la computadora puede entender en forma directa). En cambio, hay otros lenguajes (C++, C#, Rust, Go) que antes de ser ejecutados son compilados directamente a código máquina. Luego, lo que se ejecuta no es el código original, sino el código ya preparado para que la computadora lo entienda en forma directa, y esto hace que su ejecución sea mucho más rápida.
Esta lentitud fue compensada en gran parte gracias al motor V8, un intérprete de JS desarrollado por Google que es super eficiente (es el que usan Chrome y Node.js internamente).
A pesar de lo mucho que me gusta JavaScript, admito que tiene algunas cosas bastante polémicas:
Variables no declaradas
Todas las variables en JS, no importa si fueron declaradas con var, let o const, si fueron declaradas dentro de una función su alcance es sólo dentro de esa función. Con una excepción...
function unaFuncion() {
x = 1
}
unaFuncion()
console.log(x) // 1 🤨️Si la variable nunca fue declarada, por alguna extraña razón, es automáticamente convertida en una variable global que puede ser leída por fuera de la función 🤔️
JavaScript reprobó matemáticas
Otra de las cosas que hace que los programadores se burlen de JS es esto:
let ceroComaTres = 0.1 + 0.2 // El resultado debería ser 0.3
console.log(ceroComaTres) // 0.3000000000004 ️🤦♂️Según JavaScript, 0.1 + 0.2 no es 0.3 sino 0.300000000004 🙄️
Not A Number
Si intentamos dividir o multiplicar un numero por un string, vamos a obtener un error:
let multiplicacionConError = 2 * 'tres'
console.log(multiplicacionConError) // NaNNaN quiere decir Not A Number, o sea, el resultado no es un número porque 'tres' es un string 👍️
Pero si chequeamos qué tipo de dato es la variable:
console.log(typeof multiplicacionConError) // numberLa variable que no es un número es de tipo number 🤦♂️️
Y lo peor de todo es que si chequeamos la igualdad de esta variable consigo misma:
console.log(multiplicacionConError == multiplicacionConError) // falseLa variable no es igual a sí misma 😖️
Valores falsy
Las variables booleanas siempre son o verdaderas o falsas. Si la condición para ejecutar un bloque if es un booleano que es true, el bloque es ejecutado.
Pero, ¿qué pasa si lo que evaluamos es algo que no sea un booleano?
Por ejemplo, un string vacío:
let stringVacio = ''
if (!stringVacio) {
console.log('lo contrario de string vacio es true') // 'es true'
}El if se ejectuta porque un string vacío es false (o, mejor dicho, falsy), y con el signo de admiración (!stringVacio) lo convertimos en su contrario, o sea, true.
Y si probamos con un Array vacío:
const arrayVacio = []
if (arrayVacio) console.log('array vacío') // 'array vacio'Aunque un string vacío es false un array vacío es true (o, como se suele decir, truthy) 🤔️
Y lo mismo pasa con un objeto vacío, también es truthy.
La coerción de tipos de datos
En otros lenguajes de programación (C#, Java) al declarar una variable debe indicarse el tipo de dato: número entero (int), número fraccional (float), string, booleano, etc.
Pero en JS cualquier variable puede contener cualquier cosa. Esto le da más flexibilidad, pero también genera muchos problemas. Por ejemplo:
let uno = 1
let dos = '2'
let suma = dos + uno
console.log(suma) // '21' 🤦♂️Al encontrarse con un string JavaScript interpreta que estamos tratado de concatenar strings, no de sumar números, entonces, en lugar de avisarnos con un mensaje de error que estamos tratando de sumar tipos de datos distintos los concatena como si fuesen dos strings: '2' + '1'.
JavaScript con chequeo de tipado
Es por este tipo de cosas que muchos programadores prefieren usar TypeScript en vez de JS nativo.
El problema con TypeScript es que los browsers no pueden interpretarlo, antes debe ser compilado a JS nativo (y antes que eso debe ser instalado, claro).
Pero existe una alternativa más simple a TS para el chequeo de tipos que no requiere ninguna instalación previa ni compilación posterior: JSDoc.
//@ts-check
/**
* @param {number} num1
* @param {number} num2
* @returns {number}
*/
function suma(num1, num2) {
return num1 + num2
}
suma(1, '2') // El segundo param es marcado por VS Code como error
// por ser un string en vez de un númeroY no es necesario escribir todos esos comments a mano, con solo poner /** por encima de la función el autocompletado de VS Code hace el resto 👍️
Obviamente, TS no es solamente un lenguaje de tipado, tiene muchas otras funcionalidades, por ejemplo, los enums, los decorators, y otras cosas por el estilo que no están disponibles en JS nativo.
Así y todo, me hubiese gustado que JSDoc se convierta en el standard para el tipado en JavaScript, pero lamentablemente TypeScript se impuso y ya no hay vuelta atrás 🤷♂️️