1. 所有的数据都是对象#

JavaScript在设计的时候，模仿 Java 引入了两套类型机制：基本类型和对象类型。基本类型包括 undefined 、 number 、 boolean 、 string 、 function 、 object

除了 undefined 之外，一切都应是对象。为了实现这一目标，number 、 boolean 、 string 这几种基本类型数据也可以通过“包装类”的方式变成对象类型数据来处理

不能说在 JavaScript中所有的数据都是对象，但可以说绝大部分数据都是对象。那么相信在 JavaScript中也一定会有一个根对象存在，这些对象追根溯源都来源于这个根对象。

JavaScript 中的根对象是 Object.prototype 对象。 Object.prototype 对象是一个空的对象。我们在JavaScript 遇到的每个对象，实际上都是从 Object.prototype 对象克隆而来的，Object.prototype 对象就是它们的原型。

可以利用 ECMAScript 5提供的 Object.getPrototypeOf 来查看这两个对象的原型：

1
var obj1 = new Object();
2
var obj2 = {};
3
console.log( Object.getPrototypeOf( obj1 ) === Object.prototype ); // 输出：true
4
console.log( Object.getPrototypeOf( obj2 ) === Object.prototype ); // 输出：true

2. 要得到一个对象，不是通过实例化类，而是找到一个对象作为原型并克隆它#

在 JavaScript语言里，我们并不需要关心克隆的细节，因为这是引擎内部负责实现的。我 们所需要做的只是显式地调用 var obj1 = new Object() 或者 var obj2 = {} 。此时，引擎内部会从Object.prototype 上面克隆一个对象出来，我们最终得到的就是这个对象.

用 new 运算符从构造器中得到一个对象

1
function Person( name ){
2
  this.name = name;
3
};
4
Person.prototype.getName = function(){
5
  return this.name;
6
};
7
var a = new Person( 'sven' )
8
console.log( a.name ); // 输出：sven
9
console.log( a.getName() ); // 输出：sven
10
console.log( Object.getPrototypeOf( a ) === Person.prototype ); // 输出：true

这里 Person 并不是类，而是函数构造器，JavaScript 的函数既可以作为普通函数被调用，也可以作为构造器被调用,当使用 new 运算符来调用函数时，此时的函数就是一个构造器。 用new 运算符来创建对象的过程，实际上也只是先克隆 Object.prototype 对象，再进行一些其他额外操作的过程。

可以模拟new的过程：

1
// 模拟new的实现方式
2
// 先来一个Person构造器
3

4
function Person(name) {
5
    this.name = name;
6
}
7

8
Person.prototype.getName = function () {
9
    return this.name;
10
}
11

12
var objectFactory = function () {
13
    var obj = new Object(), //从Object.prototype上克隆一个空的对象{}
14
        Constructor = [].shift.call(arguments); // 取得外部传入的构造器，此例是 Person
15
    obj.__proto__ = Constructor.prototype; // 指向正确的原型
16
    var ret = Constructor.apply(obj, arguments); // 借用外部传入的构造器给 obj 设置属性
17
    return typeof ret === 'object' ? ret : obj; // 确保构造器总是会返回一个对象
18
}
19

20
var a = objectFactory(Person, 'weng');
21
console.log(a.getName());

3. 对象会记住它的原型#

对象的原型”，就 JavaScript 的真正实现来说，其实并不能说对象有原型，而只能说对象的构造器有原型。对于“对象把请求委托给它自己的原型”这句话，更好的说法是对象把请求委托给它的构造器的原型

JavaScript 给对象提供了一个名为 __proto__ 的隐藏属性，某个对象的 __proto__ 属性默认会指向它的构造器的原型对象，即 {Constructor}.prototype 。在一些浏览器中， __proto__ 被公开出来

1
var a = new Object();
2
console.log ( a.__proto__=== Object.prototype ); // 输出：true

__proto__ 就是对象跟“对象构造器的原型”联系起来的纽带。正因为对象要通过_proto__ 属性来记住它的构造器的原型，所以我们的 objectFactory 函数来模拟用 new创建对象时， 需要手动给 obj 对象设置正确的 __proto__ 指向

obj.__proto__ = Constructor.prototype;

让 obj.proto 指向 Person.prototype ，而不是原来的 Object.prototype

4. 如果对象无法响应某个请求，它会把这个请求委托给它的构造器的原型#

在 JavaScript 中，每个对象都是从 Object.prototype 对象克隆而来的，如果是这样的话， 我们只能得到单一的继承关系，即每个对象都继承自 Object.prototype 对象，这样的对象系统显 然是非常受限的。

实际上，虽然 JavaScript 的对象最初都是由 Object.prototype 对象克隆而来的，但对象构造 器的原型并不仅限于 Object.prototype 上，而是可以动态指向其他对象。这样一来，当对象 a 需 要借用对象 b 的能力时，可以有选择性地把对象 a 的构造器的原型指向对象 b ，从而达到继承的 效果

1
var obj = { name: 'sven' };
2
var A = function(){};
3
A.prototype = obj;
4
var a = new A();
5
console.log( a.name ); // 输出：sven

1
var A = function(){};
2
A.prototype = { name: 'sven' };
3
var B = function(){};
4
B.prototype = new A();
5
var b = new B();
6
console.log( b.name ); // 输出：sven