Ausführungskontext und Aufrufstapel

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 eines EC.
Genau ein globaler EC, unabhängig von der Größe des JS-Projekts.
Standardkontext, erstellt für Code, der sich nicht in einem Fn befindet.
Dann wird der Code innerhalb der 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. Klicken Sie auf einen Ereignisrückruf, der von der Ereignisschleife bereitgestellt wird.

Was ist in EC

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

4. Argumente-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. Umfangskette:
   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 Punkte 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. Pfeilfns 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

Ort, an dem 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 auf den darunter 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 Gültigkeitsbereich nicht findet, sucht er in der Gültigkeitsbereichskette nach den Variablen in seinen äußeren Gültigkeitsbereichen. 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 von 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 chain:
Its all about the order in which fns are written in the code.
Has nothing to do with order in which fns were called.
Scope chain gets the variable environment from the EC.
Order of fn calls is not relevant to the scope chain at all.

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.

Summary:
E-C, Var Env, Cl-Sk, Scope, Scope-chain are all different but related concepts.
Scoping asks the questions where do variables live, where can we access the variables and where not.
Lexical Scoping in JS: Rules of where we can access variables are based exactly where in the code fns and blocks are written.
Every scope has access to all the variables from all its outer scopes. This is scope chain which is a one-way street. An outer scope can never access variables of inner scope.
Scope chain of a certain scope is equal to adding together all the Var Envs of all the parent scopes.
Scope chain has nothing to do with the order in which fns are called. It does not affect the scope chain at all.
When a variable is not found in current scope, engine looks up the scope chain until it finds the variable its looking for. This is called variable look-up.

Das obige ist der detaillierte Inhalt vonAusführungskontext und Aufrufstapel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!