Criação de contexto de execução global para o código de nível superior, ou seja, código que não está dentro de nenhum fn. Portanto, o código fora do fn é executado primeiro.
O código dentro do corpo fn de fn-decln/exprsn só é executado quando é chamado.

Contexto de Execução (CE)

Ambiente no qual parte do JS é executada.
Armazena todas as informações necessárias para que algum código seja executado como variáveis ​​locais, argumentos passados ​​para um fn.
O código JS sempre é executado dentro de um EC.
Exatamente um CE global, independentemente do tamanho do projeto JS.
Contexto padrão, criado para código que não está dentro de nenhum fn.
Em seguida, o código é executado dentro do EC global
Após a execução do código de nível superior, execução de fns e espera por C/bs
Para cada chamada fn, um novo EC é criado para executar esse fn. O mesmo vale para métodos, pois eles também são anexados a objetos.
Todos esses ECs juntos constituem a pilha de chamadas.
Quando todos os fns são executados, o motor espera que os CBs cheguem e os executem. Ex. clique em retorno de chamada de evento, fornecido pelo loop de eventos.

O que há dentro do CE

1. Ambiente variável composto por
2. declarações let, const, var
3. Funções

4. objeto de argumentos: armazena todos os argumentos passados ​​​​para o fn em seu EC.
   Cada fn recebe seu próprio EC conforme é chamado. E as variáveis ​​declaradas acabam em ambiente variável

5. Cadeia de escopo:
   O Fns pode acessar variáveis ​​fora do fns usando a cadeia de escopo.
   Contém referências às variáveis ​​localizadas fora do fn atual e para acompanhar a cadeia de escopo, é armazenado em cada EC.

6. Cada EC também recebe a palavra-chave 'this'.

Todos os três acima são gerados durante a "Fase de Criação", logo antes da execução. Estas são as coisas necessárias para executar o código em nível superior.

Para seta fns EC:

Não teremos: objeto de argumentos, esta palavra-chave. Arrow fns usa seu fn regular mais próximo, os dois acima.

argumentos: array como objeto, contendo todos os argumentos passados ​​​​para o fn regular, não para a seta fn.

Pilha de memória de pilha de chamadas = mecanismo JS

Pilha de chamadas

Local onde os ECs são empilhados uns sobre os outros, para acompanhar onde estamos na execução. O CE mais alto é aquele que estamos administrando. Quando a execução termina, ela é removida do topo da pilha e o controle é transferido para o EC subjacente.
Se houver uma chamada fn aninhada, a chamada fn externa será pausada para retornar o resultado da execução do fn interno na pilha de chamadas, pois JS possui apenas um thread de execução. Agora o CE anterior se tornará o CE ativo
Em seguida, o EC mais alto é retirado da pilha de chamadas conforme retornado.
O ponto mais baixo na pilha de chamadas será o EC global; no topo, serão as chamadas fn à medida que ocorrerem em ordem.
Garante que a ordem de execução nunca seja perdida.
No final, o programa será finalizado e o EC global também será exibido na pilha de chamadas.

O código JS é executado dentro de um EC, que é colocado na Call Stack.

Hence, we can say that each EC has:
1. Variable environment
2. Scope chain
3. 'this' keyword

Escopo

Como nossas variáveis ​​de programa são organizadas e acessadas pelo JS Engine.
Onde residem as variáveis
Onde podemos acessar determinadas variáveis ​​e onde não.

Escopo Lexical:

JS tem escopo leical, o que significa que o escopo é controlado pela colocação de fns e blocos no código.
Ex. Um fn aninhado tem acesso às variáveis ​​de seu pai fn.

Escopo:

Espaço ou ambiente em que uma determinada variável é declarada (ambiente variável no caso de fns). É a variável env que é armazenada em fns EC.
Para fns, Var env e escopo são iguais.

Three scopes in JS are:
1. Global scope
2. Fn scope
3. Block scope [ES6]

Escopo é um local onde as variáveis ​​são declaradas. Portanto, verdadeiro para Fns também porque fns são apenas valores armazenados em variáveis.

Escopo de uma variável

Região do nosso código onde uma determinada variável pode ser acessada.

O escopo é diferente do escopo de uma variável com diferenças sutis.

## Global Scope:
For top level code
For variables declared outside of any fn or block which are accessible from everywhere
Variables in this scope are at the top of scope chain. Hence, can be used by every nested scope.

## Fn Scope:
Each fn has creates its own scope
Variables are accessible ONLY inside fn, NOT outside. Else Reference Error
Also called local scope
Fn decln, exprsn, arrow all three create their own scopes.
Only way to create scope using ES5 which had only fn & global scope.

## Block Scope:
Introduced in ES6, not only fn but {} also create a scope known as block scope which work only for ES6 variables i.e let-const types. DOesn't work for variables declared with 'var' as its fn scoped.
Variables accessible only inside block i.e {} 
This only applies to variables declared with let-const only.
Fns are also block scoped in ES6 (only in strict mode, should be used)
variables declared using 'var' will be accessible outside the block
Scoped to the current fn or the global scope.
var variables only care about fn, they ignore blocks. They end up in nearest fn scope.

Cada escopo aninhado tem acesso a variáveis ​​de seu escopo externo e do escopo global. O mesmo se aplica aos argumentos fn também.

Se um fn não encontrar a variável em seu escopo, ele procurará a cadeia de escopo para descobrir as variáveis ​​em seus escopos externos. Este processo é chamado de pesquisa de variável na cadeia de escopo. Isso não funciona ao contrário, ou seja, não podemos acessar variáveis ​​​​ou escopos fn aninhados de fora do fn ou de escopos externos. Os escopos irmãos não podem acessar as variáveis ​​um do outro
Somente o escopo mais interno pode acessar seus escopos externos, e não o contrário.

Um EC para cada fn na ordem exata em que um fn é chamado é colocado na pilha de chamadas com suas variáveis ​​​​dentro do EC. O EC global está na parte inferior da pilha de chamadas

Cadeia de escopo:

É tudo uma questão de ordem em que fns são escritos no código.
Não tem nada a ver com a ordem em que fns foi chamado.
A cadeia de escopo obtém o ambiente variável do EC.
A ordem das chamadas fn não é relevante para a cadeia de escopo.

const a = 'Alice'; primeiro(); função primeiro(){ const b = "Olá"; segundo(); função segundo(){ const c = "Olá"; terceiro(); } } função terceiro(){ const d = "Ei"; console.log(d c b a); //Erro de referência } ## Ordem da pilha de chamadas: terceiro() EC - topo segundo() CE primeiro() CE CE global - inferior Cadeia de escopo: second() --nested inside--> first() --nested inside--> escopo global. Third() é definido independentemente dentro do escopo global. Ocorreu um erro de referência porque tanto 'c' quanto 'b' não podem ser acessados ​​usando a cadeia de escopo.

const a = 'Alice';
first();

function first(){
  const b = "Hello";
  second();

  function second(){
    const c = "Hi";
    third();
  }
}

function third(){
  const d = "Hey";
  console.log(d   c   b   a); // Reference Error
}

## Call Stack order:
third() EC - top
second() EC
first() EC
global EC - bottom


Scope Chain:
second() --nested inside--> first() --nested inside--> global scope.
third() is independently defined inside gloabal scope.

Reference Error occurred because both 'c' as well as 'b' cannot be accessed using the scope chain.

Resumo:

EC, Var Env, Cl-Sk, Scope, Scope-chain são conceitos diferentes, mas relacionados.
O escopo pergunta onde residem as variáveis, onde podemos acessá-las e onde não.
Escopo léxico em JS: as regras de onde podemos acessar as variáveis ​​​​são baseadas exatamente onde no código os fns e os blocos são escritos.
Cada escopo tem acesso a todas as variáveis ​​de todos os seus escopos externos. Esta é uma cadeia de escopo que é uma rua de mão única. Um escopo externo nunca pode acessar variáveis ​​de escopo interno.
A cadeia de escopo de um determinado escopo é igual a somar todos os Var Envs de todos os escopos pais.
A cadeia de escopo não tem nada a ver com a ordem em que fns são chamados. Isso não afeta em nada a cadeia de escopo.
Quando uma variável não é encontrada no escopo atual, o mecanismo procura a cadeia de escopo até encontrar a variável que procura. Isso é chamado de pesquisa de variável.