Konteks Pelaksanaan & Timbunan Panggilan

Penciptaan konteks pelaksanaan global untuk kod peringkat teratas iaitu kod yang tiada di dalam mana-mana fn. Oleh itu, kod di luar fn dilaksanakan dahulu.
Kod di dalam badan fn fn-decln/exprsn hanya dilaksanakan apabila ia dipanggil.

Konteks Pelaksanaan(EC)

Persekitaran di mana bahagian JS dilaksanakan.
Menyimpan semua maklumat yang diperlukan untuk beberapa kod untuk dilaksanakan seperti pembolehubah tempatan, arg dihantar ke fn.
Kod JS sentiasa berjalan di dalam EC.
Tepat satu EC global tanpa mengira saiz projek JS.
Konteks lalai, dibuat untuk kod bukan dalam mana-mana fn.
Kemudian kod itu dilaksanakan di dalam EC global
Selepas kod peringkat atas dilaksanakan, pelaksanaan fns & menunggu C/bs
Untuk setiap panggilan fn, EC baharu dicipta untuk melaksanakan fn tersebut. Begitu juga dengan kaedah, kerana ia juga dilekatkan pada objek.
Semua EC ini bersama-sama membentuk Tindanan Panggilan.
Apabila semua fns dilaksanakan, enjin menunggu CB tiba & melaksanakannya. Cth. klik panggil balik acara, disediakan oleh gelung acara.

Apa yang ada di dalam EC

1. Persekitaran Boleh Ubah yang terdiri daripada
2. perisytiharan biarkan, const, var
3. Fungsi

4. objek hujah : menyimpan semua hujah yang dihantar ke fn dalam ECnya.
   Setiap fn mendapat EC sendiri seperti yang dipanggil. Dan pembolehubah yang diisytiharkan berakhir dalam persekitaran berubah

5. Rantai Skop:
   Fns boleh mengakses pembolehubah di luar fns menggunakan rantai skop.
   Mengandungi rujukan kepada pembolehubah yang terletak di luar fn semasa dan untuk menjejaki rantai skop, ia disimpan dalam setiap EC.

6. Setiap SPR juga mendapat kata kunci 'ini'.

Ketiga-tiga di atas dijana semasa "Fasa Penciptaan", sejurus sebelum pelaksanaan. Ini perkara yang diperlukan untuk menjalankan kod di peringkat teratas.

Untuk anak panah fns EC:

Kami tidak akan mempunyai: arguments object, kata kunci ini. Anak panah fn gunakan dari fn biasa terdekat mereka, dua di atas.

argumen: tatasusunan seperti objek, mengandungi semua hujah yang dihantar ke fn biasa, bukan anak panah fn.

Panggil Tumpukan Memori Tindanan = Enjin JS

Panggilan Stack

Tempat di mana EC disusun di atas satu sama lain, untuk menjejaki di mana kita berada dalam pelaksanaan. SPR paling atas ialah yang kami jalankan. Apabila pelaksanaan selesai, ia dikeluarkan dari bahagian atas tindanan dan kawalan dipindahkan ke EC asas.
Jika terdapat panggilan fn bersarang, panggilan fn luar akan dijeda untuk mengembalikan hasil pelaksanaan fn dalam pada timbunan panggilan kerana JS hanya mempunyai satu utas pelaksanaan. Kini SPR terdahulu akan menjadi SPR aktif
Kemudian EC yang paling teratas muncul daripada Tindanan Panggilan apabila ia dikembalikan.
Terendah dalam Tindanan Panggilan ialah EC global, di atasnya ialah panggilan fn apabila ia berlaku mengikut urutan.
Memastikan susunan pelaksanaan tidak pernah hilang.
Pada akhirnya, program akan selesai dan EC global juga akan muncul daripada Tindanan Panggilan.

Kod JS berjalan di dalam EC, yang diletakkan pada Tindanan Panggilan.

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

Skop

Cara pembolehubah program kami disusun dan diakses oleh JS Engine.
Di manakah pembolehubah hidup
Di manakah kita boleh mengakses pembolehubah tertentu dan di mana tidak.

Skop Leksikal:

JS mempunyai skop leikal yang bermaksud skop dikawal oleh peletakan fns dan blok dalam kod.
Cth. Fn bersarang mempunyai akses kepada pembolehubah fn induknya.

Skop:

Ruang atau env di mana pembolehubah tertentu diisytiharkan(persekitaran pembolehubah dalam kes fns). Ia adalah env pembolehubah yang disimpan dalam fns EC.
Untuk fns, Var env & skop kedua-duanya adalah sama.

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

Skop ialah tempat di mana pembolehubah diisytiharkan. Oleh itu, benar untuk Fns juga kerana fns hanyalah nilai yang disimpan dalam pembolehubah.

Skop Pembolehubah

Wilayah kod kami di mana pembolehubah tertentu boleh diakses.

Skop berbeza daripada skop pembolehubah dengan perbezaan halus.

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

Setiap skop bersarang mempunyai akses kepada pembolehubah dari skop luarnya & skop global. Perkara yang sama juga berlaku untuk hujah fn.

Jika fn tidak menemui pembolehubah dalam skopnya, ia mencari rantai skop untuk mengetahui pembolehubah dalam skop luarnya. Proses ini dipanggil carian berubah-ubah dalam rantai skop. Ini tidak berfungsi sebaliknya iaitu kita tidak boleh mengakses pembolehubah atau skop fn bersarang dari luar skop fn atau luar.
Skop adik-beradik tidak boleh mengakses pembolehubah satu sama lain
Hanya skop paling dalam boleh mengakses skop luarnya, bukan skop sebaliknya.

Satu EC untuk setiap fn dalam susunan tepat fn dipanggil diletakkan pada Call Stack dengan pembolehubahnya di dalam EC. Global EC berada di bahagian bawah Tindanan Panggilan

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.

Atas ialah kandungan terperinci Konteks Pelaksanaan & Timbunan Panggilan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!