5 cosas que haces mal en JavaScript
03-02-2022
1. Añadir saltos de línea donde no corresponde
JavaScript en ocasiones añade el ";" de forma explicita cuando hay un salto de línea. Si no tenemos cuidado con esto, puede haber comportamientos no esperados en nuestra aplicación. Es por ello que se aconseja evitar, tanto partir líneas en algunos casos, como abrir las llaves en la línea siguiente. En el siguiente ejemplo podéis ver lo que ocurre:
// Se añade ";" en el return, por lo que la línea `"Hi " + name` nunca se ejecuta.
function returnDeCadenaConSaltoDeLinea(name) {
return
"Hola " + name;
}
// Funciona como se espera
function returnEnLaMismaLinea(name) {
return "Hola " + name;
}
console.log(returnDeCadenaConSaltoDeLinea('John')); // undefined
console.log(returnEnLaMismaLinea('John')); // Hola John
Como se puede ver en el ejemplo tenemos dos funciones que, en primera instancia, parece que debieran devolver una cadena anteponiendo el texto "Hola ". En realidad en la primera función obtendremos undefined. Esto es, porque JavaScript aplica una regla llamada Automatic Semicolon Insertion (ASI), que en ciertos contextos inserta un ; implícitamente.
2. Usar siempre los bucles for tradicionales con arrays
Siempre que puedas, comienza a utilizar los bucles for...of (con aquellos elementos que sean iterables) o el método forEach en los arrays, ya que ofrecen una mejora en la legibilidad.
En el siguiente código puedes ver un ejemplo sencillo de los tres bucles.
for (let index = 0; index < arrayToIterate.length; ++index) {
console.log(arrayToIterate[index]);
}
for (const element of arrayToIterate) {
console.log(element);
}
arrayToIterate.forEach((element) => {
console.log(element);
});
- Con
for, debemos declarar el índice e indicar su incremento. Esto implica que para acceder a cada elemento necesitamos usar la nomenclaturanombreArray[indice]. - Con
for..ofobtenemos el elemento de cada posición sin usar un contador. Además podemos usarbreakycontinuepara controlar el flujo del recorrido. En el caso de necesitar un índice, si que tendremos que llevar un control manual. - Con
forEachel recorrido del bucle será completo. Por lo que si tienes que interrumpir el recorrido es mejor la otra opción. El segundo parámetro del callback es la posición, así que podremos usarla sin llevar un control manual como enfor..of.
3. Usar == y !=, en lugar de === y !==
Seguramente, esta te sonará. Y es que, a no ser que partas de un lenguaje tipado como TypeScript, el operadores de igualdad/desigualdad y no de identidad puede dar algún quebradero de cabeza. El uso de los operadores == y != compara el valor de cada variable y realiza un casting a otro tipo de dato si fuera necesario. Por el contrario, los operadores de identidad (=== y !==) aparte del valor, verifican que el tipo de dato sea el mismo.
const result = 123.456;
const expected = "123.456";
console.log(result === expected); // false
console.log(result == expected); // true
4. Seguir usando funciones para definir las clases
A no ser que tengas que hacer desarrollos para un navegador como IE (por tu bienestar mental, espero que no sea así). Deberías comenzar a usar la definición nativa de clases en JavaScript.
class Personaje {
#vida;
#ataque;
constructor(vidaInicial, ataqueInicial) {
this.#vida = vidaInicial;
this.#ataque = ataqueInicial;
}
mover() {
...
}
#puedeMoverse() {
...
}
}
La nueva sintaxis de JavaScript para definición de clases te proporciona un estilo mucho más próximo a lo que puedes ver en otros lenguajes de programación, así que olvídate de manipular directamente prototype, salvo que tengas un motivo muy concreto. Las clases no cambian el modelo de herencia, solo lo hacen más legible.
Puedes aprender más sobre esta sintaxis de JavaScript en la serie de artículos Orientación a objetos con JavaScript.
5. Usar var en lugar de let y const
¿Aún defines tus variables con var aunque nunca vayan a cambiar su valor? Pues bien, puedes usar let y const para evitar los problemas de hoisting; que se modifique lo que pensabas que era una constante; o, que pienses que una variable se encontraba en un ámbito acotado y es global. Al usar let o const, evitarás que las variables y constantes puedan usarse antes de su declaración.
function letYConst(parametro) {
let variableGlobalALaFuncion;
const constanteNoSePuedeCambiar = 123;
// Si ahora escribiéramos:
// constanteNoSePuedeCambiar = 345;
// tendríamos un error.
if (parametro) {
let variableConAmbitoDeIf = true;
}
// Si ahora intentamos llamar a variableConAmbitoDeIf, tendríamos un error.
}
Puedes ver más información sobre las diferencias entre let y var en este artículo.
Si estás empezando a programar, o empezando otra vez, en Guía de Programación en un Apocalipsis Zombi enseño TypeScript desde cero con problemas como los de aquí, solo que con zombis en la puerta. Hay un fragmento gratis para que pruebes antes de comprar, y si tienes Kindle Unlimited, el libro entero te sale gratis.