4.深入搞懂构造函数和原型对象

Question

常用的几种对象创建模式

使用 new 关键字创建

最基本的对象创建方式:

var o = new Object();
o.name = 'james';
o.sex = 'man';
o.sayWhat = function(){
  console.log(this.name+"said:I am a"+this.sex);
}

使用字面量

var o = {
   name:'zhangcong',
   sex :'man',
   sayWhat:function(){
     console.log(this.name + 'said I am a' + this.sex);
   }
}
var b = o.sayWhat();

工厂模式

实际中最常用的对象定义方式,可以定义大量属性

function creatO(name,sex) {
  var o = new Object;
  o.name = name;
  o.sex = sex;
  o.sayWhat = function() {
    console.log(this.name +' '+ 'like'+' zhangcong');
     console.log(this.name +'是'+this.sex+'孩');
  }
  return o;
}

var gf = creatO('YangYou','女')
gf.sayWhat();

构造函数

工厂模式解决了多个相似对象的创建问题，但是问题又来了，这些对象都是Object整出来的，怎么区分它们的对象具体类型呢？这时候我们就需要切换到另一种模式了，构造函数模式：

function Gf(name,sex) {
  this.name = name;
  this.sex = sex;
  this.sayWhat = function(){
    console.log(this.name + 'said I am a' + this.sex);
  }
}
var gf1 = new Gf('yangyou','gril');

使用一个大写字母开头的构造函数替代了工厂模式中的 creatO，注意按照约定构造函数的首字母要大写。在这里我们创建一个新对象，然后将构造函数的作用域赋给新对象，调用构造函数中的方法。

原型对象模式

理解原型对象模式

当我们创建一个函数时，该函数就会具备一个 prototype 属性，这个属性指向通过构造函数创建的那个函数的原型对象。通俗点讲原型对象就是内存中为其他对象提供共享属性和方法的对象。

在原型模式中，不必再构造函数中定义实例属性，可以将属性信息直接赋予原型对象：

function Gf() {
  Gf.prototype.name = 'zhangcong';
  Gf.prototype.sex = 'nan';
  Gf.prototype.sayWhat = function () {
    console.log(this.name + this.sex);
  }
}

var gf1 = new Gf();
gf1.sayWhat();
var gf2 = new Gf();

和构造函数不同的是这里新对象的属性和方法是所有实例都可以共享的，换句话说gf1和gf2访问的是同一份属性和方法。原型对象中除了我们赋予的属性外，还有一些内置的属性，所有原型对象都具备一个 constructor 属性，这个属性是一个指向包含prototype属性函数的一个指针。

所有的对象都有一个原型对象（prototype），原型对象中有一个constructor属性指向包含prototype属性的函数，Gf的实例gf1和gf2都包含一个内部属性指向原型对象（在firefox 浏览器中表现为私有属性 proto），当我们访问一个对象中的属性时，首先会询问实例对象中有没有该属性，如果没有则继续查找原型对象。

使用原型对象

在为原型对象添加属性时，需要每个都增加 Gf.prototype，这个工作很重复，在上面对象的创建模式中，我们知道可以通过字面量的形式创建一个对象，这里我们也可以改进一下：

function Gf() {}
  Gf.propotype = {
    name:'zhangcong',
    sex :'man',
    sayWhat:function(){
      consolve.log(this.name + this.sex);
    }
  }

这里有一个地方需要特别注意下，constructor 属性不再指向对象Gf，因为每定义一个函数，就会同时为其创建一个 prototype 对象，这个对象也会自动获取一个新的 constructor 属性，这个地方我们使用 Gf.prototype 本质上覆写了原有的 prototype 对象，因此 constructor 也变成了新对象的 constructor 属性，不再指向 Gf，而是Object:

var gf1 = new Gf();
console.log(gf1.constructor == Gf);//false
console.log(gf1.constructor == Object)//true

一般情况下，这个微妙的改变是不会对我们造成影响的，但如果你对 constructor 有特殊的需求，我们也可以显式的指定下 Gf.prototype 的 constructor 属性：

Gf.prototype = {
  constructor : Gf,
  name : "vivian",
  bar : "c++",
  sayWhat : function() {
    alert(this.name + "said:love you forever");
  }
}
var gf1 = new Gf();
console.log(gf1.constructor == Gf);//true

通过对原型对象模式的初步了解，我们发现所有的实例对象都共享相同的属性，这是原型模式的基本特点，但往往对于开发者来说这是把“双刃剑”，在实际开发中，我们希望的实例应该是具备自己的属性，这也是在实际开发中很少有人单独使用原型模式的主要原因。

构造函数和原型组合模式

在实际开发中，我们可以使用构造函数来定义对象的属性，使用原型来定义共享的属性和方法，这样我们就可以传递不同的参数来创建出不同的对象，同时又拥有了共享的方法和属性。

function Gf(name,bar) {
  this.name = name;
  this.bar = bar;
}
Gf.prototype = {
  construction:Gf,
  sawWhat : functon(){
    console.log(this.name + this.bar);
  }
}
var gf1 = new Gf('zhangcong','ddd');
var gf2 = new Gf('lisi','coffer');
gf1.sayWhat();

在这个例子中，我们再构造函数中定义了对象各自的属性值，在原型对象中定义了constructor属性和sayWhat函数，这样gf1和gf2属性之间就不会产生影响了。这种模式也是实际开发中最常用的对象定义方式，包括很多js库（bootstrap等）默认的采用的模式。

Function 构造器生成的函数，在全局作用域中被创建

1、f() 函数返回的 function e() 是闭包.

var n = 1;
function f(){
  var n = 2;
  function e(){
    return n;
  }
  return e;
}
console.log (f()()); // 2

2、f() 函数返回的 function e() 是全局作用域函数

var n = 1;
function f(){
  var n = 2;
  var e = new Function("return n;");
  return e;
}
console.log (f()()); // 1