JavaScript 作用域和作用域链

来源：互联网发布：pb程序员编辑：程序博客网时间：2024/05/22 05:51

作用域是JavaScript最重要的概念之一，想要学好JavaScript就需要理解JavaScript作用域和作用域链的工作原理。今天这篇文章对JavaScript作用域和作用域链作简单的介绍，希望能帮助大家更好的学习JavaScript。

JavaScript作用域

任何程序设计语言都有作用域的概念，简单的说，作用域就是变量与函数的可访问范围，即作用域控制着变量与函数的可见性和生命周期。在JavaScript中，变量的作用域有全局作用域和局部作用域两种。

1、全局作用域（Global Scope）

在代码中任何地方都能访问到的对象拥有全局作用域，一般来说以下几种情形拥有全局作用域：

（1）最外层函数和在最外层函数外面定义的变量拥有全局作用域，例如：
var authorName = "山边小溪";function doSomething(){    var blogName = "梦想天空";    function innerSay(){        alert(blogName);    }    innerSay();}alert(authorName); //山边小溪alert(blogName);   //脚本错误doSomething();     //梦想天空innerSay()         //脚本错误
（2）所有末定义直接赋值的变量自动声明为拥有全局作用域，例如：
function doSomething(){    var authorName = "山边小溪";    blogName = "梦想天空";    alert(authorName);}doSomething();      //山边小溪alert(blogName);    //梦想天空alert(authorName);  //脚本错误
变量blogName拥有全局作用域，而authorName在函数外部无法访问到。
（3）所有window对象的属性拥有全局作用域
一般情况下，window对象的内置属性都拥有全局作用域，例如window.name、window.location、window.top等等。

2、局部作用域（Local Scope）
和全局作用域相反，局部作用域一般只在固定的代码片段内可访问到，最常见的例如函数内部，所有在一些地方也会看到有人把这种作用域称为函数作用域，例如下列代码中的blogName和函数innerSay都只拥有局部作用域。
function doSomething(){    var blogName = "梦想天空";    function innerSay(){        alert(blogName);    }    innerSay();}alert(blogName); //脚本错误innerSay();      //脚本错误
3、总结作用域
JavaScript的作用域是相对于函数来说的，简单说来就是函数外的为全局作用域，函数内的为局部作用域，因为JavaScript不像其他语言有块级作用域。
我们先来看个例子：
例1
var scope = "global";  function t(){      console.log(scope);  //undefined    var scope = "local"      console.log(scope);  //local}  t(); 
有没有想到输出的结果会是这样的？为什么？
所谓函数作用域就是说：变量在声明它们的函数体以及这个函数体嵌套的任意函数体内都是有定义的。
所以根据函数作用域的意思，可以将上述代码重写如下：
例2
var scope = "global";  function t(){      var scope;      console.log(scope);      scope = "local"      console.log(scope);  }  t();  
我们可以看到，由于函数作用域的特性，局部变量在整个函数体始终是由定义的，我们可以将变量声明”提前“到函数体顶部，同时变量初始化还在原来位置。
为什么说Js没有块级作用域呢，有以下代码为证：
例3
var name = "global";  if(true){      var name = "local";      console.log(name)  //local}  console.log(name);     //local
如果有块级作用域，那么第二个应该输出“global”才对。
现在来回答上边遗留的问题，JavaScript会自动将变量声明(定义)提前, 调用变量时是找离调用位置最近的作用域的变量(找不到再找作用域链的上一层)，所以在函数中scope的声明会提前，但是没有赋值就像例2一样。
所以下面的代码也就很好理解了。
例4
function t(flag){      if(flag){          var s = "ifscope";          for(var i = 0;i < 2;i++){            ;          }    }      console.log(i);  // 2    console.log(s);  // ifscope}  t(true);  
例5
function t(flag){      if(flag){          s="ifscope";          for(var i=0;i<2;i++){            ;          }    }      console.log(i);  // 2}  t(true);  console.log(s);  // ifscope
就是上面的翻版，知识将声明s中的var去掉，这主要是Js中没有用var声明的变量都是全局变量，而且是顶层对象的属性。只有做赋值运算的时候才会把未定义的变量，定义为window的属性，如果没有赋值运算直接调用会报错
所以你用console.log(window.s)也是会输出"ifconfig"

作用域链（Scope Chain）

在JavaScript中，函数也是对象，实际上，JavaScript里一切都是对象。函数对象和其它对象一样，拥有可以通过代码访问的属性和一系列仅供JavaScript引擎访问的内部属性。其中一个内部属性是[[Scope]]，由ECMA-262标准第三版定义，该内部属性包含了函数被创建的作用域中对象的集合，这个集合被称为函数的作用域链，它决定了哪些数据能被函数访问。
当一个函数创建后，它的作用域链会被创建此函数的作用域中可访问的数据对象填充。例如定义下面这样一个函数：
function add(num1, num2) {    var sum = num1 + num2;    return sum;}
在函数add创建时，它的作用域链中会填入一个全局对象，该全局对象包含了所有全局变量，如下图所示（注意：图片只例举了全部变量中的一部分）：

函数add的作用域将会在执行时用到。例如执行如下代码：
var total = add(5, 10);
执行此函数时会创建一个称为“运行期上下文(execution context)”的内部对象，运行期上下文定义了函数执行时的环境。每个运行期上下文都有自己的作用域链，用于标识符解析，当运行期上下文被创建时，而它的作用域链初始化为当前运行函数的[[Scope]]所包含的对象。
这些值按照它们出现在函数中的顺序被复制到运行期上下文的作用域链中。它们共同组成了一个新的对象，叫“活动对象(activation object)”，该对象包含了函数的所有局部变量、命名参数、参数集合以及this，然后此对象会被推入作用域链的前端，当运行期上下文被销毁，活动对象也随之销毁。新的作用域链如下图所示：

在函数执行过程中，没遇到一个变量，都会经历一次标识符解析过程以决定从哪里获取和存储数据。该过程从作用域链头部，也就是从活动对象开始搜索，查找同名的标识符，如果找到了就使用这个标识符对应的变量，如果没找到继续搜索作用域链中的下一个对象，如果搜索完所有对象都未找到，则认为该标识符未定义。函数执行过程中，每个标识符都要经历这样的搜索过程。
再来看个例子
例6
name = "lwy";  function t(){      var name = "tlwy";      function s(){          var name = "slwy";          console.log(name);  //slwy    }      function ss(){          console.log(name);  //tlwy    }      s();      ss();  }  t();  
当执行s()时：
将创建函数s的执行环境(调用对象),并将该对象置于链表开头，然后将函数t的调用对象链接在之后，最后是全局对象。然后从链表开头寻找变量name,很明显 name是"slwy"。
作用域链：s() -> t() -> window
第一次搜索就找到了，即在s()中搜索就找到了name
当执行ss()时：
作用域链：ss() -> t() -> window
第一次搜所没有找到，去上一级中查找，找到了即在t()中找到name，所以结果为“tlwy”
下面看一个很容易犯错的例子
例7
<html>  <head>  <script type = "text/javascript">  function buttonInit(){      for(var i = 1; i < 4; i++){          var b = document.getElementById("button" + i);          b.addEventListener("click", function(){ alert("Button" + i); }, false);      }  }  window.onload = buttonInit;  </script>  </head>  <body>      <button id = "button1">Button1</button>      <button id = "button2">Button2</button>      <button id = "button3">Button3</button>  </body>  </html> 
当文档加载完毕，给几个按钮注册点击事件，当我们点击按钮时，会弹出什么提示框呢？
很容易犯错，三个按钮都是弹出："Button4",你答对了吗？
当注册事件结束后，i的值为4，当点击按钮时，事件函数即function(){ alert("Button" + i);}这个匿名函数中没有i,根据作用域链，所以到buttonInit函数中找，此时i的值为4，所以弹出”button4“。

作用域链和代码优化

从作用域链的结构可以看出，在运行期上下文的作用域链中，标识符所在的位置越深，读写速度就会越慢。如上图所示，因为全局变量总是存在于运行期上下文作用域链的最末端，因此在标识符解析的时候，查找全局变量是最慢的。所以，在编写代码的时候应尽量少使用全局变量，尽可能使用局部变量。一个好的经验法则是：如果一个跨作用域的对象被引用了一次以上，则先把它存储到局部变量里再使用。例如下面的代码：
function changeColor(){    document.getElementById("btnChange").onclick = function(){        document.getElementById("targetCanvas").style.backgroundColor = "red";    };}
这个函数引用了两次全局变量document，查找该变量必须遍历整个作用域链，直到最后在全局对象中才能找到。这段代码可以重写如下：
function changeColor(){    var doc = document;    doc.getElementById("btnChange").onclick = function(){        doc.getElementById("targetCanvas").style.backgroundColor = "red";    };}
这段代码比较简单，重写后不会显示出巨大的性能提升，但是如果程序中有大量的全局变量被从反复访问，那么重写后的代码性能会有显著改善。

改变作用域链

函数每次执行时对应的运行期上下文都是独一无二的，所以多次调用同一个函数就会导致创建多个运行期上下文，当函数执行完毕，执行上下文会被销毁。每一个运行期上下文都和一个作用域链关联。一般情况下，在运行期上下文运行的过程中，其作用域链只会被 with 语句和 catch 语句影响。
with语句是对象的快捷应用方式，用来避免书写重复代码。例如：
function initUI(){    with(document){        var bd = body,            links = getElementsByTagName("a"),            i = 0,            len = links.length;        while(i < len){            update(links[i++]);        }        getElementById("btnInit").onclick = function(){            doSomething();        };    }}
这里使用width语句来避免多次书写document，看上去更高效，实际上产生了性能问题。
当代码运行到with语句时，运行期上下文的作用域链临时被改变了。一个新的可变对象被创建，它包含了参数指定的对象的所有属性。这个对象将被推入作用域链的头部，这意味着函数的所有局部变量现在处于第二个作用域链对象中，因此访问代价更高了。如下图所示：

因此在程序中应避免使用with语句，在这个例子中，只要简单的把document存储在一个局部变量中就可以提升性能。
例8
person = {name: "yhb", age: 22, height: 175, wife: {name: "lwy", age: 21}};  with(person.wife){      console.log(name);  //lwy}
with语句将person.wife添加到当前作用域链的头部，所以输出的就是："lwy".
with语句结束后，作用域链恢复正常
另外一个会改变作用域链的是try-catch语句中的catch语句。当try代码块中发生错误时，执行过程会跳转到catch语句，然后把异常对象推入一个可变对象并置于作用域的头部。在catch代码块内部，函数的所有局部变量将会被放在第二个作用域链对象中。示例代码：
try{    doSomething();}catch(ex){    alert(ex.message); //作用域链在此处改变}
请注意，一旦catch语句执行完毕，作用域链机会返回到之前的状态。try-catch语句在代码调试和异常处理中非常有用，因此不建议完全避免。你可以通过优化代码来减少catch语句对性能的影响。一个很好的模式是将错误委托给一个函数处理，例如：
try{    doSomething();}catch(ex){    handleError(ex); //委托给处理器方法}
优化后的代码，handleError方法是catch子句中唯一执行的代码。该函数接收异常对象作为参数，这样你可以更加灵活和统一的处理错误。由于只执行一条语句，且没有局部变量的访问，作用域链的临时改变就不会影响代码性能了。

参考资料

1. High.Performance.JavaScript, Nicholas.C.Zakas
2. Explaining JavaScript Scope And Closures, Robert Nyman
3. ECMAScript Language Specification, bclary.com

0 0