首先原型链是指的是对象为单位,
闭包呢,是以函数为单位.
我说的相似之处是,
他们都能有自己独立的仓库,或者世界.
原型链
Person.prototype.isRich = 'very rich';
function Person () {
this.sex = 'male';
}
var person = new Person()
Father.prototype = person;
function Father () {
this.age = 18
}
var father = new Father();
Son.prototype = father;
function Son () {
this.name = 'mike';
}
var son = new Son();
son这个实例对象,可以访问他上面所有原型链上的方法和属性.
本篇里我想象成,他拥有多个世界的钥匙.
函数
var fun = (function() {
var sex = 'male';
function person() {
var name = 'mike';
function father() {
var age = '18';
return function son() {
return {
sex,
name,
age
}
}
}
return father();
}
return person();
})();
var a = fun();
这么写感觉挺蠢的,重点是,函数也能拥有很多个世界.
我们不嵌套多层,就看看两层结构
var fun = (function () {
var obj = {
name:'mike',
age : 18,
sex : 'male',
handle : function () {
console.log(123);
}
}
var fun = function () {
console.log(obj);
return obj;
}
return fun;
})();
返回的fun上面,肯定是拥有访问上一个世界的钥匙,
问题是无法像对象一样,通过fun.name,fun.obj这样的方式去访问操作.
因为[[scope]]属性是无法被访问的.
也就是说,如果想要操作obj,必须要在fun定义的时候,定义好怎么操作.
Person.prototype.obj = {
name:'mike',
age : 18,
sex : 'male',
handle : function () {
console.log(123);
}
}
function Person () {};
var person = new Person();
var fun = (function () {
var obj = {
name:'mike',
age : 18,
sex : 'male',
handle : function () {
console.log(123);
}
}
var getName = function () {
return obj.name;
}
var getAge = function () {
return obj.age;
}
var getSex = function () {
return obj.sex;
}
var getHandle = function () {
return obj.handle;
}
var objFun = {
getName,
getAge,
getSex,
getHandle
};
return function () {
return objFun;
}
})();
跟原型链,对象的操作数据方式相比,
利用函数执行,感觉很别扭,这种别扭可能来自,操作不是很方便
但好处是,数据保护可以做的很好,
并且如果预留出的接口足够丰富,齐全,也应该是比较好用的.
问题是,两者最佳适用情景是什么的问题?
这个肯定跟经验有关,或者跟什么设计模式有关?
我们看一下jQuery源码就会发现,
实际上jq是两者结合.
先形成一个闭包,又生成一个实例.
或者,函数生成的世界,概念更接近"环境"这个概念.
而原型链代表的世界,概念更接近一种"库"的概念.
===========================================
回头重看这一篇写的,
感觉写的挺蠢的,
不过令人感觉挺搞笑的是,
上面写的函数闭包返回对象的形式.
乍一看,完全就是构造函数,就差一个new了.
我想也许,能写成闭包形式的,都能改成构造函数的形式返回对象,
能写成构造好书返回对象形式的,都能写成闭包.
两者的区别?
构造函数的形式,返回的是对象,所以语义化更好?
更容易扩展?和维护?
