继承

继承是什么？

在面向对象的思想中，广义的继承是子对象拥有父对象的一切方法与属性。而JavaScript有着更特殊的原型继承。
上次我们已经介绍了JavaScript中独有的原型及其原型链这一概念，JS的原型继承正式基于这两者而实现的。那么什么是原型继承呢？子对象能够使用父原型对象中的一切方法属性却不占用自己的内存空间。一句话解释：我是公共资源，能用却不被拥有。

例如：学校需要录入学校一年级男生的信息，样本个例的差异仅仅是姓名，所以仅需为每个新对象添加一个姓名的属性即可。但此时，粗心的管理员把这份信息表和女生的弄混了，然而每个对象并没有性别这个属性，如何做到呢？

function Person(name){
  this.name = name;
}
Person.prototype.gender = "male";
Person.prototype.selfSay = function(){console.log("my name is " + this.name;)}
var p1 = new Person("xiaoming");
var p2 = new Person("xiaohua");

原型图

我们创建了构造函数Person，只有一个属性name。显然，通过Person new出来的对象p1,p2都会拥有name属性。我们额外的为Person.prototype这个原型对象，设置了gender:male,以及方法selfSay。p1,p2本身并不具备gender属性和selfSay方法，却能调用它：

p1.gender;   //male
p2.selfSay(); // my name is xiaohua

这种继承方式最大的好处就是，设置公共资源，减少内存空间的占用。

有几种常见创建对象的方式? 举例说明?

• 直接创建

var xiaoming = {
     name:"xiaoming", 
     age:18,
     gender:"male"
};
var xiaomei = {
     name:"xiaomei",
     age:18,
     gender:"female"
} 

• 构造函数

function Person(name,age,gender){
     this.name=name;
     this.age=age;
     this.gender = gender;
}
var xiaoming = new Person("xiaoming",18,"male");
var xiaomei = new Person("xiaomei",18,"female");

• 工厂模式

function factory(name,age,gender){
    var obj=new Object();
    obj.name=name;
    obj.age=age;
    obj.gender=gender;
    return obj;
}
var xiaoming = factory("xiaoming",18,male);
var xiaomei = factory("xiaomei",18,female);

• 原型

function Person(name,gender){
    this.name = name;
    this.gender = gender;
}
Person.prototype.age = 18;
var xiaoming = new Person("xiaoming","male");
var xiaomei = new Person("xiaomei","female");

下面两种写法有什么区别?

//方法1
function People(name, sex){
    this.name = name;
    this.sex = sex;
    this.printName = function(){
        console.log(this.name);
    }
}
var p1 = new People('饥人谷', 2)

//方法2
function Person(name, sex){
    this.name = name;
    this.sex = sex;
}

Person.prototype.printName = function(){
    console.log(this.name);
}
var p1 = new Person('若愚', 27);

两种方法的p1对象均能使用，区别在于PrintName这个方法存放在哪。方法一中，每个新创建的子对象都拥有方法PrintName，而方法法二中子对象是不存储PrintName方法的，而是通过原型链调用该方法。

Object.create有什么作用？兼容性如何？如何使用？

Object.create(proto [, propertiesObject ])方法创建一个拥有指定原型和若干个指定属性的对象。它是ES5的新方法（IE9以上支持）。

• 第一个参数为必选项，作为被拷贝的对象原型。
• 第二个参数为可选项，是新对象的属性描述符，格式如下：
  数据属性
  writable:是否可任意写
  configurable：是否能够删除，是否能够被修改
  enumerable：是否能用 for in 枚举
  value：值
  访问属性：
  get(): 访问
  set(): 设置

例：

var obj = {
    a:function(){
        console.log("I am a.")
    },
    b:function(){
        console.log("I am b.")
    }
}
var newObj = Object.create(obj,{
    c:{ 
        value:"CCCC",
        writable:true
    },
    d:{
        configurable: false,
        get: function() { return d; },
        set: function(value) { d=value }
    }
});

console.log(newObj.a());   //I am a.
console.log(newObj.c);     // CCCC
newObj.c = "DDDDD"         
console.log(newObj.c);     //DDDDD
newObj.d = 100;
console.log(newObj.d);     //100

hasOwnProperty有什么作用？ 如何使用？

判断一个属性是否为该对象的自身属性，如：

function People(name){
    this.name = name;
}
var xiaoming = new People("xiaoming");
xiaoming.age = 18;
xiaoming.hasOwnProperty("name");  //false
xiaoming.hasOwnProperty("age")    //true

实现Object.create的 polyfill(基于hasOwnProperty)

直接贴的MDN文档，我按自己的意思来理解一下：

//当没有这种方法时，创建该方法。
if(!Object.create){                                
    Object.create = (function(){
//准备工作：1.建立一个临时的空对象 ；2.提取hasOwnProperty方法 
        function Temp(){};                               
        var hasOwn = Object.prototype.hasOwnProperty;   
        return function(o){
//先判断传进来的参数是否是一个单纯的对象，例如函数就不是，所以函数应当传递Function.prototype;
            if(typeof o != "object"){
                throw TypeError("Object prototype may only be an Object or null");
            }
//让临时对象的prototype指向传入参数o这个原型对象，用Temp构造出对象obj，显然obj此时没有自有属性。
            Temp.prototype = o;
            var obj = new Temp();
            Temp.prototype = null;
//我们知道Object.create()是可以传入两个参数的，这里这种写法不禁止你传入多个参数，但是至多只有
//两个有效参数，当传入两个或两个以上参数时，只取第二个参数。按照Object.create()原格式，第二个
//参数应该是一个对象，对象里有各种属性，所以在此遍历所有属性，并将其赋予obj；至此，obj已经完全
//复制了o对象，return即可；
            if(arguments.length > 1){
                var Properties = Object(arguments[1]);
                for (var prop in Properties){
                    if(hasOwn.call(Properties,prop)){
                        obj[prop] = Properties[prop];
                    }
                }
            }
            return obj;
        }
    })();
}

如下代码中call的作用是什么?

function Person(name, sex){
    this.name = name;
    this.sex = sex;
}
function Male(name, sex, age){
    Person.call(this, name, sex);    //调用Person函数，同时将作用域由window变为this（调用Male函数的对象）
    this.age = age;
}

补全代码，实现继承

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

Person.prototype.getName = function(){
    console.log(this.name);
};    

function Male(name, sex, age){
    Person.call(this,name,sex)
    this.age = age;
}
var obj = Object.create(Person.prototype);
Male.prototype = obj;
obj.constructor = Male;  
Male.prototype.getAge = function(){
    console.log(this.age);
};

var ruoyu = new Male('若愚', '男', 27);
ruoyu.getName();