原型链组合继承习题分析

function SuperType(name) {
    this.name = name;
    this.colors = ["red", "blue", "green"];
}
/*调用函数时 在实例对象中添加name属性，并赋值为name，原本this是指向SuperType构造的
实例对象，但是在本题中，在对SuperType进行调用时修改了this的指向，所以这里的this指向
的是SubType函数构造的实例对象*/

SuperType.prototype.sayName = function () {
    console.log(this.name);
};

function SubType(name, age) {
    SuperType.call(this, name);
    this.age = age;
}
SubType.prototype = new SuperType();//SubType构造函数的原型对象是 SuperType的实例对象
								//SubType.prototype.__proto__ == SuperType.prototype
SubType.prototype.sayAge = function () {
    console.log(this.age);

};

var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
console.log(instance1.colors);
instance1.sayName();
instance1.sayAge();

var instance2 = new SubType("Greg", 27);
console.log(instance2.colors);
instance2.sayName();
instance2.sayAge();

1）var instance1 = new SubType("Nicholas", 29);/*构造函数SubType()构造了一个新的
                                     实例函数instance1，调用SubType(name, age)函数，
                                     将实参("Nicholas", 29)传入函数中*/


2）function SubType("Nicholas", 29) {
    1.SuperType.call(this, name);//调用SuperType()函数，
      将SuperType()函数中的this指向SubType实例对象
    {
        .call()函数的作用是改变this指向，这里时改变SuperType的this指向
        .call(第一个参数,第二个参数,...,...)
        第一个参数：this的指向对象，在本题中，第一个参数是this，
                    这个this是SubType()函数的
                    那么SubType()函数的this指向是instance1
        第二个参数第二个参数,...,...函数SuperType()的参数
        此时SuperType.call(instance1, name)
    }
    2.this.age = 29;//实参赋值
}

3）instance1.colors.push("black");//instance1函数中的colors数组中添加一个元素"black"
								//此时this.colors = ["red", "blue", "green","black"];
4)console.log(instance1.colors);//输出colors数组;["red", "blue", "green","black"]

5)instance1.sayName();//"Nicholas"
	/*
	1.由于instance1自己没有sayName()函数，所以在原型链中向上寻找
	2.instance1.__proto__ == SubType.prototype;
	3.SubType.prototype.__proto__ == SuperType.prototype;
	4.  instance1.__proto__.__proto__
	  ==SubType.prototype.__proto__
	  == SuperType.prototype
	5.所以instance1.__proto__.__proto__ == SuperType.prototype
	6.SuperType.prototype.sayName = function () {
    	console.log(this.name);
    }
		就相当于
	7.instance1.__proto__.__proto__.sayName = function () {
    	console.log(this.name);
    }
    8.instance1中的原型链找到了sayName()函数，
      所以此时函数的this指向函数调用者instance1
	*/

6)instance1.sayAge();//输出29
	/*
	1.由于instance1自己没有sayAge()函数，所以在原型链中向上寻找
	2.instance1.__proto__ == SubType.prototype;
	3.SuperType.prototype.sayAge = function () {
    	console.log(this.age);
    }
		就相当于
	4.instance1.__proto__.sayAge = function () {
    	console.log(this.age);
    }
    5.instance1中的原型链找到了sayAge()函数，
      所以此时函数的this指向函数调用者instance1
	*/

7）var instance2 = new SubType("Greg", 27);
8)function SubType("Greg", 27){
    1.SuperType.call(this, name);
    2.this.age = 27;//实参赋值
}
9）console.log(instance2.colors);//["red", "blue", "green"]
10)instance2.sayName();//"Greg"
11)instance2.sayAge();//27