JavaScript: Programación asíncrona

La programación asíncrona en JavaScript es esencial para gestionar operaciones no bloqueantes, como llamadas a APIs, operaciones de entrada/salida y temporizadores. Este módulo profundiza en técnicas y conceptos clave para manejar la asincronía de manera eficiente en JavaScript.

Callbacks

Los callbacks son funciones que se pasan como argumento a otra función y se ejecutan después de que la operación principal haya finalizado. Aunque son útiles, pueden llevar al "callback hell" si no se gestionan adecuadamente.

function realizarOperacion(callback) {
    setTimeout(() => {
        console.log('Operación completada');
        callback();
    }, 2000);
}

realizarOperacion(() => {
    console.log('Callback ejecutado');
});

Promesas

Las promesas son un avance significativo sobre los callbacks, proporcionando una forma más manejable y legible de manejar operaciones asíncronas. Una promesa puede estar en uno de tres estados: pendiente, cumplida o rechazada.

const promesa = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve('Operación completada');
    }, 2000);
});

promesa
    .then(resultado => {
        console.log(resultado);
    })
    .catch(error => {
        console.error(error);
    });

Async/Await

Introducido en ECMAScript 2017, async/await es una sintaxis que permite escribir código asíncrono de manera más sincrónica, mejorando la legibilidad y reduciendo la complejidad de manejo de errores.

async function realizarOperacion() {
    try {
        const resultado = await new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve('Operación completada');
            }, 2000);
        });
        console.log(resultado);
    } catch (error) {
        console.error(error);
    }
}

realizarOperacion();

Manejo de errores

El manejo de errores en la programación asíncrona es crucial para crear aplicaciones robustas. Con async/await, los errores pueden ser manejados usando bloques try/catch.

async function realizarOperacionConErrores() {
    try {
        const resultado = await new Promise((resolve, reject) => {
            setTimeout(() => {
                reject('Error en la operación');
            }, 2000);
        });
        console.log(resultado);
    } catch (error) {
        console.error('Se produjo un error:', error);
    }
}

realizarOperacionConErrores();

Operaciones concurrentes

JavaScript permite ejecutar múltiples operaciones asíncronas de manera concurrente usando Promise.all, lo que es útil para optimizar el rendimiento.

async function realizarOperacionesConcurrentes() {
    try {
        const resultados = await Promise.all([
            new Promise((resolve) => setTimeout(() => resolve('Operación 1 completada'), 1000)),
            new Promise((resolve) => setTimeout(() => resolve('Operación 2 completada'), 2000)),
            new Promise((resolve) => setTimeout(() => resolve('Operación 3 completada'), 3000))
        ]);
        console.log(resultados);
    } catch (error) {
        console.error('Se produjo un error en una de las operaciones:', error);
    }
}

realizarOperacionesConcurrentes();