O JavaScript é uma linguagem de programação que pode ser bastante confusa para quem está começando, principalmente quando se trata de callbacks e promises. Vejamos um exemplo de código abaixo:

function printHelloWorld() {
  console.log("Hello World");
}

function sayHi() {
  console.log("Hi!");
}

function blockFor7000ms() {
  for (let i = 0; i < 1000000000; i++) {}
  console.log("end for");
}

setTimeout(printHelloWorld, 0);

blockFor7000ms();

new Promise((resolve) => {
  sayHi();
  resolve();
});

Se executarmos esse código, teremos essa resposta no console:

> end for
> Hi!
> Hello World

Por que o end for foi executado primeiro, mesmo que ele tenha demorado 7000ms? O setTimeout não deveria ter sido executado primeiro? E por que a Promise também foi executada antes do setTimeout?

Para responder a essas perguntas, primeiro temos que entender alguns princípios básicos do JavaScript.

Event Loop e Call Stack

O Call Stack e o Event Loop são dois dos principais mecanismos que trabalham juntos para gerenciar a execução de código em JavaScript. O Call Stack é uma estrutura de dados que rastreia a execução das funções no código. Quando uma função é chamada, ela é adicionada ao topo do Call Stack. Quando a função é concluída, ela é removida do Call Stack e o controle é devolvido para a função que a chamou.

O Event Loop, por outro lado, é responsável por gerenciar a fila de eventos. Eventos, como interações do usuário ou respostas de rede, são adicionados à fila de eventos. O Event Loop monitora constantemente a fila de eventos e, quando o Call Stack está vazio, o próximo evento da fila é retirado e processado.

Quando o JavaScript executa um trecho de código, ele é adicionado ao Call Stack. Se o código contém operações síncronas que exigem tempo de processamento, o Call Stack pode ser bloqueado até que as operações sejam concluídas. No entanto, se o código contém operações assíncronas, como uma chamada de API ou manipulação de eventos do usuário, essas operações são adicionadas à fila de eventos em vez de serem executadas imediatamente.

Quando uma operação assíncrona é concluída, ela é adicionada à fila de tarefas, juntamente com outras operações assíncronas que foram concluídas. O Event Loop monitora a fila de tarefas, dando prioridade às micro-tarefas em relação às macro-tarefas. As micro-tarefas são executadas antes das macro-tarefas, mesmo que tenham sido adicionadas posteriormente.

Depurando nosso codigo

Sabendo disso, vamos depurar nosso código para compreender melhor esses conceitos.

1. Até a linha 13, o JavaScript apenas salvou em memória nossas funções. Na linha 14, ele adicionará no topo do nosso call stack a função do setTimeout. O setTimeout faz parte das features do browser, logo, ele será executado pelo browser após o tempo que foi passado como parâmetro. Como foi passado 0 segundos, ele é executado imediatamente. O browser envia a nossa função printHelloWorld para o Callback Queue (macro tarefas), que ficará aguardando até que não haja mais nada no call stack.

2. Em seguida, a função blockFor7000ms() é adicionada ao call stack. Esta função consiste em um loop for que itera um grande número de vezes. Isso levará um tempo significativo para ser concluído e, enquanto isso, o restante do código não será executado, bloqueando o nosso call stack. E a nossa função printHelloWorld continuará no Callback Queue aguardando para ser executada. Se olharmos para o console nesse ponto, ele acabará de imprimir o nosso end for quando a função blockFor7000ms() finalizar.

> end for

3. Finalizando o blockFor7000ms, ele adicionará a nossa Promise para o call stack. Ao executar a nossa Promise, ele enviará a função sayHi() para a fila de micro-tarefas.

4. Depois disso, o nosso programa entra em um estado de espera, aguardando que o call stack fique vazio. Isso acontece porque a execução da Promise é assíncrona e não bloqueia o call stack.

5. Agora, o event loop verificará que não tem mais nada no call stack. Ele verificará primeiro na fila de micro-tarefas. Nessa fila, ele encontrará a função sayHi() e a passará para o call stack. No Call stack, a função sayHi() será executada e irá imprimir o nosso console.log. Se olharmos no console, ficará assim:

> end for
> Hi!

6. Nesse ponto, o nosso call stack ficará vazio novamente, e o nosso event loop verificará primeiro a nossa fila de micro-tarefas. Como não teremos nada, ele verificará as nossas macro-tarefas. Nas macro-tarefas, ele encontrará o nosso printHelloWorld e o passará para o call stack, executando-o e imprimindo o console.log. Por fim, nosso console ficará assim:

> end for
> Hi!
> Hello World 

Conclusão

Em um primeiro momento javascript pode ser bastante obscuro e confuso, mas isso se deve a forma como ele funciona, se entendermos a teoria veremos q ele é bastante simples e poderoso.

Ref:

https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Using_promises#composi%C3%A7%C3%A3o