JS面向对象编程之普通类、Function和Object的关系

JavaScript中Function和Object简单来说就是互为父亲的关系了，是不是听起来有点微妙，下面我就通过一些列子来证明这种“乱伦”的关系了。

从普通类开始
第一步定义一个Point类：

function Point (row, col) {
	this.setRow = function (row) {
		this.row = row ? row : 1;
	}

	this.setCol = function (col) {
		this.col = col ? col : 1;
	}

	this.getRow = function () {
		return this.row;
	}

	this.getCol = function () {
		return this.col;
	}

	this.toString = function () {
		return '(' + row + ", " + col + ')';
	}

	this.setRow(row);
	this.setCol(col);

}

接着创建这个类的三个对象

var point1 = new Point(4, 6);
var point2 = new Point(5);
var point3 = new Point();

输出

console.log("Point:", Point);
console.log("point1 : ", point1);
console.log("point2 : ", point2);
console.log("point3 : ", point3);

我们看到Point类有prototype属性和_proto_属性，prototype属性是指原型，而prototype是指这个类的原型链；
point1是Point的一个对象，它只有_proto_属性。
其实我们是可以通过判断是否含有prototype属性来判断它是一个类还是一个对象的，但是何为原型，何为原型链，这该怎么解释呢。

输出
console.log("point1.__proto__ === Point.prototype", point1.__proto__ === Point.prototype);

结果为 true， 可以说明一个对象的原型链和它所属类的原型指向的是同一个空间。

Point含有_prototype_属性，说明Point类其实也是父类的一个对象，它的原型链应该与它的父类的原链指向同一空间。

再看Point的输出结果：

Point类的父类其实是function，输出下面的结果

console.log("Point instanceof Function", Point instanceof Function);
 console.log("Function.prototype === Point.__proto__:", 	Function.prototype === Point.__proto__);

两个结果都为true，因此Point类的原型链和Function的原型指向了同一个空间，如图：

这么看来Function的原型链又指向了哪里呢？

console.log("Function.prototype === Function.__proto__:", Function.prototype === Function.__proto__);

它的输出结果为true，因此Function.prototype， Function.__proto__指向了同一空间。

但是Point类的原型和Function的原型到底是什么呢，我们来看看Object类
输出

console.log ("Object :", Object);

从这里我们可以看到Object类其实是Function的对象，输出`

 console.log("Object.__proto__ === Function.prototype:", Object.__proto__ === Function.prototype);

的结果为true,因此有下图：

从上图可以看到，Point，Function和Object的原型都还没有指向，我们输出：

 console.log("Point.prototype instanceof Object", Point.prototype instanceof Object);
   console.log("Function.prototype instanceof Object", Function.prototype instanceof Object);

结果都为true,证明所有类的原型其实都是一个Object类的对象，则这个对象的_prototype_所指向的空间就是Object类的原型所指向的空间：

 console.log("Point.prototype.__proto__ === Object.prototype", Point.prototype.__proto__ === Object.prototype);
    console.log("Function.prototype.__proto__ === Object.prototype",  Function.prototype.__proto__ === Object.prototype);

它们的结果为true，最后形成的图像如下：

最后我们输出

 console.log("Object.prototype.__proto__:", Object.prototype.__proto__);

结果为null,相当于一个链表的末节点。

console.log("Object instanceof Function:", Object instanceof Function);
console.log("Object instanceof Object:", Object instanceof Object);
console.log("Function instanceof Object:", Function instanceof Object);

这三行代码的输出结果都为true,因此就可以证明刚开篇提到的Function与Object之间互为父类的复杂关系了，Object是Function 的一个对象，Function也是Object的一个对象，值得注意的是Object类也是自己的一个对象。
不得不说JavaScrip里面的关系是在是太复杂了~~~~