A pilha de chamadas
Veja como as chamadas de funções são rastreadas.
A pilha de chamadas é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 4 aulas no total.
O que é a pilha de chamadas?
A pilha de chamadas é o mecanismo pelo qual JavaScript acompanha qual função está sendo executada e para onde deve retornar. Cada chamada de função é colocada no topo; quando termina, é removida.
Ela é uma estrutura LIFO: o último a entrar é o primeiro a sair.
Inserção e remoção na pilha
Quando você chama uma função, um quadro da pilha é inserido. Quando ela retorna, o quadro é removido. Observe a ordem dos registros à medida que as chamadas se aninham.
function first() {
console.log('first start');
second();
console.log('first end');
}
function second() {
console.log('second');
}
first();LIFO em ação
A função chamada mais recentemente precisa terminar antes que a função abaixo dela continue. A chamada interna termina primeiro, embora tenha começado por último.
function a() {
console.log('enter a');
b();
console.log('exit a');
}
function b() {
console.log('enter b');
c();
console.log('exit b');
}
function c() {
console.log('c runs');
}
a();Síncrono significa bloqueante
JavaScript executa uma coisa de cada vez em uma única linha de execução. Enquanto houver quadros na pilha, nada mais será executado. O código síncrono bloqueia até terminar.
console.log('start');
function busy() {
let sum = 0;
for (let i = 0; i < 1000; i++) sum += i;
return sum;
}
console.log(busy());
console.log('end');Os valores de retorno descem
À medida que cada quadro é removido, seu valor de retorno volta para a função chamadora que aguarda abaixo dele na pilha.
function square(n) {
return n * n;
}
function sumOfSquares(a, b) {
return square(a) + square(b);
}
console.log(sumOfSquares(3, 4));A recursão aumenta a pilha
Cada chamada recursiva adiciona outro quadro. A pilha cresce até que o caso-base seja alcançado e, então, é desfeita quadro a quadro.
function countdown(n) {
if (n === 0) {
console.log('liftoff');
return;
}
console.log(n);
countdown(n - 1);
}
countdown(3);Estouro da pilha
A pilha tem tamanho finito. Uma recursão sem caso-base continua inserindo quadros até que o mecanismo lance RangeError: tamanho máximo da pilha de chamadas excedido.
function endless(n) {
return endless(n + 1);
}
try {
endless(1);
} catch (e) {
console.log(e.name);
}A ordem de execução é previsível
Como a pilha segue estritamente a ordem LIFO e é síncrona, a ordem dos registros síncronos é sempre determinística. Você pode rastreá-la manualmente.
function outer() {
console.log(1);
inner();
console.log(3);
}
function inner() {
console.log(2);
}
outer();
console.log(4);Onde entra o assíncrono
A pilha de chamadas executa apenas código síncrono. Funções como setTimeout entregam o trabalho ao ambiente, que posteriormente coloca as funções de retorno em filas. Essas funções só são executadas quando a pilha está vazia.
Essa é a ponte para o loop de eventos.
console.log('A');
setTimeout(() => console.log('B (later)'), 0);
console.log('C');A pilha precisa ser esvaziada primeiro
Até mesmo um temporizador de zero milissegundo espera todo o código síncrono terminar. A função de retorno não pode ser executada enquanto houver quadros na pilha.
console.log('sync 1');
setTimeout(() => console.log('timeout'), 0);
console.log('sync 2');
console.log('sync 3');Por que a pilha de chamadas é importante
Entender a pilha de chamadas explica por que loops síncronos longos congelam uma página, por que a recursão pode causar um estouro e por que funções de retorno assíncronas sempre são executadas por último. Ela é a base de tudo no loop de eventos.
function compute() {
return [1, 2, 3].reduce((a, b) => a + b, 0);
}
console.log('before');
console.log(compute());
console.log('after');Verificação rápida
Qual princípio de ordenação a pilha de chamadas segue?
Recapitulação: a pilha de chamadas
Você aprendeu o núcleo de execução do mecanismo:
- A pilha de chamadas acompanha as funções em execução na ordem LIFO.
- JavaScript usa uma única linha de execução, e o código síncrono bloqueia.
- A recursão aumenta a pilha e pode causar um estouro.
- Funções de retorno assíncronas esperam até que a pilha esteja vazia, levando-nos ao loop de eventos.
Perguntas Frequentes
A aula “A pilha de chamadas” é grátis?
Sim — o texto completo de “A pilha de chamadas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 4 aulas no total.
O que vou aprender em “A pilha de chamadas”?
Veja como as chamadas de funções são rastreadas. Você pratica JavaScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar JavaScript Academy?
Nenhuma experiência prévia é necessária. JavaScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “A pilha de chamadas”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de JavaScript Academy?
Sim. Cada aula de JavaScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- A pilha de chamadas
- Macrotarefas e a fila de tarefas
- Microtarefas e Promises
- queueMicrotask e ordenação