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()