Rantaian skop JavaScript (Rantaian Skop) contoh penggunaan analisis_kemahiran javascript

Artikel ini menganalisis penggunaan rantai skop JavaScript (Rantai Skop) dengan contoh. Kongsikan dengan semua orang untuk rujukan anda, butirannya adalah seperti berikut:

Saya telah lama mendengar tentang rantaian skop js, dan telah membaca beberapa catatan blog pengenalan, tetapi pemahaman saya sentiasa samar-samar. Baru-baru ini, saya membaca dengan teliti buku "Memahami Javascript" dan merasakan bahawa ia ditulis dengan sangat mendalam Dalam bahagian "Ruang dan Masa Kod", terdapat bahagian yang memperkenalkan rantai skop dengan hanya beberapa perkataan, yang meninggalkan saya dengan. aftertaste yang tidak berkesudahan (sebenarnya saya masih memahaminya ^_^). Sekarang susun nota bacaan anda, lukis sumber dalam talian dan tuliskannya.

1. Mari kita mulakan dengan soalan mudah

Apakah hasil yang akan dipaparkan apabila kod js berikut dijalankan pada halaman:

var arg = 1;
function fucTest(arg) {
  alert(arg);
  var arg = 2;
  //alert(arg);
}
fucTest(10);

Apakah jawapan anda? Betul, 10 muncul. Pemahaman saya ialah ini, fungsi funTest mempunyai arg parameter formal, fungsi funTest melepasi parameter sebenar 10, dan kaedah amaran hanya muncul 10, memalukan.
Okey, inilah soalannya sekali lagi:

var arg = 1;
function funcTest() {
  alert(arg);
  var arg = 2;
}
arg = 10;
funcTest();

Apakah jawapannya? Jika saya 5 tahun yang lalu, saya pasti tidak akan memikirkannya lagi, ia masih 10! Mengapa anda perlu memikirkan soalan yang begitu mudah? Pemahaman saya ialah: fungsi funTest ialah fungsi tanpa parameter Di dalam fungsi, pembolehubah luaran (global) dipanggil melalui kaedah amaran Sebelum fungsi dilaksanakan, arg diberikan nilai 10. Selepas nilai arg adalah muncul, nilai arg ditukar kepada 2. , jadi nilai pop timbul ialah 10.

Adakah ia benar-benar 10? Ya atau tidak?

Keputusan ujian: "undefined" muncul, peluh air terjun.

2. Fahami rantai skop, bermula daripada mekanisme pengendalian JavaScript

1. Urutan larian js

Jika aliran dokumen mengandungi berbilang segmen kod skrip (kod js dipisahkan oleh teg skrip atau fail js yang diperkenalkan), susunan jalannya ialah:

Langkah 1. Baca segmen kod pertama (enjin pelaksanaan js tidak melaksanakan program baris demi baris, tetapi menganalisis dan melaksanakannya sekeping demi sekeping)
Langkah 2. Lakukan analisis sintaks Jika terdapat sebarang ralat, ralat sintaks akan dilaporkan (seperti kurungan tidak sepadan, dll.) dan lompat ke langkah 5
Langkah 3. Lakukan "pra-penghuraian" pembolehubah var dan definisi fungsi (tiada ralat akan pernah dilaporkan, kerana hanya pengisytiharan yang betul dihuraikan)
Langkah 4. Laksanakan segmen kod dan laporkan ralat jika terdapat ralat (contohnya, pembolehubah tidak ditentukan)
Langkah 5. Jika terdapat segmen kod lain, baca segmen kod seterusnya dan ulangi langkah 2
Langkah 6. Tamat

Analisis di atas cukup jelas. Fon merah dalam langkah 2, 3 dan 4 mungkin menjadi titik buta untuk kita yang baru faham, terutamanya "pre-parsing" dalam langkah 3. Jika anda tidak tahu apa pra. -menghuraikan adalah, saya sentiasa berasa tidak senang. Langkah keempat "laporkan ralat jika ada ralat" juga sering dihadapi. Contohnya:

function funcTest() {
  alert(arg);
  var arg = 2;
}
funcTest();

上面这段代码执行时，弹出“undefined”，也就是说arg没有定义，js的变量不是不用定义也可以吗？

2、语法分析和“预解析”

（1）、从解释型语言的编译过程说起

众所周知，javascript是解释型语言，它不同于c#和java等编译型语言。对于传统编译型语言来说，编译步骤分为：词法分析、语法分析、语义检查、代码优化和字节生成；但对于解释型语言来说，通过词法分析和语法分析得到语法树后，就可以开始解释执行了。

a、词法分析

简单地说，词法分析是将字符流(char stream)转换为记号流(token stream)。
但是这个转换过程并不是可以用一句话就可以概括的那么简单，我们可以试着用伪代码理解一段简单的程序：

代码var result=x-y;的转换大致可以表示如下：

NAME "result"
EQUALS
NAME "x"
MINUS
NAME "y"
SEMICOLON

b、语法分析

简单地说，语法分析就是为了构造合法的语法分析树，而语法分析树可以直观地表示出推导的过程。

那么什么是语法分析树？简单地说，就是程序推导过程的描述。但是到底什么是语法树，请参考专业文章，本篇略过。

c、其他

通过语法分析，构造出语法分析树后，接下来还可能需要进一步的语义检查。对于传统强类型语言来说，语义检查的主要部分是类型检查，比如函数的实参和形参类型是否匹配等等。
结论：通过上面的分析可以看出，对于javascript引擎来说，肯定有词法分析和语法分析，之后可能还有语义检查、代码优化等步骤，等这些编译步骤完成之后（任何语言都有编译过程，只是解释型语言没有编译成二进制代码），才会开始执行代码。

（2）、执行过程

a、javascript的作用域机制

通过编译，javascript代码已经翻译成了语法树，然后会立刻按照语法树执行。

进一步的执行过程，需要理解javascript的作用域机制：词法作用域（lexcical scope）。通俗地讲，就是javascript变量的作用域是在定义时决定而不是执行时决定，也就是说词法作用域取决于源码，编译器通过静态分析就能确定，因此词法作用域也叫做静态作用域（static scope）。但需要注意，with和eval的语义无法仅通过静态技术实现，所以只能说javascript的作用域机制非常接近词法作用域（lexical scope）.

javascript引擎在执行每个函数实例时，都会创建一个执行环境（execution context）。执行环境中包含一个调用对象（call object）, 调用对象是一个scriptObject结构（scriptObject是与函数相关的一套静态系统，与函数实例的生命周期保持一致），用来保存内部变量表varDecls、内嵌函数表funDecls、父级引用列表upvalue等语法分析结构（注意varDecls和funDecls等信息是在语法分析阶段就已经得到，并保存在语法树中。函数实例执行时，会将这些信息从语法树复制到scriptObject上）。

b、javascript作用域机制的实现方法

词法作用域（lexical scope）是javascript的作用域机制，还需要理解它的实现方法，就是作用域链（scope chain）。作用域链是一个name lookup机制，首先在当前执行环境的scriptObject中寻找，没找到，则顺着upvalue到父scriptObject中寻找，一直lookup到全局调用对象（global object）。

现在回过头来分析第二个问题：

var arg = 1;
function funcTest() {
  alert(arg);
  var arg = 2;
}
arg = 10;
funcTest();

在执行funcTest函数时，也即进入了funcTest对应的作用域，js引擎在执行时，当遇到对变量名或者函数名的使用时，会首先在当前作用域（也即funcTest对应的作用域）查找变量或者函数（显然，arg变量在funcTest对应的作用域里被定义为var arg=2 所以alert方法的参数采用的是当前作用域的arg，但是因为arg被定义在alert方法后，所以arg变量默认值为undefined）。当然，如果没有找到就到上层作用域查找，依此类推（作用域范围可以持续到javascript运行环境的根：window对象）。

最后，让你看的更清楚，上面的代码其实可以等价于：

var arg = 1;
function funcTest() {
  var arg; //默认值undefined
  alert(arg);
  arg = 2;
}
arg = 10;
funcTest();

c, penutupan

Apabila tika fungsi dilaksanakan, penutupan dibuat atau dikaitkan dengannya. (Mengenai penutupan, saya bercadang untuk menulis nota belajar yang lain)

scriptObject digunakan untuk menyimpan jadual pembolehubah yang berkaitan dengan fungsi secara statik, dan penutupan secara dinamik menyimpan jadual pembolehubah ini dan nilai lariannya semasa pelaksanaan;

Kitaran hayat penutupan mungkin lebih lama daripada contoh fungsi. Contoh fungsi akan dimusnahkan secara automatik selepas rujukan aktif kosong;

Penutupan akan dikitar semula oleh enjin JavaScript selepas rujukan data kosong (dalam beberapa kes, ia tidak akan dikitar semula secara automatik, mengakibatkan kebocoran memori).

ps: Bahagian tentang "proses pelaksanaan" ini agak sukar untuk disebut. Terdapat banyak kata nama, tetapi jangan takut dengannya apabila anda memahami konteks pelaksanaan, objek panggilan, skop leksikal, Konsep seperti skop rantaian dan penutupan boleh menyelesaikan banyak fenomena dalam JavaScript dengan mudah.

3. Kesimpulan

Melalui analisis perenggan kedua, bandingkan dengan penghakiman yang dibuat oleh pengarang dalam perenggan pertama (Adakah anda juga berpendapat bahawa analisis dan kesimpulan penulis sebelum ini adalah naif (walaupun kadangkala hasilnya betul!) ?! Ia tidak cetek, ^_^), anda akan mendapati bahawa terdapat begitu banyak "misteri" dalam JavaScript, tetapi tidak mudah untuk benar-benar memahami dan menguasainya? Mari "fahamkan" dahulu dan kemudian bercakap mengenainya.

Saya harap artikel ini akan membantu semua orang dalam pengaturcaraan JavaScript.