你不知道的JavaScript“坑”

最近在看《你不知道的JavaScript》系列丛书，发现了平时容易误解、混淆或者违背常理的一些特性，在此进行总结一下。

[[Prototype]]屏蔽属性

var a = {a:2}
var b = Object.create(a)
a.a
>2
b.a
>2
b.a++
>2
b.a
>3
a.a
>2

原因：++操作相当于b.a = b.a + 1。因此++操作首先通过[[Prototype]]查找a属性并从a.a获取当前属性值2，然后给这个值加1，接着用[[put]]将值3赋给b中新建的屏蔽属性a。

JavaScript中的“类”

在ES6之前，我们都是用一些方法近似实现类的功能。然而实际上JavaScript的类与其他语言并不一样。

继承

在其他语言（如Java）中，定义一个子类，相对于父类它就是一个独立并且完全不同的类。子类会包含父类行为的原始副本，也可以重写所有继承的行为甚至定义新行为。类的继承本质上是复制。
在JavaScript中，类继承和实例化，并不会自动执行复制行为。在JavaScript中只有对象，并不存在可以实例化的类。一个对象并不会复制到其他对象，它们会被关联起来。

实例

function Foo(){this.a = 1}
f = new Foo()
Object.getPrototypeOf(f) === Foo.prototype
>true

JavaScript中不能创建一个类的多个实例，只能创建多个对象。new Foo()会生成一个新对象，新对象的内部链接[[Prototype]]关联的是Foo.prototype对象。
最后我们得到了两个对象，它们之间互相关联。实际上，我们并没有从"类”中复制任何行为到一个对象中，只是让两个对象关联。这是和其他编程语言不同的地方。

“类”和“委托”

function Foo(who){
    this.me = who;
}

Foo.prototype.identify = function () {
    return "I am  "+this.me;
};

function Bar(who){
    Foo.call(this,who);
}

//创建一个新的Bar.prototype对象并关联到Foo.prototype
Bar.prototype = Object.create(Foo.prototype);

Bar.prototype.speak = function () {
    console.log("Hello,"+this.identify());
};

var b1 = new Bar("b1");
var b2 = new Bar("b2");
b1.speak();
b2.speak();
>Hello,I am  b1
>Hello,I am  b2

以上例子是“类”模式。

Foo = {
    init:function (who) {
        this.me = who;
    },
    identify:function () {
        return "I am " + this.me;
    }
};
Bar = Object.create(Foo);
Bar.speak = function () {
    console.log("Hello,"+this.identify());
};

var b1 = Object.create(Bar);
var b2 = Object.create(Bar);
b1.init("b1");
b2.init("b2");
b1.speak();
b2.speak();
>Hello,I am b1
>Hello,I am b2

以上是“委托”模式。

以上均用到了Object.create(...)函数。它会创建一个新对象，并把它关联到指定对象。这样我们才能充分发挥[[prototype]]机制的威力（委托）（查找属性当对象本身不存在该属性时查找原型链）。

"类“模式的代码中常常会出现大量” Foo.call(this,who);"这样丑陋的代码（从”子类”中引用”父类“方法）。相比而言，“委托”模式更为简洁明了。

值得多提一句的是，在很多书籍中，使用“类”模式时，常常使用了两种错误的方式来创建原型关联。

//直接引用的方式，当修改Bar.prototype时会直接影响Foo.prototype
Bar.prototype = Foo.prototype;
//如果函数Foo有一些副作用，比如写日志、给this添加属性等等，会影响Bar的shi'li
Bar.prototype = new Foo();

闭包的“正确定义”

闭包：当函数可以记住并访问所在的词法作用域，即使函数在当前词法作用域之外执行，这时就产生了闭包