Что такое stack в Node.js?

Call Stack в Node.js — как JavaScript выполняет код

Stack (стек вызовов) в Node.js — это механизм, который JavaScript использует для отслеживания того, какие функции в данный момент выполняются. Это структура данных LIFO (Last In, First Out), где каждый вызов функции добавляется в стек, а после завершения удаляется.

Понимание Call Stack

Когда JavaScript выполняет код, каждый вызов функции добавляется в стек:

function add(a, b) {
  return a + b;
}

function multiply(x, y) {
  const sum = add(1, 2);
  return x * y * sum;
}

function calculate() {
  const result = multiply(3, 4);
  console.log(result);
}

calculate();

Процесс выполнения:

1. Call Stack: [Global]
2. calculate() вызвана
   Call Stack: [Global, calculate]
3. multiply() вызвана из calculate
   Call Stack: [Global, calculate, multiply]
4. add() вызвана из multiply
   Call Stack: [Global, calculate, multiply, add]
5. add() завершилась, вернула 3
   Call Stack: [Global, calculate, multiply]
6. multiply() завершилась, вернула 36
   Call Stack: [Global, calculate]
7. console.log() выполнен
   Call Stack: [Global, calculate, console.log]
8. calculate() завершилась
   Call Stack: [Global]

Stack Overflow Error

Если функция вызывает саму себя (рекурсия) без базового случая, стек переполняется:

function infinite() {
  console.log('Calling infinite...');
  infinite(); // Рекурсия без выхода
}

infinite();
// RangeError: Maximum call stack size exceeded

Правильная рекурсия с базовым случаем:

function factorial(n) {
  // Базовый случай — выход из рекурсии
  if (n <= 1) {
    return 1;
  }
  // Рекурсивный случай
  return n * factorial(n - 1);
}

console.log(factorial(5)); // 120

// Stack trace:
// factorial(5) -> factorial(4) -> factorial(3) -> factorial(2) -> factorial(1) -> return 1

Stack Trace в Error Handling

Когда происходит ошибка, Node.js выводит stack trace — полную цепочку вызовов:

function first() {
  second();
}

function second() {
  third();
}

function third() {
  throw new Error('Something went wrong!');
}

first();

Stack trace:

Error: Something went wrong!
    at third (/app/index.js:10:9)
    at second (/app/index.js:6:8)
    at first (/app/index.js:2:5)
    at Object.<anonymous> (/app/index.js:13:3)
    at Module._load (internal/modules/cjs/loader.js:663:5)
    at Function._load (internal/modules/cjs/loader.js:580:5)

Это показывает точный путь вызовов, приведший к ошибке.

Асинхронный код и Call Stack

Node.js разделяет выполнение кода на синхронную и асинхронную части:

console.log('1. Start');

setTimeout(() => {
  console.log('2. Timeout');
}, 0);

Promise.resolve().then(() => {
  console.log('3. Promise');
});

console.log('4. End');

// Вывод:
// 1. Start
// 4. End
// 3. Promise
// 2. Timeout

Объяснение:

CALL STACK:              CALLBACK QUEUE:        MICROTASK QUEUE:
┌─────────────┐          (setTimeout)           (Promises)
│ console.log │          ┌──────────┐          ┌─────────────┐
│   ('1')     │          │ setTimeout│          │ Promise.then│
└─────────────┘          └──────────┘          └─────────────┘
   ↓ (выполнится)           ↓                      ↓
   console.log('1')      (после стека)        (перед callback queue)

Event Loop сначала выполняет стек, потом микротаски, потом макротаски

Демонстрация Stack размера

const util = require('util');

function countStackSize() {
  const stack = new Error().stack;
  const frames = stack.split('\n').length;
  console.log(`Current stack depth: ${frames} frames`);
}

function level1() { level2(); }
function level2() { level3(); }
function level3() { level4(); }
function level4() { level5(); }
function level5() { countStackSize(); }

level1();
// Output:
// Current stack depth: 11 frames

Stack Trace Limits

Node.js имеет ограничение глубины стека:

// Получить максимальный размер стека
console.log(Error.stackTraceLimit); // 10 (по умолчанию)

// Установить новый лимит
Error.stackTraceLimit = 50;

function recursiveFn(n) {
  if (n === 0) {
    console.log(new Error().stack);
  } else {
    recursiveFn(n - 1);
  }
}

recursiveFn(20);
// Выведет stack trace с максимум 50 кадрами

Tail Call Optimization (TCO)

Некоторые языки оптимизируют хвостовую рекурсию, но JavaScript не гарантирует это:

// Обычная рекурсия (неоптимизированная)
function factorial(n, accumulator = 1) {
  if (n <= 1) {
    return accumulator;
  }
  return factorial(n - 1, n * accumulator);
}

// Даже если это хвостовой вызов, стек всё равно растёт
// Node.js обычно не оптимизирует это

Практические инструменты для анализа Stack

1. console.trace() — вывести текущий stack trace:

function processUser(userId) {
  console.trace('Processing user');
  // ... логика
}

processUser(123);
// Output:
// Trace: Processing user
//   at processUser (/app/index.js:2:15)
//   at Object.<anonymous> (/app/index.js:6:1)

2. Использование debugger:

function calculateTotal(prices) {
  debugger; // Точка остановки для отладчика
  let total = 0;
  for (const price of prices) {
    total += price;
  }
  return total;
}

// Запуск: node --inspect index.js
// Затем открыть Chrome DevTools на chrome://inspect

3. Профилирование в Node.js:

const profiler = require('v8').writeHeapSnapshot;

function expensiveOperation() {
  const data = [];
  for (let i = 0; i < 1000000; i++) {
    data.push({ id: i, value: Math.random() });
  }
  return data;
}

console.time('operation');
const result = expensiveOperation();
console.timeEnd('operation');
// Output:
// operation: 150ms

Синхронный vs Асинхронный Stack

// Синхронный стек видит всю цепочку вызовов
function sync1() {
  sync2();
}

function sync2() {
  throw new Error('Sync error');
}

sync1();

// Stack trace покажет: sync1 -> sync2 -> Error

// ============================================

// Асинхронный стек может быть разрывом
function async1() {
  setTimeout(() => {
    async2();
  }, 100);
}

function async2() {
  throw new Error('Async error');
}

async1();

// Stack trace покажет только async2 -> Error
// async1 не будет видна, так как setTimeout создаёт новый контекст

Решение для асинхронного stack trace

// Использовать async/await вместо callbacks
async function async1() {
  await new Promise(resolve => setTimeout(resolve, 100));
  async2();
}

async function async2() {
  throw new Error('Async error');
}

async1().catch(console.error);

// Или использовать library типа longjohn для восстановления стека
const longjohn = require('longjohn');

// Теперь стек будет показывать полную цепочку даже через асинхронные операции

Best Practices

1. Избегай слишком глубокой рекурсии

// Плохо: может переполнить стек
function deepRecursion(n) {
  if (n === 0) return;
  deepRecursion(n - 1);
}

deepRecursion(10000); // RangeError: Maximum call stack size exceeded

// Хорошо: используй итерацию
function deepLoop(n) {
  for (let i = n; i > 0; i--) {
    // ...
  }
}

deepLoop(10000); // Без проблем

2. Используй async/await для лучшего stack trace

// Плохо: callback hell теряет контекст
fs.readFile('file.txt', (err, data) => {
  processData(data, (err, result) => {
    saveResult(result, (err) => {
      // Stack trace потеряет информацию о readFile
    });
  });
});

// Хорошо: async/await сохраняет контекст
async function process() {
  const data = await fs.promises.readFile('file.txt');
  const result = await processData(data);
  await saveResult(result);
}

3. Мониторь stack usage в production

import os from 'os';

function checkMemoryHealth() {
  const memUsage = process.memoryUsage();
  const heapUsedPercent = (memUsage.heapUsed / memUsage.heapTotal) * 100;
  
  if (heapUsedPercent > 90) {
    console.warn('WARNING: High heap usage detected');
    // Trigger garbage collection
    if (global.gc) {
      global.gc();
    }
  }
}

setInterval(checkMemoryHealth, 60000);

// Запуск: node --expose-gc app.js

Call stack — это фундаментальная концепция JavaScript, которая определяет, как выполняется код. Понимание стека критично для отладки ошибок, оптимизации производительности и написания эффективного асинхронного кода.