JavaScript Engines: O Motor Por Trás do Código

Código fonte → Parser (tokens + AST) → Ignition (bytecode, rápido)              → TurboFan (código quente → máquina otimizada)              → Resultado

Trabalhadores manuais (Ignition) começam na hora; robôs (TurboFan) demoram a instalar mas são muito mais rápidos em tarefas repetidas.

Todos implementam ECMAScript — por isso JS se comporta igual no Chrome, Firefox ou Node. Foco aqui no V8, o mais implantado.

Tokenização: código vira tokens (function, add, (, a, +, …).

AST (Abstract Syntax Tree): estrutura que captura o significado:

FunctionDeclaration "add"  params: [a, b]  body: ReturnStatement    BinaryExpression: a + b

Explore ASTs em AST Explorer.

Ignition (V8 5.9+, 2017) gera bytecode compacto e executa imediatamente — sem esperar compilação.

Ldar a1    // carrega aAdd a2     // soma bReturn

Enquanto roda, coleta profiling: funções quentes, tipos observados, ramos de if tomados.

Funções quentes (muitas chamadas) vão ao TurboFan, que gera código de máquina assumindo tipos observados:

function add(a, b) { return a + b; } add(1, 2);add(3, 4);// TurboFan: "sempre números" → código nativo rápido

Benefícios: sem interpretar bytecode a cada vez; menos checagens de tipo; inlining e dead code elimination.

Suposições erradas → deopt — descarta código otimizado, volta ao Ignition:

add(1, 2);       // otimizado para númerosadd("a", "b");   // strings! deopt

Gatilhos: mudança de tipo, hidden class diferente, call site megamórfico.

Parse → Ignition ⇄ TurboFan → Executar         (profile)   (deopt se errado)

JS é dinâmico — tipos desconhecidos em compile time. JIT observa runtime, otimiza o que vê, desfaz se errar.

Warm-up: primeira execução mais lenta; após muitas chamadas, código fica mais rápido — benchmarks incluem fase de aquecimento.

V8 rastreia formas de objetos internamente. Mesmas propriedades na mesma ordem → mesma hidden class:

const p1 = { x: 1, y: 2 };const p2 = { x: 5, y: 10 };// mesma hidden class → x no offset 0, y no offset 1 const a = { x: 1, y: 2 };const b = { y: 2, x: 1 };  // hidden class DIFERENTE!

Cadeia de transição: {} → {x} → {x,y}. Prefira literais { x, y } a {} + atribuições sequenciais quando possível.

V8 cacheia onde achou uma propriedade para uma hidden class:

function getX(obj) { return obj.x; } getX({ x: 1, y: 2 });  // miss → cacheia offsetgetX({ x: 3, y: 4 });  // hit — mesma forma

Factories com forma consistente mantêm IC monomórfico:

function createPoint(x, y) { return { x, y }; }

Hipótese geracional: a maioria dos objetos morre jovem.

Geração jovem (Scavenger, rápido, frequente)    ↓ sobreviventesGeração velha (Mark-Compact, completo, raro)

GC moderno: paralelo, incremental e concorrente — pausas raras na prática.

Veja também memória em Primitive Types e Primitives vs Objects.

1. Formas consistentes — mesma ordem de propriedades (createUser(name, age)).

1. Tipos estáveis — evite count = 0 depois count = "none".

1. Arrays densos — sem buracos; tipos homogêneos quando possível.

1. Evite delete — muda hidden class; prefira undefined ou Map.

1. Monomorfismo — mesma forma de objeto nas funções quentes (classes/factories).

1. Evite eval() — impede otimizações do parser.

Você abriu a trilha Advanced Topics — o primeiro de nove conceitos avançados da série.

Revise Call Stack e Event Loop para conectar motor single-threaded e assíncrono.

→ Error Handling — seu código precisa de um plano B

Fonte de referência: 33jsconcepts.com/concepts/javascript-engines ⬀