Перейти до основного вмісту

Callbacks, Promises, async/await в Node.js

Node.js однопотоковий і використовує неблокуючий I/O. Замість створення нових потоків, Node.js реєструє callback-функції, які викликаються, коли операція завершується. Це схоже на CompletableFuture у Java, але є основним способом роботи.

1. Callbacks: Перший підхід до асинхронності

Callback — це функція, яку ви передаєте як аргумент і яка викликається після завершення операції. У Java це можна порівняти з передачею Consumer або Function як параметра.

// Node.js - callback pattern
import fs from 'fs';

// Error-first callback convention
fs.readFile('user.json', 'utf8', (err, data) => {
    if (err) {
        console.error('Помилка читання файлу:', err);
        return;
    }
    console.log('Дані:', data);
});

console.log('Цей рядок виведеться ПЕРШИМ!');

Конвенція Error-First Callback: Перший параметр завжди помилка (або null), другий — результат. Це стандарт у Node.js.

Приклад: HTTP-запит з callbacks

import http from 'http';

function fetchUser(userId: number, callback: (err: Error | null, user?: any) => void) {
    http.get(`http://api.example.com/users/${userId}`, (res) => {
        let data = '';
        
        res.on('data', (chunk) => {
            data += chunk;
        });
        
        res.on('end', () => {
            try {
                const user = JSON.parse(data);
                callback(null, user);
            } catch (err) {
                callback(err as Error);
            }
        });
    }).on('error', (err) => {
        callback(err);
    });
}

// Використання
fetchUser(123, (err, user) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('User:', user);
});

Проблема: Callback Hell (Піраміда Doom)

Коли потрібно виконати кілька асинхронних операцій послідовно, код стає нечитабельним:

// Callback Hell - погана практика!
fetchUser(123, (err, user) => {
    if (err) return console.error(err);
    
    fetchOrders(user.id, (err, orders) => {
        if (err) return console.error(err);
        
        fetchOrderDetails(orders[0].id, (err, details) => {
            if (err) return console.error(err);
            
            updateInventory(details.items, (err, result) => {
                if (err) return console.error(err);
                
                sendNotification(user.email, result, (err) => {
                    if (err) return console.error(err);
                    console.log('Все готово!');
                });
            });
        });
    });
});

У Java це виглядало б як вкладені CompletableFuture з вкладеними thenAccept. Неприємно, чи не так?

2. Promises: Розв'язання проблеми Callback Hell

Promise — це об'єкт, що представляє майбутнє значення. Аналог у Java — CompletableFuture<T>.

Три стани Promise:

  • Pending — очікує виконання (як незавершений Future)
  • Fulfilled — успішно завершено з результатом
  • Rejected — завершено з помилкою
// Створення Promise
function fetchUser(userId: number): Promise<any> {
    return new Promise((resolve, reject) => {
        http.get(`http://api.example.com/users/${userId}`, (res) => {
            let data = '';
            
            res.on('data', (chunk) => {
                data += chunk;
            });
            
            res.on('end', () => {
                try {
                    const user = JSON.parse(data);
                    resolve(user); // Еквівалент completableFuture.complete(user)
                } catch (err) {
                    reject(err); // Еквівалент completableFuture.completeExceptionally(err)
                }
            });
        }).on('error', (err) => {
            reject(err);
        });
    });
}

Ланцюжки Promise (Promise Chaining)

Метод .then() повертає новий Promise, що дозволяє будувати ланцюжки:

// Promise chaining - набагато читабельніше!
fetchUser(123)
    .then(user => {
        console.log('Користувач:', user);
        return fetchOrders(user.id); // Повертаємо новий Promise
    })
    .then(orders => {
        console.log('Замовлення:', orders);
        return fetchOrderDetails(orders[0].id);
    })
    .then(details => {
        console.log('Деталі:', details);
        return updateInventory(details.items);
    })
    .then(result => {
        console.log('Результат:', result);
    })
    .catch(err => {
        // Один обробник помилок для всього ланцюжка!
        console.error('Помилка:', err);
    })
    .finally(() => {
        console.log('Завершено (незалежно від результату)');
    });

Це схоже на CompletableFuture.thenCompose() у Java.

Паралельне виконання з Promise.all

// Аналог CompletableFuture.allOf() у Java
const promises = [
    fetchUser(123),
    fetchUser(456),
    fetchUser(789)
];

Promise.all(promises)
    .then(users => {
        console.log('Всі користувачі:', users);
        // users - це масив результатів у тому ж порядку
    })
    .catch(err => {
        // Якщо хоча б один Promise rejected
        console.error('Помилка:', err);
    });

Promise.race та Promise.allSettled

// Promise.race - повертає перший завершений Promise
Promise.race([
    fetchFromPrimaryDB(),
    fetchFromReplicaDB()
])
.then(result => console.log('Найшвидша відповідь:', result));

// Promise.allSettled - чекає на всі Promise (навіть rejected)
Promise.allSettled([
    fetchUser(123),
    fetchUser(999), // Може не існувати
    fetchUser(456)
])
.then(results => {
    results.forEach(result => {
        if (result.status === 'fulfilled') {
            console.log('Успіх:', result.value);
        } else {
            console.log('Помилка:', result.reason);
        }
    });
});

3. Async/Await: Синтаксичний цукор над Promises

У Java 21+ з'явилися Virtual Threads та Structured Concurrency. Async/await у JavaScript з'явився раніше і робить асинхронний код схожим на синхронний.

// Async/await - найсучасніший підхід
async function processOrder(userId: number): Promise<void> {
    try {
        // await "розпаковує" Promise і чекає на результат
        const user = await fetchUser(userId);
        console.log('Користувач:', user);
        
        const orders = await fetchOrders(user.id);
        console.log('Замовлення:', orders);
        
        const details = await fetchOrderDetails(orders[0].id);
        console.log('Деталі:', details);
        
        const result = await updateInventory(details.items);
        console.log('Результат:', result);
        
    } catch (err) {
        // Ловимо помилки з будь-якого await
        console.error('Помилка:', err);
    } finally {
        console.log('Завершено');
    }
}

// Виклик async функції
processOrder(123);

Важливо: await можна використовувати тільки всередині async функції. Async функція завжди повертає Promise.

Паралельне виконання з async/await

// НЕПРАВИЛЬНО - послідовне виконання (повільно!)
async function getMultipleUsers() {
    const user1 = await fetchUser(123); // Чекаємо 1 секунду
    const user2 = await fetchUser(456); // Чекаємо ще 1 секунду
    const user3 = await fetchUser(789); // Чекаємо ще 1 секунду
    return [user1, user2, user3]; // Загалом: 3 секунди
}

// ПРАВИЛЬНО - паралельне виконання (швидко!)
async function getMultipleUsersFast() {
    // Запускаємо всі Promise одночасно
    const [user1, user2, user3] = await Promise.all([
        fetchUser(123),
        fetchUser(456),
        fetchUser(789)
    ]);
    return [user1, user2, user3]; // Загалом: ~1 секунда
}

Порівняння з Java Spring Boot

// Java/Spring Boot - блокуючий підхід
@Service
public class OrderService {
    public OrderResponse processOrder(Long userId) {
        User user = userRepository.findById(userId);
        List<Order> orders = orderRepository.findByUserId(userId);
        OrderDetails details = orderClient.getDetails(orders.get(0).getId());
        return new OrderResponse(user, orders, details);
    }
}

// Node.js - async/await
async function processOrder(userId: number): Promise<OrderResponse> {
    const user = await userRepository.findById(userId);
    const orders = await orderRepository.findByUserId(userId);
    const details = await orderClient.getDetails(orders[0].id);
    return { user, orders, details };
}

// Java - з CompletableFuture (реактивний підхід)
public CompletableFuture<OrderResponse> processOrderAsync(Long userId) {
    return userRepository.findByIdAsync(userId)
        .thenCompose(user -> 
            orderRepository.findByUserIdAsync(userId)
                .thenCompose(orders ->
                    orderClient.getDetailsAsync(orders.get(0).getId())
                        .thenApply(details -> 
                            new OrderResponse(user, orders, details)
                        )
                )
        );
}

Обробка помилок: порівняння підходів

Підхід Обробка помилок Читабельність
Callbacks Error-first параметр, перевірка в кожному callback ❌ Погано (callback hell)
Promises .catch() в кінці ланцюжка ✅ Добре
Async/Await try/catch блоки (як у Java!) ✅✅ Відмінно

Типові помилки та best practices

// ❌ ПОМИЛКА 1: Забути return у Promise chain
fetchUser(123)
    .then(user => {
        fetchOrders(user.id); // Забули return!
        // Наступний .then() отримає undefined
    })
    .then(orders => {
        console.log(orders); // undefined!
    });

// ✅ ПРАВИЛЬНО
fetchUser(123)
    .then(user => {
        return fetchOrders(user.id); // Повертаємо Promise
    })
    .then(orders => {
        console.log(orders); // Масив замовлень
    });

// ❌ ПОМИЛКА 2: Не обробляти rejected promises
async function riskyOperation() {
    await somethingThatMightFail(); // Якщо fail, необроблена помилка!
}

// ✅ ПРАВИЛЬНО
async function safeOperation() {
    try {
        await somethingThatMightFail();
    } catch (err) {
        console.error('Обробили помилку:', err);
        // Або прокинути далі: throw err;
    }
}

// ❌ ПОМИЛКА 3: Змішувати callbacks і promises
async function confused() {
    fs.readFile('file.txt', (err, data) => { // Callback
        return data; // Це НЕ СПРАЦЮЄ!
    });
}

// ✅ ПРАВИЛЬНО: Використовувати promise-based API
import { readFile } from 'fs/promises';

async function correct() {
    const data = await readFile('file.txt', 'utf8');
    return data;
}

Util.promisify: Перетворення callbacks у promises

import { promisify } from 'util';
import fs from 'fs';

// Перетворюємо callback-based функцію на Promise-based
const readFileAsync = promisify(fs.readFile);

async function readConfig() {
    try {
        const data = await readFileAsync('config.json', 'utf8');
        return JSON.parse(data);
    } catch (err) {
        console.error('Помилка читання конфігу:', err);
        throw err;
    }
}

// Або використовувати вбудований fs/promises:
import { readFile } from 'fs/promises';

async function readConfigModern() {
    const data = await readFile('config.json', 'utf8');
    return JSON.parse(data);
}

Практичний приклад: Express endpoint

import express, { Request, Response } from 'express';

const app = express();

// ПОГАНО: callback hell в Express
app.get('/user/:id/orders', (req, res) => {
    getUserById(req.params.id, (err, user) => {
        if (err) return res.status(500).json({ error: err.message });
        
        getOrdersByUserId(user.id, (err, orders) => {
            if (err) return res.status(500).json({ error: err.message });
            
            res.json({ user, orders });
        });
    });
});

// ДОБРЕ: async/await (як контролер у Spring!)
app.get('/user/:id/orders', async (req: Request, res: Response) => {
    try {
        const user = await getUserById(req.params.id);
        const orders = await getOrdersByUserId(user.id);
        
        res.json({ user, orders });
    } catch (err) {
        res.status(500).json({ 
            error: err instanceof Error ? err.message : 'Unknown error' 
        });
    }
});

// ЩЕ КРАЩЕ: з обробником помилок
app.get('/user/:id/orders', asyncHandler(async (req: Request, res: Response) => {
    const user = await getUserById(req.params.id);
    const orders = await getOrdersByUserId(user.id);
    res.json({ user, orders });
}));

// Utility для автоматичної обробки помилок
function asyncHandler(fn: Function) {
    return (req: Request, res: Response, next: Function) => {
        Promise.resolve(fn(req, res, next)).catch(next);
    };
}

Підсумок: Що використовувати?

  • Callbacks — уникайте в новому коді. Використовуйте тільки якщо працюєте зі старими бібліотеками.
  • Promises — добре для складних ланцюжків та комбінування операцій (Promise.all, Promise.race).
  • Async/Await — основний вибір для більшості випадків. Код виглядає як синхронний Java-код.

Якщо ви з Java/Spring Boot світу — використовуйте async/await. Це найближче до того, як ви пишете код зараз, але з перевагами неблокуючого I/O.

Labels:

Коментарі

Дописати коментар

Популярні публікації

Створення нового Elixir-проєкту

Для створення новго Elixir-проєкту можна використати команду mix new first_project --sup Зрозуміло, що Elixir має бути встановлений раніше. Пояснення команди: mix — це вбудований інструмент для управління проєктами в Elixir (аналог maven у Java чи npm у JavaScript ). new — підкоманда mix, яка створює новий проєкт. first_project — назва твого нового проєкту. Папка з цією назвою буде створена у поточному каталозі. --sup — опціональний прапорець, який додає шаблон структури з Supervision Tree. Це означає, що створений проєкт одразу буде мати структуру, яка підтримує супервізор (супервізор керує життєвим циклом процесів у системі, перезапускаючи їх при падінні). Щоб створити файл з тестом, можна запустити команду із директорії проєкту mix test Приблизний вигляд структури проєкту:
Дописати коментар
Читати далі »

Агрегати в DDD

Domain-Driven Design (DDD, предметно-орієнтоване проєктування) — це підхід до розробки програмного забезпечення, який зосереджується на моделюванні бізнес-логіки на основі реального домену (предметної області). Його запропонував Ерік Еванс у своїй книзі "Domain-Driven Design: Tackling Complexity in the Heart of Software". Основні принципи DDD Фокус на домені – головна увага приділяється предметній області, а не технічним деталям. Єдина мова (Ubiquitous Language) – розробники, бізнес-аналітики та інші учасники проєкту використовують спільну термінологію, щоб уникнути непорозумінь. Бізнес-логіка відокремлена від технічної реалізації – код моделюється так, щоб він чітко відображав реальний бізнес-процес. Основні концепції DDD Entity (Сутність) – об’єкт з унікальним ідентифікатором, що зберігається в системі (наприклад, Користувач, Замовлення). Value Object (Об’єкт-значення) – об’єкт, який не має унікального ідентифікатора та є незмінним (наприклад, Адреса або Гроші)...
Дописати коментар
Читати далі »

Стратегії ребалансування в Kafka

Стратегії ребалансування в Kafka Ребалансування (Rebalancing) — це процес перерозподілу партицій між споживачами (сonsumer) у групі (Consumer Group). Kafka має кілька стратегій ребалансування: RangeAssignor. Ця стратегія розподіляє партиції на основі діапазонів, які створюються відповідно до сортування топіків і партицій. Наприклад, якщо є два консюмери і 6 партицій (P0–P5), перший консюмер отримає P0–P2, а другий — P3–P5. Особливості: Простий алгоритм. Може призводити до нерівномірного розподілу, якщо кількість партицій не ділиться порівну між консюмерами. RoundRobinAssignor. Ця стратегія рівномірно розподіляє партиції між консюмерами за круговим принципом. Наприклад, якщо є два консюмери і 6 партицій, перший отримає P0, P2, P4, а другий — P1, P3, P5. Особливості: Гарантує більш рівномірний розподіл партицій. Використовується в багатотопікових сценаріях. StickyAssignor. Ця стратегія намагається мінімізувати кількість змін у розподілі партицій між консюмерами при ре...
Дописати коментар
Читати далі »

Основи Elixir

Elixir — це функційна мова програмування, яка працює на віртуальній машині Erlang (BEAM). Вона призначена для створення масштабованих і відмовостійких систем. Elixir успадкував багато переваг Erlang, таких як легкість паралельного програмування та висока доступність, але також додав сучасний синтаксис та інструменти для розробки. Основні концепції Elixir Elixir є функційною мовою, тому вона орієнтована на використання функцій та незмінних даних. Ось декілька ключових концепцій: Незмінність даних. Усі дані в Elixir є незмінними, що спрощує роботу з паралельними процесами. Функції. Функції є основним будівельним блоком програми. Вони можуть бути анонімними або іменованими. Паттерн-матчинг. Elixir використовує паттерн-матчинг для роботи з даними, що дозволяє легко розбирати структури даних. Процеси. Elixir використовує легкі процеси для паралельного виконання завдань. Ці процеси ізольовані та спілкуються через передачу повідомлень. Синтаксис Elixir Синтаксис Elixir є прос...
Дописати коментар
Читати далі »

Angular CLI

CLI (command-line interface) – інтерфейс командного рядка. Перед початком роботи має бути встановлений Node.js Встановлення: npm install -g @angular/cli Отримання допомоги: ng help Буде приблизно такий результат: add Adds support for an external library to your project. analytics Configures the gathering of Angular CLI usage metrics. See https://angular.io/cli/usage-analytics-gathering. build (b) Compiles an Angular app into an output directory named dist/ at the given output path. Must be executed from within a workspace directory. deploy Invokes the deploy builder for a specified project or for the default project in the workspace. config Retrieves or sets Angular configuration values in the angular.json file for the workspace. doc (d) Opens the official Angular documentation (angular.io) in a browser, and searches for a given keyword. e2e (e) Builds and serves an Angular app, then runs end-to-end tests. extract-i18n (i18n-extract, xi18n) Extracts i18n mes...
Дописати коментар
Читати далі »