Что такое стек вызовов (Call Stack) и является ли он частью движка V8?

Стек вызовов (Call Stack) — это механизм, используемый JavaScript движком для отслеживания выполнения функций. Да, стек вызовов является неотъемлемой частью V8 и любого другого JavaScript движка.

Что такое Call Stack

Call Stack — это структура данных (конкретно, стек LIFO — Last In, First Out), которая хранит информацию о выполняемых функциях:

• Какая функция сейчас выполняется
• Где она была вызвана
• Какие локальные переменные она имеет

function a() {
  console.log('Start A');
  b();
  console.log('End A');
}

function b() {
  console.log('Start B');
  c();
  console.log('End B');
}

function c() {
  console.log('Start C');
}

a();

// Call Stack в процессе выполнения:
// a() вызвана → [a]
// b() вызвана из a → [a, b]
// c() вызвана из b → [a, b, c]
// c() завершена → [a, b]
// b() завершена → [a]
// a() завершена → []

Логика работы

глобальный контекст
      ↓
   function a()
      ↓
   function b()
      ↓
   function c()
      ↓
   вернуть из c
      ↓
   вернуть из b
      ↓
   вернуть из a
      ↓
   завершение

V8 движок и Call Stack

Да, стек вызовов является основной частью V8 (и любого другого движка). V8 — это JavaScript движок от Google, используемый в Node.js и Chrome.

Структура V8:

┌─────────────────────────┐
│      JavaScript         │
│      (исходный код)     │
└────────────┬────────────┘
             │
      ┌──────▼──────┐
      │  Parser     │ (парсинг кода)
      └──────┬──────┘
             │
      ┌──────▼──────┐
      │   AST       │ (абстрактное синтаксическое дерево)
      └──────┬──────┘
             │
      ┌──────▼──────┐
      │ Compiler    │ (компиляция)
      └──────┬──────┘
             │
      ┌──────▼──────────────┐
      │   Machine Code      │
      │   + Call Stack      │ ← ВОТ ЗДЕСЬ
      │   + Memory Heap     │
      └─────────────────────┘

V8 компоненты

V8 состоит из:

1. Call Stack — стек вызовов (синхронный код)
2. Memory Heap — куча (хранение объектов)
3. Event Loop — цикл событий (асинхронный код)
4. Callback Queue — очередь обратных вызовов
5. Web APIs (в браузере) / Node APIs (в Node.js)

Стек Stack vs Heap

function process(data) {
  const num = 42; // Stack - примитив
  const obj = {x: 1}; // Stack хранит ссылку, сам объект в Heap
  const arr = [1, 2, 3]; // Stack хранит ссылку, массив в Heap
  return num + obj.x;
}

// Stack (локальные переменные):
// - num: 42
// - obj: <ref to heap>
// - arr: <ref to heap>

// Heap (объекты):
// - {x: 1}
// - [1, 2, 3]

Stack Overflow

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

function recursive(n) {
  console.log(n);
  return recursive(n + 1); // Бесконечная рекурсия
}

recursive(0);
// RangeError: Maximum call stack size exceeded

Отладка Call Stack

В DevTools браузера видно содержимое стека вызовов:

function outer() {
  debugger; // Точка останова
  inner();
}

function inner() {
  throw new Error('Stack trace');
}

outer();

// Call Stack в DevTools покажет:
// inner()
// outer()
// <anonymous> (основной код)

Event Loop и Call Stack

Важно понимать взаимодействие между ними:

console.log('1');

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

console.log('3');

// Вывод:
// 1
// 3
// 2

// Почему?
// 1. Call Stack выполняет console.log('1') → вывод "1"
// 2. setTimeout отправляет callback в Callback Queue
// 3. Call Stack выполняет console.log('3') → вывод "3"
// 4. Call Stack пуст, Event Loop берет из Queue
// 5. Event Loop добавляет callback в Stack
// 6. Выполняется console.log('2') → вывод "2"

Node.js и Call Stack

В Node.js Call Stack работает так же, но интегрирован с libuv для асинхронных операций:

const fs = require('fs');

console.log('Start');

fs.readFile('file.txt', (err, data) => {
  console.log('File read'); // В Call Stack после Event Loop
});

console.log('End');

// Вывод:
// Start
// End
// File read

Stack Trace

При ошибке видно весь Call Stack:

function a() { b(); }
function b() { c(); }
function c() { throw new Error('Ошибка'); }

a();

// Stack Trace:
// Error: Ошибка
//   at c (file.js:3)
//   at b (file.js:2)
//   at a (file.js:1)
//   at Object.<anonymous> (file.js:5)

Вывод

Call Stack — критически важный механизм V8:

• Отслеживает выполнение синхронного кода
• Ограничен по размеру (переполнение → RangeError)
• Основа для debugger и stack traces
• Работает вместе с Event Loop для обработки асинхронного кода
• Есть во всех JavaScript движках (V8, SpiderMonkey, JavaScriptCore)