对象的继承

对象的继承

 function MyArray() {}  //声明一个MyArray函数
 MyArray.prototype = new Array(); //将MyArray的原型对象赋值为Array的实例
 MyArray.prototype.constructor = MyArray; //将MyArray的constructor赋值为MyArray
 var mine = new MyArray(); //创建MyArray的实例
 mine.push(1,2,3); //创建后的实例对象完全继承了Array的属性和方法
 console.log(mine.length)  //3
 mine instanceof Array; //true
 

 function P() {}
 var p = new P();
 console.log(p.constructor === P); //true
 console.log(p.constructor === P.prototype.constructor)  //true
 p.hasOwnProperty("constructor")  //false

 function Constr() {}
 var x = new Constr();

 var y = new x.constructor();
 y instanceof Constr // true

 Constr.prototype.createCopy = function() {
     return new this.constructor();
 };
 var b = x.createCopy();
 

 function Person(name) {
     this.name = name;
 }

 Person.prototype.constructor === Person // true
 //将Person.prototype对象进行重新赋值但是未指定constructor属性，则对象constructor默认指向Object
 Person.prototype = {
     method: function () {}
 };

 Person.prototype.constructor === Person // false
 Person.prototype.constructor === Object // true
        

 //利用instanceof运算符，还可以巧妙地解决，调用构造函数时，忘了加new命令的问题。
 function Person(name,age) {
     if(this instanceof Person) {
         this.name = name;
         this.age = age;
     }else {
         return new Person(name,age);
     }
 }
        

 function Father(name,age,height,weight) {
     this.name = name;
     this.age = age;
     this.height = height;
     this.weight = weight;
 }
 function Son(name,age,height,weight) {
 	 //通过call调用Father的this可为Son生成相同属性
     Father.call(this,"huzhixin",19,170,130);
 }
 var father = new Father();
 var son = new Son()
 

 function Super(){};
 Super.prototype.name = "abc";
 Super.prototype.age = 20;
 function Sub(){}
 //利用Object.create()方法将Super.prototype对象设置为Sub的原型对象，从而继承Super的属性和方法
 Sub.prototype = Object.create(Super.prototype);
 //将Sub的constructor设置为Sub
 Sub.prototype.constructor = Sub;
 var sub = new Sub();
 

 function M1(){
     this.hello = "hello";
 }
 function M2(){
     this.world = "world";
 }
 function Mine(){
 	 //调用call同时继承M1和M2的属性
     M1.call(this);
     M2.call(this);
 }
 var mine = new Mine();
 //将M1.prototype设置为Mine的原型对象
 Mine.prototype = Object.create(M1.prototype);
 //合并Mine和M2的prototype
 Object.assign(Mine.prototype,M2.prototype);
 Mine.prototype.constructor = Mine;
 console.log(mine);
 console.log(Mine.prototype.constructor)