js继承

问题1： apply、call 、bind有什么作用，什么区别

apply/call/bind

问题2： 以下代码输出什么?

var john = { 
  firstName: "John" 
}
function func() { 
  alert(this.firstName + ": hi!")
}
john.sayHi = func
john.sayHi()//John:hi!

问题3： 下面代码输出什么，为什么

func() 
function func() { 
  alert(this)//[object Window]
}

可以这么理解：在func函数里没有找到this，所以往全局函数找，于是this就是window，也可以这么理解func.call(null)，于是乎this就是window了，还可以这么理解：它就是一个简单的函数调用，此时的this就是window了...

问题4：下面代码输出什么

document.addEventListener('click', function(e){
    console.log(this);//document,这个属于方法调用模式，this指向事件源DOM对象，可以这么理解：obj1.fn.apply(obj1);

    setTimeout(function(){
        console.log(this);//window，这个属于把函数赋值之后调用的回调函数，this指向window,可以这么理解：f1.call(null,f2)
    }, 200);
}, false);

问题5：下面代码输出什么，why

var john = { 
  firstName: "John" 
}

function func() { 
  alert( this.firstName )
}
func.call(john)//john

因为func将this绑定为john这个对象了，因此this.firstName => john.firstName

问题6： 以下代码有什么问题，如何修改

var module= {
  bind: function(){
    $btn.on('click', function(){
      console.log(this) //this指$btn
      this.showMsg();
    })
  },
  
  showMsg: function(){
    console.log('饥人谷');
  }
}

this.showMsg()这个this指的是$btn，而$btn没有showMsg()这个方法，可以在函数后面bind(module),也可以将this.showMsg()改为module.showMsg.call(module)，也可以将module的this保存起来为that，最后用that.showMsg()去执行

问题7：有如下代码，解释Person、 prototype、__proto__、p、constructor之间的关联

function Person(name){
    this.name = name;
}
Person.prototype.sayName = function(){
    console.log('My name is :' + this.name);
}
var p = new Person("若愚")
p.sayName();

每个构造函数有一个prototype属性，指向一个对象，被称为原型对象，原型对象有一个构造器constructor指向该构造函数，每个对象都有一个__proto__属性，指向创建该对象的构造函数的原型对象。
因此有以下关联：

p.__proto__ == Person.prototype
Person.prototype.constructor == Person
p.constructor == Person//从原型链上查找

问题8： 上例中，对对象 p可以这样调用 p.toString()。toString是哪里来的? 画出原型图?并解释什么是原型链。

画图太麻烦了，还是用代码代替吧...

//首先会查找自身有没有toString()这个方法
//然后根据__proto__一级一级的向上查找，直到找到Object.prototype，如果还是没找到就返回null，期间找到了就调用那个方法
p.__proto__ == Person.prototype//找到父元素的原型对象，没有这个方法，于是继续查找
p.__proto__.__proto__ == Object.prototype//找到了Object对象的原型对象
p.__proto__.__proto__.toString()== Object.prototype.toString()
//最后在Object.prototype中找到了toString()这个方法，所以此时就可以调用toString这个方法了

原型链：由于原型对象本身也是对象，而每个javascript对象都有一个原型对象，每个对象都有一个隐藏的__proto__属性，原型对象也有自己的原型，而它自己的原型对象又可以有自己的原型，这样就组成了一条链，这个就是原型链。在访问对象的属性时，如果在对象本身中没有找到，则会去原型链中查找，如果找到，直接返回值，如果整个链都遍历且没有找到属性，则返回undefined。原型链一般实现为一个链表，这样就可以按照一定的顺序来查找。

上面的p.toString()这个方法的查找就是一个很明显的原型链的例子

问题9：对String做扩展，实现如下方式获取字符串中频率最高的字符

String.prototype.getMostOften = function(){
    var arr = this.split('')
    var results = {}
    var max = 0
    var result
    for(var i=0;i max){
            max = results[j]
            result = j
        }
    }
    return result
}
var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d , 因为d 出现了5次

问题10： instanceOf有什么作用？内部逻辑是如何实现的？

instanceof 运算符与 typeof 运算符相似，用于识别正在处理的对象的类型。与 typeof 方法不同的是，instanceof 方法要求开发者明确地确认对象为某特定类型

A instanceof B的判断规则是：沿着A的__proto__这条线来找，同时沿着B的prototype这条线来找，如果两条线能找到同一个引用，即同一个对象，那么就返回true。如果找到终点还未重合，则返回false

因此：

Object instanceof Object
Object instanceof Function
Function instanceof Object
Function instanceof Function 

function io(arr,fn){
    if(arr.__proto__){
        if(arr.__proto__ === fn.prototype){
            return true
        }else{
            return io(arr.__proto__,fn)
        }  
    }else{
        return false
    }
}

var arr = []
console.log(io(arr,Array))
console.log(io(arr,Object))
console.log(io(arr,String))

问题11：继承有什么作用?

继承机制使得不同的实例可以共享构造函数的原型对象的属性和方法，提高了代码的复用性

问题12： 下面两种写法有什么区别?

//方法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);

同样是printName方法，一个直接写在构造函数内部的实例对象上，另一个部写在构造函数的prototype对象上，前者在每生成一个实例之后实例的printName就占用内存，而后者每生成一个实例后会共享构造函数prototype对象上的printName方法，以达到节省内存的效果，因此公共方法写在原型对象上更好。

问题13： Object.create 有什么作用？兼容性如何？

Object.create() 方法会使用指定的原型对象及其属性去创建一个新的对象，
各大浏览器的最新版本（包括IE9）都部署了这个方法，可以写一个polyfill解决低版本浏览器问题

if(!Object.create){
    Object.create = function(obj){
          function F(){};
          F.prototype = obj;
          return new F();
  }
}

问题14： hasOwnProperty有什么作用？ 如何使用？

对象实例的hasOwnProperty方法返回一个布尔值，用于判断某个属性定义在对象自身，还是定义在原型链上

//这样写可以排除原型链上的属性
var obj = {}
for(var i in obj){
    if(Object.hasOwnProperty(obj[i])){
        // 继续执行
    }
}    

问题15：如下代码中call的作用是什么?

function Person(name, sex){
    this.name = name;
    this.sex = sex;
}
function Male(name, sex, age){
    Person.call(this, name, sex); //this指的实例，将Person在这里执行了一遍，实例就有了Person的属性
    //借用Person函数的属性，使Male函数能够执行Person上的初始化代码，实现构造函数属性继承
    this.age = age;
}

问题16： 补全代码，实现继承

//寄生组合继承:
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
}

// 方法在这继承
Male.prototype = Object.create(Person.prototype)
Male.prototype.constructor = Male;//constructor将constructor复原
Male.prototype.getAge = function(){
    console.log(this.age)
};

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

讲讲Function和Object的关系

对象是函数创建的，而函数却又是一种对象,每个函数function都有一个prototype,每个对象都有一个__proto__，它指向创建该对象的函数的prototype,Object.prototype却是一个特例——它的__proto__指向的是null，因此Object.prototype.__proto__ === null.

函数也是一种对象，函数也有__proto__吗？当然有，函数也不是从石头缝里蹦出来的，函数也是被创建出来的。谁创建了函数呢？——Function，对象的__proto__指向的是创建它的函数的prototype，因此：Object.__proto__ === Function.prototype

所有函数的__proto__都指向Function.prototype，包括Object这个所有对象的祖宗，Object.__proto__指向Function.prototype，唉，怎么还有一个……Function.proto指向Function.prototype？这不成了循环引用了？对！是一个环形结构。

其实稍微想一下就明白了。Function也是一个函数，函数是一种对象，也有__proto__属性。既然是函数，那么它一定是被Function创建。所以Function是被自身创建的。所以它的__proto__指向了自身的Prototype，因此：Function.__proto__ === Function.prototype

Function是每个函数的祖宗，Object是每个对象的祖宗，每个函数的__proto__都指向Function.prototype，每一个对象包括原型对象都指向Object.prototype，那么Function.prototype指向的对象，它的__proto__是不是也指向Object.prototype？答案是肯定的。因为Function.prototype指向的对象也是一个普通的被Object创建的对象
因此：Function.prototype.__proto__ === Object.prototype

最后再三强调一下：每个对象都有一个__proto__属性，指向创建该对象的构造函数的原型对象,因为每个函数都是由Function创造的，因此所有函数的__proto__都指向Function.prototype，因为所有对象都是由Object创造的，因此所有对象的__proto__都指向Object.prototype，如果理解了下面的等式就理解了这句话:

Object.__proto__ === Function.prototype
Function.prototype.__proto__ === Object.prototype

当然Function和Object有一些特殊，所有函数的__proto__都指向Function.prototype，那么它自己呢，同样如此；所有对象都是由Object创造的，因此所有对象的__proto__都指向Object.prototype，那么它自己呢，此时它却指向null！！！记住下面两个代码：

Function.__proto__ === Function.prototype
Object.prototype.__proto__ === null