JS构造函数

对象创建的三种方法

1. 字面量()

var obj = {};

2. new关键字

var obj = new Object();

3. 构造函数

function Person(name,age){
  this.name = name;
  this.age = age;
}
var obj = new Person('zs',12);

构造函数原型prototype

构造函数通过原型分配的函数是所有对象所共享的。
JavaScript 规定，
每一个构造函数都有一个prototype 属性，指向另一个对象。注意这个prototype就是一个对象，这个对象的所有属性和方法，都会被构造函数所拥有。
我们可以把那些不变的方法，直接定义在 prototype 对象上，这样所有对象的实例就可以共享这些方法。

function Star(uname, age) {
    this.uname = uname;
    this.age = age;
}
Star.prototype.sing = function() {
	console.log('我会唱歌');
}
var ldh = new Star('刘德华', 18);
var zxy = new Star('张学友', 19);
ldh.sing();//我会唱歌	ldh实例调用构造函数原型方法
zxy.sing();//我会唱歌	zxy实例调用构造函数原型方

对象原型

• 对象都会有一个属性 __proto__ 指向构造函数的 prototype 原型对象
• 之所以我们对象可以使用构造函数 prototype 原型对象的属性和方法，就是因为对象有 __proto__ 原型的存在。
• __proto__对象原型和原型对象 prototype 是等价的
  

function Star(uname, age) {
    this.uname = uname;
    this.age = age;
}
Star.prototype.sing = function() {
	console.log('我会唱歌');
}
var ldh = new Star('刘德华', 18);
console.log(ldh.__proto__ === Star.prototype) 
//true

constructor构造函数

• 对象原型 __proto__和构造函数prototype原型对象 都有一个属性 constructor
• constructor 我们称为构造函数，因为它指回构造函数本身。
• constructor 主要用于记录该对象引用于哪个构造函数，它可以让原型对象重新指向原来的构造函数。

如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用constructor指回原来的构造函数

 function Star(uname, age) {
     this.uname = uname;
     this.age = age;
 }
 // 很多情况下,我们需要手动的利用constructor 这个属性指回 原来的构造函数
 Star.prototype = {
 // 如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用constructor指回原来的构造函数
   constructor: Star, // 手动设置指回原来的构造函数
   sing: function() {
     console.log('我会唱歌');
   },
   movie: function() {
     console.log('我会演电影');
   }
}
var zxy = new Star('张学友', 19);
console.log(zxy)

原型链

每一个实例对象又有一个__proto__属性，指向的构造函数的原型对象，构造函数的原型对象也是一个对象，也有__proto__属性，这样一层一层往上找就形成了原型链。

构造函数实例和原型对象三角关系

1. 构造函数的prototype属性指向了构造函数原型对象
2. 实例对象是由构造函数创建的,实例对象的__proto__属性指向了构造函数的原型对象prototype
3. 构造函数的原型对象的constructor属性指向了构造函数,实例对象的原型的constructor属性也指向了构造函数
   

原型链和成员的查找机制

1. 当访问一个对象的属性（包括方法）时，首先查找这个对象自身有没有该属性。
   如果没有就查找它的原型（也就是 __proto__指向的 prototype 原型对象）。
2. 如果还没有就查找原型对象的原型（Object的原型对象）。
   依此类推一直找到 Object 为止（null）。
3. __proto__对象原型的意义就在于为对象成员查找机制提供一个方向，或者说一条路线。

原型对象中this指向

构造函数中的this和原型对象的this,都指向我们new出来的实例对象

继承

子构造函数继承父构造函数中的属性
借用原型对象继承方法

更改this指向

1. call()方法调用一个对象。简单理解为调用函数的方式，但是它可以改变函数的 this 指向 fun1.call(fun2) 将fun1的方法放到fun2中

 var o = {
	name: 'andy'
}
 function fn(a, b) {
      console.log(this);
      console.log(a+b)
};
fn(1,2)// 此时的this指向的是window 运行结果为3
fn.call(o,1,2)//此时的this指向的是对象o,参数使用逗号隔开,运行结果为3

2. apply() 方法调用一个函数。简单理解为调用函数的方式，但是它可以改变函数的 this 指向。

var o = {
	name: 'andy'
}
 function fn(a, b) {
      console.log(this);
      console.log(a+b)
};

fn(1,2)// 此时的this指向的是window 运行结果为3
fn.apply(o,[1,2])//此时的this指向的是对象o,参数使用数组传递 运行结果为3

3. bind() 方法不会调用函数,但是能改变函数内部this 指向,返回的是原函数改变this之后产生的新函数

 var o = {
 name: 'andy'
 };

function fn(a, b) {
	console.log(this);
	console.log(a + b);
};
var f = fn.bind(o, 1, 2); //此处的f是bind返回的新函数
f();//调用新函数  this指向的是对象o 参数使用逗号隔开

重写prototype

  function A(){
      this.do =function(){return 'foo'}
    }
      A.prototype.do = function(){
        
        return 'foo222'
    }

    var x =new A()
    console.log(A.prototype.do())	 foo222
    console.log(x.do())				foo