问答
1.继承有什么作用？
继承是指一个对象可以使用另一个对象的属性和方法。JavaScript中由于没有类（ES6之前）这一概念，所以没有原生的继承方式，而是通过原型链来实现继承。
2.有几种常见创建对象的方式？举例说明？
- 原始构造，直接使用字面量来创建对象：
var person1 = {
name : "xiaoming"，
age : 25,
sayName : function(){
console.log("xiaoming")
}
};
var person2 = {
name : "xiaohong",
age : 23,
sayName : function(){
console.log("xiaohong")
}
}
这种方法有2个问题：一是每创建一个对象都要重复写一遍代码，太浪费资源，二是两个实例对象之间看不出有什么关系。
- 工厂模式：
function Person(name,age){
var obj = {
name : name,
age : age,
sayName = function(){
console.log(this.name);
}
}
return obj;
};
var person1 = Person("xiaoming",25);
var person2 = Person("xiaohong",23);
这种方法是通过函数来实现自动创建对象的过程，虽然解决了重复代码的问题，但是构造出来的对象类型都是object,无法区分。
- 构造函数模式：
function Person(name,age){
this.name = name;
this.age = age;
this.sayName = function(){
console.log(this.name);
}
};
var person1 = new Person("xiaoming",25);
var person2 = new Person("xiaohong",23);
console.log(person1 instanceof Person );//true
console.log(person2 instanceof Object);//true
对构造函数使用new运算符，就能生成实例，函数中的this就会指向实例。并且还提供了instanceof运算符来验证原型对象和实例对象的关系。但是构造函数中会有些内容相同的属性和方法，每生成一个实例都会重复一次，造成内存的浪费。
- 原型模式：
function Person(name,age){
this.name = name;
this.age = age;
};
Person.prototype.sayName = function(){
console.log(this.name);
};
var person1 = new Person("xiaoming",25);
var person2 = new Person("xiaohong",23);
每个构造函数都有一个prototype属性，指向一个对象，我们可以把那些不变的属性和方法，直接定义在prototype对象上，这样就提高了运行效率，这也是推荐的创建对象的方式。
3.下面两种写法有什么区别？
//方法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);
方法一是就是问答2中的构造函数模式，它创建的每个实例都会拥有自己的printName方法。方法二是问答2中的原型模式，它创建的每个实例中的printName方法是来自于People.prototype对象上。方法二更加节省内存，更有效率。
4.Object.create有什么作用？兼容性如何？如何使用？
- 作用：在之前的一篇文章对象、原型中解释了隐式原型
_proto_的指向问题。我们说，在JS中，一个对象的__proto__指向构造该对象的函数的prototype。
而对象实质上都是通过new操作符来创建的。但是在ES5中，新增了一种创建对方的方法，叫做Object.create(),而这个方法创建出来的对象的__proto__是指向该方法的第一个参数对象，实际上，这个方法在ES5之前被称为"原型式继承"：
道格拉斯·克罗克福德在2006年写了一篇文章，题为Prototype Inheritance in JavaScript（JavaScript中的原型继承）。在这篇文章中，他介绍了一种实现继承的方法，这种方法并没有使用严格意义上的构造函数。他的想法是借助原型可以基于已有的对象创建新对象，同时还不必因此创建自定义类型。为了达到这个目的，他给出了如下函数：
function object(o){
function F(){}
F.prototype =o;
return new F()；
}
————《JavaScript高级程序设计（第三版） 》6.34节
看了代码后就知道，这个方法本质上还是利用了new操作符来创建一个实例对象。区别在于，object()对传入其中的参数对象o执行了一次浅复制，最后使创建出来的对象的__proto__指向o。具体过程可以用下面的伪代码来说明：
//假设在函数object的内部有一个对象f为临时构造函数F的实例
var f = new F();
//于是有
f.__proto__ === F.prototype;//true
//又因为
F.prototype === o; //true
//所以
f.__proto__ === o;//true
ES5吸收了“原型式继承”方法并作出扩展，把它规范为Object.create()。这个方法接受两个参数：第一个作为新创建对象的原型。第二个（可选）作为新创建对象定义的额外属性。
- 兼容性：Object.create()方法是从ES5引入的，在IE9之前不能使用，在IE9中的严格模式中不能使用，其余主流的PC端和移动端浏览器适用性良好。
- 使用：
在只传入一个参数的情况下，Object.create()与object()方法的行为相同，可用于构造函数的方法继承：
function People(name, age){
this.name = name;
this.age = age;
}
People.prototype = {
walk: function(){
console.log(this.name + ' is ' + 'walking...');
},
}
function Programmer(name, age, hobby){
People.call(this, name, age);
this.hobby = hobby;
}
Programmer.prototype = Object.create(People.prototype);
Programmer.prototype.constructor = Programmer;
var p = new Programmer('LightBuild', 25, 'drive')
p.walk()//LightBuild is walking...
若传入2个参数，则第二个参数的每个属性都是通过自己的描述符定义的。以这种方式指定的任何属性都会覆盖原型对象上的同名属性：
var person = {
name : "BuildLight",
age : 25,
}
var person1 = Object.create(person,{
name : {
value: "Harden"
}
})
console.log(person1.name);//“Harden”
5.hasOwnProperty有什么作用？如何使用？
6.实现Object.create的polyfill，如：（ps：写个函数create，实现Obejct.create的功能）
var obj = {a:1,b:2};
var obj2 = create(obj);
console.log(obj2.a);//1
只有1个参数：
function create(o){
function F(){}
F.prototype =o;
return new F()；
}
有2个参数（参考mdn）：
if (typeof Object.create != 'function') {
// Production steps of ECMA-262, Edition 5, 15.2.3.5
// Reference: http://es5.github.io/#x15.2.3.5
Object.create = (function() {
//为了节省内存，使用一个共享的构造器
function Temp() {}
// 使用 Object.prototype.hasOwnProperty 更安全的引用
var hasOwn = Object.prototype.hasOwnProperty;
return function (O) {
// 1. 如果 O 不是 Object 或 null，抛出一个 TypeError 异常。
if (typeof O != 'object') {
throw TypeError('Object prototype may only be an Object or null');
}
// 2. 使创建的一个新的对象为 obj ，就和通过
// new Object() 表达式创建一个新对象一样，
// Object是标准内置的构造器名
// 3. 设置 obj 的内部属性 [[Prototype]] 为 O。
Temp.prototype = O;
var obj = new Temp();
Temp.prototype = null; // 不要保持一个 O 的杂散引用（a stray reference）...
// 4. 如果存在参数 Properties ，而不是 undefined ，
// 那么就把参数的自身属性添加到 obj 上，就像调用
// 携带obj ，Properties两个参数的标准内置函数
// Object.defineProperties() 一样。
if (arguments.length > 1) {
// Object.defineProperties does ToObject on its first argument.
var Properties = Object(arguments[1]);
for (var prop in Properties) {
if (hasOwn.call(Properties, prop)) {
obj[prop] = Properties[prop];
}
}
}
// 5. 返回 obj
return obj;
};
})();
}
7.如下代码中的call的作用是什么？
function Person(name, sex){
this.name = name;
this.sex = sex;
}
function Male(name, sex, age){
Person.call(this, name, sex); //这里的 call 有什么作用
this.age = age;
}
让Person函数在Male函数的作用域下执行，实现Male函数继承Person函数的属性。
8.补全代码。实现继承
function Person(name, sex){
this.name = name;
this.sex = sex;
}
Person.prototype.getName = function(){
return this.name;
};
Person.prototype.printName = function(){
console.log(this.name);
};
function Male(name, sex, age){
Person.call(this,name,sex);
this.age = age;
};
function inherit(superType,subtype){
var _prototype = Object.create(superType.prototype);
subtype.prototype = _prototype;
_prototype.constructor = subtype;
};
inherit(Person,Male);
Male.prototype.getAge = function(){
return this.age;
};
var ruoyu = new Male('若愚', '男', 27);
ruoyu.printName();
