JS中的变量对象

函数参数传递的过程实际上就是实参像形参复制值的过程。

• 在向参数传递基本类型的值时，被传递（实参）的值会复制给一个局部变量（形参），形参值的变化不会对函数外的实参产生影响。
• 在向参数传递引用类型的值时，会把这个值在内存中的地址复制给形参。这时这个形参也指向了函数外的实参，因此这个形参的变化也会导致实参的变化。

  function addTen(num) {
    num += 10;
    return num;
  }

  var count = 20, result = addTen(count);
  alert(count); //20

这里函数 addTen()的参数num，实际上是函数的局部变量。在调用函数时，变量count作为参数传递给函数。由于 count 的值是20，所以数值20被复制给参数num。在函数内部，这个参数被加了10，但这并不会影响函数外部的count变量。

当向参数传递的值为对象时，例如：

 function setName(obj) {
    obj.name = "Nicholas";
  }

  var person = new Object();
  person.name = "Greg";
  setName(person);
  alert(person.name);  //"Nicholas"

这里首先是创建了一个对象，保存在变量person中，并且给变量的 name属性赋值为 "Greg"。然后这个变量被当作参数传递给函数setName的参数 obj。在函数内部，obj和 person 指向同一个对象，因为传递的是对象的地址。所以给obj的 name属性赋值后，也会改变 person 的name属性值。

如果在函数内部为obj新建一个对象实例，这个新对象实例会开辟新的内存空间，导致 obj的地址和person不同。此时，obj和 person 将指向两个不同的对象，所以互不影响。例如：

  function setName(obj) {
    obj.name = "Nicholas"; // 这个obj和person指向的地址相同，即函数外person创建的对象。    
    obj = new Object(); // 新建实例对象，导致obj指向另一个地址    
    obj.name = "Greg";
  }

  var person = new Object();
  person.name = "Jhon";
  setName(person);
  alert(person.name); //"Nicholas"

全局上下文中的变量对象

全局对象(Global object) 是在进入任何执行上下文之前就已经创建了的对象；这个对象只存在一份，它的属性在程序中任何地方都可以访问，全局对象的生命周期终止于程序退出那一刻。

全局对象初始创建阶段将Math、String、Date、parseInt 作为自身属性，等属性初始化，同样也可以有额外创建的其它对象作为属性（其可以指向到全局对象自身）。例如，在DOM中，全局对象的window属性就可以引用全局对象自身(当然，并不是所有的具体实现都是这样)：

global = {
  Math: <...>,
  String: <...>
  ...
  ...
  window: global //引用自身
};

函数上下文中的变量对象

在函数执行上下文中，变量对象(VO)是不能直接访问的，此时由活动对象(activation object,缩写为AO)扮演 VO 的角色。

活动对象是在进入函数上下文时刻被创建的，它通过函数的arguments属性初始化。arguments属性的值是 Arguments对象：

Arguments 对象是活动对象的一个属性，它包括如下属性：

• callee ：指向当前函数的引用；
• length ： 真正传递的参数个数；
• properties-indexes (字符串类型的整数)： 属性的值就是函数的参数值(按参数列表从左到右排列)。 properties-indexes 内部元素的个数等于arguments.length，properties-indexes的值和实际传递进来的参数之间是共享的。

function foo(x, y, z) {
 
  // 声明的函数参数数量arguments (x, y, z)
  alert(foo.length); // 3
 
  // 真正传进来的参数个数(only x, y)
  alert(arguments.length); // 2
 
  // 参数的callee是函数自身
  alert(arguments.callee === foo); // true
 
  // 参数共享
 
  alert(x === arguments[0]); // true
  alert(x); // 10
 
  arguments[0] = 20;
  alert(x); // 20
 
  x = 30;
  alert(arguments[0]); // 30
 
  // 不过，没有传进来的参数z，和参数的第3个索引值是不共享的

  z = 40;
  alert(arguments[2]); // undefined
 
  arguments[2] = 50;
  alert(z); // 40
 
}
 
foo(10, 20);

现在在严格模式下，arguments 对象已与过往不同。arguments 不再与函数的实际形参之间共享，同时caller属性也被移除。

剩余参数、默认参数和解构赋值参数

在严格模式下，剩余参数、默认参数和解构赋值参数的存在不会改变 arguments对象的行为，但是在非严格模式下就有所不同了。

当非严格模式中的函数没有包含剩余参数、默认参数和解构赋值，那么arguments对象中的值会跟踪参数的值（反之亦然）。看下面的代码：

function func(a) { 
  arguments[0] = 99;   // 更新了arguments[0] 同样更新了a
  console.log(a);
}
func(10); // 99

并且

function func(a) { 
  a = 99;              // 更新了a 同样更新了arguments[0] 
  console.log(arguments[0]);
}
func(10); // 99

当非严格模式中的函数有包含剩余参数、默认参数和解构赋值，那么arguments对象中的值不会跟踪参数的值（反之亦然）。看下面的代码：

function func(a = 55) { 
  a = 99; // updating a does not also update arguments[0]
  console.log(arguments[0]);
}
func(10); // 10

并且

function func(a = 55) { 
  console.log(arguments[0]);
}
func(); // undefined

delete

关于变量，还有一个重要的知识点。变量相对于简单属性来说，变量有一个特性(attribute)：{ DontDelete },这个特性的含义就是不能用 delete 操作符直接删除变量属性。

a = 10;
alert(window.a); // 10
 
alert(delete a); // true
 
alert(window.a); // undefined
 
var b = 20;
alert(window.b); // 20
 
alert(delete b); // false
 
alert(window.b); // still 20

但是这个规则在有个上下文里不起走样，那就是eval上下文，变量没有 { DontDelete } 特性。

eval('var a = 10;');
alert(window.a); // 10
 
alert(delete a); // true
 
alert(window.a); // undefined

参考文章

Arguments 对象
深入理解JavaScript系列（12）：变量对象（Variable Object）