Tips para un código limpio en Javascript
A la hora de programar 🤓 muchas veces cometemos el error de no hacer un código limpio y entendible, sobre todo si somos novatos en el tema. Esto a la larga puede traer dolores de cabeza, ya sea para nosotros mismos o para otros desarrolladores, a la hora de leer y entender nuestro código escrito.
A continuación voy a detallar unos tips para que nuestro código sea más bonito y entendible.
Desestructurar objetos 🤖
La desestructuración de objetos nos permite tomar propiedades específicas de un objeto y asignarlos a una variable inmediatamente. Esto nos reduce líneas, hace que sea fácil entender el código y nos ahorra tiempo en tener que declarar las variables, ya sea usando múltiples propiedades de un objeto, usar la misma propiedad varias veces o usar propiedades anidadas de un objeto.
// Declaramos la constante 'personaje' el cual es un objeto con las siguientes propiedades
const personaje = {
nombre: 'Homero',
apellido: 'Simpson',
email: 'homero@mail.com',
telefono: '123-123-1234',
direccion: {
calle: 'Avenida Siempreviva 742',
ciudad: 'Springfield',
pais: 'EEUU',
},
};❎ sin desestructuración
// Extraemos las propiedades del personaje en cada constante
const nombre = personaje.nombre;
const apellido = personaje.apellido;
const email = personaje.email;
const telefono = personaje.telefono;
const direccion = personaje.direccion;
// Extraemos las propiedades de la dirección en cada constante
const calle = personaje.direccion.calle;
const ciudad = personaje.direccion.ciudad;
const pais = personaje.direccion.pais;✅ con desestructuración
// Desestructuramos el personaje
const { nombre, apellido, email, telefono, direccion } = personaje;
// Desestructuramos la dirección
const { calle, ciudad, pais } = direccion;El resultado final de las dos formar son idénticas, pero el uso de la desestructuración de objetos hace que nuestro código sea más limpio, fácil de entender y más sencillo a la hora de programar.
Usar múltiples parámetros en lugar de usar un solo objeto como parámetro 😉
Al declarar una función, siempre debemos usar múltiples parámetros de entrada en lugar de un solo objeto como entrada. Este enfoque nos ayuda a comprender fácilmente la cantidad mínima de parámetros que deben pasarse al observar la firma del método.
Con esto evitamos crear parámetros del objeto que no vayamos a utilizar en la función lo cual evita "recolectar basura" y mejora el rendimiento de la aplicación. 🙌
// Con múltiples parámetros (recomendado)
function multipleParamteros(nombre, apellido, email) {
console.log(
'Nombre: ' + nombre + '. Apellido: ' + apellido + '. Email: ' + email
);
}
// Con un solo parámetros (no recomendado)
function unParametro(personaje) {
console.log(
'Nombre: ' +
personaje.nombre +
'. Apellido: ' +
personaje.apellido +
'. Email: ' +
personaje.email
);
}☝ Un dato importante a tener en cuenta es que si aumenta el número de parámetros de entrada, se recomienda enviar el objeto completo como parámetro para no caer en complejidades innecesarias del código.
Uso de Funciones de Flecha 🙆♂️
Las arrow functions, o funciones de flecha, nos brindan una forma muy concisa a la hora de escribir funciones en Javascript y estas nos resuelven el problema de acceder a la propiedad this dentro del retorno de los callbacks.
// Función regular
function infoPersonaje(nombre, apellido) {
const texto =
'El nombre completo del personaje es: ' + nombre + ' ' + apellido;
return texto;
}
// Función de flecha
const infoPersonaje = (nombre, apellido) => {
const texto =
'El nombre completo del personaje es: ' + nombre + ' ' + apellido;
return texto;
};Al utilizar las funciones de flecha, las llaves, los paréntesis y la palabra return se pueden volver opcionales si solo retornamos un valor:
const datosPersonaje = (nombre) => 'El nombre del personaje es: ' + nombre;☝ Dato a destacar: El uso de las funciones de flecha no es el mejor enfoque cuando se trabaja con prototipos de objetos, clases u objetos literales. Hay que destacar también que las funciones de flecha no se pueden utilizar como constructores de clases ya que ésto, retornaría un error al usar el método para crear un nuevo objeto a partir de una función de flecha.
Template Literals ✔
Los template literals ó plantillas literales para cadena de caracteres (strings) están delimitadas por backticks ( ` ` ). Esto nos provee una manera muy sencilla para interpolar strings en multilíneas de una manera muy eficaz.
Por ejemplo podemos, con unos sencillos backticks, establecer un texto de manera fácil el cual contiene variables sin concatenaciones innecesarias:
// Concatenando variables
const nombre = 'Homero';
const mensaje = 'Hola' + ' ' + nombre + '.';
// Usando templates literales
const nombre = 'Homero';
const mensaje = `Hola ${nombre}.`;El uso de estos templates es mucho más cómodo a la hora de escribir cadenas de strings, ya que no caemos en la confusión del cierre del mismo por ejemplo, o al colocar las variables, es mucho más fácil distinguir y colocar los espacios.
El operador Spread ◾◾◾
El operador Spread es una característica introducida en el ES6 y éste nos permite expandir o combinar arrays en elementos individuales en una línea de código.
El Spread Operator nos es bastante útil a la hora de colocar otro array u objeto dentro de un nuevo array o tambien combinar múltiples parámetros en el array.
const array = ['Homero', 'Moe', 'Barney'];
const nuevoArray = ['Carl', 'Lenny', ...array];
console.log(nuevoArray); // Carl, Lenny, Homero, Moe, BarneyEl código de arriba muestra la manera de combinar dos arrays usando el operador spread. Como se puede ver, usar esto hace que el código sea más limpio, fácil de entender y no es necesario usar ciclos como el for, foreach, entre otros.
Promesas - Async/Await 👐
Los callbacks son una manera de manejas los procesos asíncronos en las funciones de Javascript. El que los usó o sigue usando, creo que sabe la tensión en la nuca que provoca el tener que estar anidando múltiples callbacks:
miFuncion1(function (err, data) {
// hacer algo ...
miFuncion2(arg1, function (err, data) {
// hacer algo ...
miFuncion3(arg2, function (err, data) {
// hacer algo ...
miFuncion4(arg3, function (err, data) {
// hacer algo ...
});
});
});
});El código de arriba ejecuta una función en la cual se anidan 4 callbacks. Esto puede ser un verdadero desastre a la hora de entender el código si el código empieza a crecer y crecer.
Una solución que se introdujo en el ES6 y ES7 para manejar las funciones asíncronas fueron las Promises (Promesas) y el Async/Await, lo cual, hace que sea mucho más fácil escribir código e interpretarlo, ya sea por uno mismo o por otros desarrolladores. Usando las Promises o el Async/await nuestro código quedaría más limpio, ordenado y entendible.
Promesas 🙇♂️:
miFuncion()
.then(miFuncion2)
.then(miFuncion3)
.then(miFuncion2)
.catch((err) => console.error(err));Si en el caso de que usemos las Promises nuestro código crece mucho, también puede llegar a volverse un poco confuso (pero aun así es fácil de interpretar). Si las Promises no quedan a gusto, la otra alternativa sería usar el Async/Await.
Async/Await ✋:
const miFuncionAsync = async () => {
try {
const dato1 = await funcion1();
const dato2 = await funcion2(dato1);
const dato3 = await funcion3(dato2);
return {
data: dato3,
};
} catch (e) {
console.error(err);
}
};A mi parecer y gusto, dependiendo del caso, el uso del Async/Await es más fácil de implementar, estructurar y comprender.
Usar operadores cortos para reducir líneas de código 💡
Cuando trabajamos con condicionales, el trabajar con operadores cortos no reduce tiempo y líneas de código.
Por ejemplo si queremos checkear una variable en una condición la cual queremos saber si no está vacía, ni es null, ni es undefined, debemos de escribir varias condiciones en la sentencia del if:
if (personaje !== '' && personaje !== null && personaje !== undefined) {
// hacer algo ...
}En cambio si usamos operadores de forma corta podríamos hacerlo todo en una simple condición de manera fácil y concisa
if (!!personaje) {
// hacer algo ...
}Con esto obtendríamos el mismo resultado y nos ahorraríamos el tedioso tema de tener que escribir varias condiciones y que el código se vea extenso.
Conclusión 👨🏫
Como desarrolladores siempre tenemos que buscar la forma de escribir un código limpio para que sea fácil de comprender, tanto para uno mismo como para otros desarrolladores que lean el código.
Espero que estas características de javascript sean de ayuda y que el artículo te haya sido de mucha utilidad.
Gracias por leer. Nos vemos! 👋