Что такое стек вызовов (call stack) в Node.js?

Ёпта, слушай сюда, разберемся с этим стеком вызовов в Node.js, а то народ путается, как сука в трёх соснах.

Представь себе, что стек вызовов — это такая стопка тарелок, ебать мои старые костыли. Принцип простой: какую тарелку последней поставил — ту первую и возьмёшь. Это и есть LIFO. Каждый раз, когда ты вызываешь какую-нибудь функцию, её, как новую тарелку, кладут на самый верх стопки. А как только она отработала — всё, снимают её оттуда, и управление возвращается к той функции, что была под ней.

Вот смотри на примере, тут всё понятно:

function greet(name) {
  return `Hello, ${name}!`;
}

function welcome() {
  const message = greet('Alice'); // (1) Вызов greet
  console.log(message); // (3) Вызов console.log
}

welcome(); // Начальный вызов

Что по шагам происходит, а?

1. Вызываем welcome() — кладём эту тарелку в стопку.
2. Внутри welcome зовётся greet('Alice'). Хуй с горы! Сверху на welcome кладём greet.
3. greet отработала, вернула строку и — бац! — её снимают со стека. Выкинули, короче.
4. Управление вернулось в welcome. Теперь там console.log(...) вызывается. Ну, ясен пень, кладём console.log наверх.
5. console.log отработал — и его тоже снимаем. Тарелочку помыли.
6. welcome закончила свою работу — и её снимают. Стек пустой, всё чисто.

А теперь, чувак, главная фишка, из-за которой все мозги выносят. В Node.js этот самый стек работает в одном-единственном основном потоке. И если ты туда сунешь какую-нибудь долгую синхронную операцию — всё, приехали. Приложение встанет колом, как будто его впендюрили. Никакие новые запросы обрабатывать не сможет, пока эта операция не закончится. Пиздец, а не архитектура.

Вот тебе антипаттерн, смотри, как делать НЕ НАДО:

const fs = require('fs');

// СИНХРОННОЕ чтение файла — это ядрёна вошь! Стек заблокирован намертво.
const data = fs.readFileSync('/path/to/huge/file.txt'); // Пока файл не прочитается, все тут и застынут
console.log('Это выполнится только после полного чтения файла');

Вот это и есть та самая блокировка. Удивление пиздец, как народ такое в продакшене пихает.

А как правильно-то? А правильно — через асинхронные операции и Event Loop, ёпта! Асинхронные штуки (типа fs.readFile, setTimeout или запросы в сеть) не выполняются в основном стеке. Они как хитрая жопа: передают свою работу (callback или Promise) куда-то в системные недра Node.js (в libuv, если точнее), а сам стек в это время — свободен! Освободился, понимаешь? И когда эта фоновая операция наконец-то допиздится до конца, её колбэк ставят в очередь. А потом Event Loop, когда увидит, что стек пустой, аккуратно достаёт этот колбэк из очереди и кладёт его в стек на выполнение. Вот и вся магия.

Смотри, как это выглядит в жизни:

// НЕБЛОКИРУЮЩИЙ асинхронный код
const fs = require('fs').promises;

async function readFile() {
  console.log('(1) Начало чтения файла (стек свободен)');
  // Асинхронный вызов — стек освобождается моментально, можно чай пить
  const data = await fs.readFile('/path/to/file.txt');
  console.log('(3) Файл прочитан, callback выполнен');
}

console.log('(0) До вызова async функции');
readFile();
console.log('(2) Стек свободен, можно обрабатывать другие запросы');

Видишь? После вызова readFile() стек не застыл, мы сразу печатаем вторую строчку. Красота!

Ну и классика жанра — переполнение стека, или Stack Overflow. Это когда ты на рекурсию подсел, а выхода из неё не предусмотрел. Стек растёт, как на дрожжах, пока не кончится память.

function recursiveFunc() {
  recursiveFunc(); // Бесконечный самовызов, мудя...
}
recursiveFunc(); // RangeError: Maximum call stack size exceeded

Вот тут тебе и выскочит ошибка, что лимит стека исчерпан. Сам от себя охуеешь, когда такое в логах увидишь. Так что, чувак, следи за глубиной рекурсии, а то будет тебе хиросима.