this 相关问题
问题1： apply、call 、bind有什么作用，什么区别？
apply,call,bind 都是Function.prototype的方法，都可以改变函数的执行上下文。
不同点：
function.apply( 第一个参数，[a,b,c,d]),第一个参数代表期望函数执行的上下文,后面的参数以数组形式传递。。。
利用第二点，即后面的参数，我们可以实现一个简单的用法，用Math对象的一些方法来直接处理数组，Math.max.apply(null,[1,2,3,4,5])call，用法基本与apply相同，只是传递参数的方式不一样。传递的参数要以列表形式。
bind ，首先会创建一个新的函数，然后第一个参数也是改变 函数的执行上下文，传递的参数也是以列表形式，但是，传递的参数，会优先实参传递。
function a(a,b,c){
console.log(a,b,c)
}
var b=a.bind(this,4,5)
b(1,2)// 结果打印 4，5，1
问题2： 以下代码输出什么?
var john = {
firstName: "John"
}
function func() {
alert(this.firstName + ": hi!")
}
john.sayHi = func
john.sayHi()
输出：John：hi!
john.sayHi() 相当于 john.sayHi.call(john)
即在john的上下文中 执行 函数，this，代表就是john这个对象。
问题3： 下面代码输出什么，为什么
func()
function func() {
alert(this)
}
[object,window]，因为func.call(undefined),所以，undefined在执行环境中代表window.
4.下面代码输出什么
document.addEventListener('click', function(e){
console.log(this);
setTimeout(function(){
console.log(this);
}, 200);
}, false);
#document
window对象
因为，事件监听的时候，this，指的绑定时间的元素节点。所以是document
setTimeout 这个this，代表的是window
问题5：下面代码输出什么，why
var john = {
firstName: "John"
}
function func() {
alert( this.firstName )
}
func.call(john)// 输出 John，因为 func的执行上下文变成了 john，this总是返回执行函数的对象。
问题6： 以下代码有什么问题，如何修改
var module= {
bind: function(){
// var that=this
$btn.on('click', function(){
console.log(this) //this指什么
this.showMsg();
//that.showMsg()
})//.bind(this)
},
showMsg: function(){
console.log('饥人谷');
}
}
两个this，都表示这个$btn对象。。
可以用一个变量来固定this。
也可以在函数后.bind(this)
原型链相关问题
问题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();
8.上例中，对对象 p可以这样调用 p.toString()。toString是哪里来的? 画出原型 图?并解释什么是原型链。
在 javaScript 中，每个对象都有一个指向它的原型（prototype）对象的内部链接，proto。这个原型对象又有自己的原型，直到找到最顶层的原型，Object.prototype。这种一级一级的链结构就称为原型链（prototype chain）。
9.问题9：对String做扩展，实现如下方式获取字符串中频率最高的字符
String.prototype.getMostOften = function(){
var obj = {};
for(var i=0,k;i<this.length;i++){
k = this[i];
if(obj[k]){
obj[k]++
}else{
obj[k] = 1
}
}
var max = 0,key;
for(var k in obj){
if(obj[k]>max){
max = obj[k];
key = k;
}
}
return key;
}
console.log(str.getMostOften())
//第二种
var str='ahbbccdeddddfg'
String.prototype.getMostOften=function(){
var str=this
var arr=[]
for(var i=0;i<this.length;i++){
var times=0
for(var j=0;j<str.length;j++){
if(this[i]===str[j]){
times++
}
}
arr.push(times)
}
return str[arr.indexOf(Math.max.apply(null,arr))]
}
console.log(str.getMostOften())
问题10： instanceOf有什么作用？内部逻辑是如何实现的？
a instanceof b,判断a是不是b的实例。
判断的逻辑是沿着 原型链走的，即，判断a 的proto属性有没有链接到b。
function instance(L,R){
var a=L.__proto__
var b=R.prototype
while(a){
if(a===b){
return true;
}else{
a=a.__proto__
}
}
return false
}//大致的代码实现，应该不是很严格，意思就是当 instanceof 左边的__proto__ 如果等于右边表达式的 prototype 时返回true ,如果不等于，就沿着 instanceof的原形链一直走，直到 与右边的prototype相等返回true，或者直到 遍历整个原形链都没有找到（最顶端的Object.prototype.__proto__为null)
继承相关问题
问题11：继承有什么作用?
最大的作用就是提高代码的复用性。
JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型，以及该对象的原型的原型，依此层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾。这就意味着，JS对象可以使用所有其原型的所有方法，如果我们在原型上添加新的方法，那么实例也会拥有该方法，能够大大减少冗余代码。
问题12： 下面两种写法有什么区别?
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的方法，比较占用内存，方法二：printName作为公共的方法，每次创建实例，只需要沿着原型链去这找就可以了。
问题13： Object.create 有什么作用？兼容性如何？
Object.create() 方法使用指定的原型对象和其属性创建了一个新的对象。
Object.create(proto, [ propertiesObject ])
proto：一个对象，作为新创建对象的原型。或者为null。
propertiesObject：可选。该参数对象是一组属性与值，该对象的属性名称将是新创建的对象的属性名称，值是属性描述符（这些属性描述符的结构与Object.defineProperties()的第二个参数一样）。注意：该参数对象不能是 undefined，另外只有该对象中自身拥有的可枚举的属性才有效，也就是说该对象的原型链上属性是无效的。
相当于
Object.create = function(prop){
function F(){}
F.prototype = prop
return new F;
}
hasOwnProperty有什么作用？ 如何使用？
判断一个属性或者方法是不是自身的。它是js中唯一，不会去遍历原型链的方法。
var a={nihao:'haha'}
a.hasOwnProperty('nihao')//true
a.hasOwnProperty('toString')//false
问题15：如下代码中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;
}
call的作用 让Person的执行上下文变为 Male，并将参数name, sex传递到 原函数的第一个参数及第二个参数上。所以，Male中有了this.name=name this.age
16 .补全代码，实现继承
function Person(name, sex){
this.name=name
this.sex=sex
}
Person.prototype.getName = function(){
console.log(this.name)
};
function Male(name, sex, age){
this.age=age
Person.call(this,name,age)
}
/*function copy(parent,son){
son.prototype=Object.create(parent.prototype)
son.prototype.constructor=son
}
copy(Person,Male)*/
function fn(){}
fn.prototype=Person.prototype
Male.prototype=new fn()
Male.prototype.constructor=Male
Male.prototype.getAge = function(){
console.log(this.age)
};
var ruoyu = new Male('若愚', '男', 27);
ruoyu.getName()
