Erstellung eines globalen Ausführungskontexts für den Code der obersten Ebene, d. h. Code, der sich nicht in einem FN befindet. Daher wird Code außerhalb des fn zuerst ausgeführt.
Code im Fn-Körper von fn-decln/exprsn wird nur ausgeführt, wenn er aufgerufen wird.

Ausführungskontext (EC)

Umgebung, in der ein JS-Teil ausgeführt wird.
Speichert alle notwendigen Informationen für die Ausführung von Code, z. B. lokale Variablen, Argumente, die an einen Fn übergeben werden.
JS-Code läuft immer innerhalb einer EC.
Genau ein globaler EC, unabhängig von der Größe des JS-Projekts.
Standardkontext, erstellt für Code, der sich nicht in einer Fn befindet.
Dann wird der Code innerhalb des globalen EC
ausgeführt. Nachdem der Code der obersten Ebene ausgeführt wurde, wird fns ausgeführt und auf C/bs
gewartet. Für jeden Fn-Aufruf wird ein neuer EC erstellt, um diesen Fn auszuführen. Das Gleiche gilt für Methoden, da es sich auch um FNS handelt, die an Objekte angehängt sind.
Alle diese ECs zusammen bilden den Call Stack.
Wenn alle FNS ausgeführt sind, wartet die Engine auf das Eintreffen der CBs und führt sie aus. Ex. Click-Event-Callback, bereitgestellt von der Event-Schleife.

Was ist in EC

1. Variable Umgebung bestehend aus
2. let-, const-, var-Deklarationen
3. Funktionen

4. Arguments-Objekt: speichert alle an den Fn übergebenen Argumente in seinem EC.
   Jeder Fn erhält seinen eigenen EC, wie er genannt wird. Und deklarierte Variablen landen in der Variablenumgebung

5. Scope-Kette:
   Fns können mithilfe der Bereichskette auf Variablen außerhalb von fns zugreifen.
   Enthält Verweise auf die Variablen, die sich außerhalb des aktuellen FN befinden. Um den Überblick über die Bereichskette zu behalten, werden sie in jedem EC gespeichert.

6. Jeder EC erhält außerdem das Schlüsselwort „this“.

Alle drei oben genannten werden während der „Erstellungsphase“ direkt vor der Ausführung generiert. Dies sind die Dinge, die zum Ausführen des Codes auf der obersten Ebene erforderlich sind.

Für Pfeil fns EC:

Wir werden nicht haben: arguments object, dieses Schlüsselwort. Pfeil-Fns verwenden von ihrem nächstgelegenen regulären Fn die beiden oben genannten.

Argumente: Array-ähnliches Objekt, das alle Argumente enthält, die an die reguläre Fn übergeben werden, nicht an die Pfeil-Fn.

Call Stack Memory Heap = JS Engine

Call Stack

Platzieren Sie die Stelle, an der ECs übereinander gestapelt werden, um den Überblick darüber zu behalten, wo wir uns in der Ausführung befinden. Der oberste EC ist der, den wir durchführen. Sobald die Ausführung beendet ist, wird sie von der Oberseite des Stapels entfernt und die Kontrolle wird an den zugrunde liegenden EC übertragen.
Wenn es einen verschachtelten Fn-Aufruf gibt, wird der äußere Fn-Aufruf angehalten, um das Ergebnis der Ausführung des inneren Fn im Aufrufstapel zurückzugeben, da JS nur einen Ausführungsthread hat. Jetzt wird der vorherige EC zum aktiven EC
Dann wird der oberste EC bei der Rückgabe aus dem Call Stack entfernt.
Am niedrigsten im Aufrufstapel ist der globale EC, an der Spitze stehen fn-Aufrufe, wie sie in der richtigen Reihenfolge auftreten.
Stellt sicher, dass die Ausführungsreihenfolge nie verloren geht.
Am Ende wird das Programm beendet und der globale EC wird ebenfalls aus dem Call Stack entfernt.

JS-Code wird in einem EC ausgeführt und auf dem Call Stack platziert.

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

Scoping

Wie unsere Programmvariablen von JS Engine organisiert werden und auf sie zugreift.
Wo leben Variablen
Wo können wir auf bestimmte Variablen zugreifen und wo nicht.

Lexikalisches Scoping:

JS verfügt über einen Leical-Scoping, was bedeutet, dass der Scoping durch die Platzierung von FNS und Blöcken im Code gesteuert wird.
Ex. Ein verschachtelter Fn hat Zugriff auf Variablen seines übergeordneten Fn.

Umfang:

Raum oder Umgebung, in der eine bestimmte Variable deklariert ist (Variablenumgebung im Fall von fns). Es ist die Variable env, die in fns EC gespeichert ist.
Für fns sind Var env und Scope beide gleich.

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

Scope ist ein Ort, an dem Variablen deklariert werden. Dies gilt daher auch für Fns, da Fns nur in Variablen gespeicherte Werte sind.

Umfang einer Variablen

Region unseres Codes, in der auf eine bestimmte Variable zugegriffen werden kann.

Der Geltungsbereich unterscheidet sich vom Geltungsbereich einer Variablen mit geringfügigen Unterschieden.

## 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.

Jeder verschachtelte Bereich hat Zugriff auf Variablen aus seinem äußeren Bereich und dem globalen Bereich. Das Gleiche gilt auch für fn-Argumente.

Wenn ein FN die Variable in seinem Bereich nicht findet, sucht er in der Bereichskette nach den Variablen in seinen äußeren Bereichen. Dieser Vorgang wird als Variablensuche in der Bereichskette bezeichnet. Andersherum funktioniert das nicht, d. h. wir können nicht auf verschachtelte FN-Variablen oder Bereiche außerhalb des FN oder der äußeren Bereiche zugreifen.
Geschwisterbereiche können nicht auf die Variablen des anderen zugreifen
Nur der innerste Bereich kann auf seine äußeren Bereiche zugreifen, nicht umgekehrt.

Ein EC für jeden Fn in der genauen Reihenfolge, in der ein Fn aufgerufen wird, wird mit seinen Variablen innerhalb des EC auf dem Call Stack platziert. Global EC befindet sich am Ende des Call Stacks

Scope-Kette:
Es kommt auf die Reihenfolge an, in der FNS in den Code geschrieben werden.
Hat nichts mit der Reihenfolge zu tun, in der fns aufgerufen wurden.
Die Scope-Kette ruft die Variablenumgebung vom EC ab.
Die Reihenfolge der Fn-Aufrufe ist für die Bereichskette überhaupt nicht relevant.

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.

Zusammenfassung:
E-C, Var Env, Cl-Sk, Scope, Scope-Chain sind allesamt unterschiedliche, aber verwandte Konzepte.
Beim Scoping geht es um die Frage: Wo leben Variablen, wo können wir auf die Variablen zugreifen und wo nicht.
Lexikalisches Scoping in JS: Regeln, wo wir auf Variablen zugreifen können, basieren genau darauf, wo im Code FNS und Blöcke geschrieben sind.
Jeder Bereich hat Zugriff auf alle Variablen aller seiner äußeren Bereiche. Dies ist eine Scope-Kette, die eine Einbahnstraße ist. Ein äußerer Bereich kann niemals auf Variablen des inneren Bereichs zugreifen.
Die Bereichskette eines bestimmten Bereichs entspricht der Addition aller Var Envs aller übergeordneten Bereiche.
Die Gültigkeitskette hat nichts mit der Reihenfolge zu tun, in der FNS aufgerufen werden. Es wirkt sich überhaupt nicht auf die Bereichskette aus.
Wenn eine Variable im aktuellen Bereich nicht gefunden wird, durchsucht die Engine die Bereichskette, bis sie die gesuchte Variable findet. Dies wird als Variablensuche bezeichnet.