高级2发表

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

答案1：

apply()和call()函数都可以 指定this值和参数值的情况下调用某个函数。
call()和apply()的作用一样，区别在于提供给原函数的参数的方式不一样
apply()函数只接受两个参数，提供给原函数的参数以数组或类数组对象的形式存在
而call()接收无限个参数， 第二个参数及其后面的参数就是提供给原函数的参数。

它们各自的定义：
apply：应用一对象的一个方法，用另一个对象替换当前对象。
call： 调用一对象的一个方法，用另一个对象替换当前对象。

它们的共同之处：
都“可以用来代替另一个对象调用一个方法，将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。

它们的不同之处：
apply和call功能一样，只是传入的参数列表形式不同：
如 func.call(func1,var1,var2,var3) 对应的apply写法为：func.apply(func1,[var1,var2,var3])
也就是说：call调用的为单个，apply调用的参数为数组

function sum(a,b){
  console.log(this === window);//true
  console.log(a + b);
}
sum(1,2);
sum.call(null,1,2);
sum.apply(null,[1,2]);

问题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是在全局作用域下被调用

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

document.addEventListener('click', function(e){
    console.log(this);
    setTimeout(function(){
        console.log(this);
    }, 200);
}, false);

//document
//window因为setTimerout也是一个函数调用。

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

var john = { 
  firstName: "John" 
}

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

//弹出John，因为使用call()传入的第一个参数是this的指针，可以看见调用func的时候改变了this的指向，指向的是john

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

var module= {
  bind: function(){
    $btn.on('click', function(){
      console.log(this) //this指向$btn
      this.showMsg();//问题出在这里$btn没有showMsg这个方法。所以应该放moudule调用这个方法
    })
  },
  
  showMsg: function(){
    console.log('饥人谷');
  }
}

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

原型链相关问题

问题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();

即p是Person的一个实例，
p的__proto__指向Person的prototype，
Person的prototype的__proto__指向对象的prototype，这里到达顶级，
另外constructor即构造函数person本身。

p._proto=Person.prototype;
p.constructor=Person;
Peroson.prototype.constructor=Person

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

Paste_Image.png

javaScript中的对象有指向其原型对象的内部链接，而原型对象又有自己的原型知道对象的原型为null。这种一级一级的链结构就称为原型链（prototype chain）。上述例子的原型链如下：p-->p.__ proto__-->Person,prototype：Person.prototype.__ proto__--->Object.prototype：Object.prototype.__ proto__=null。

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

var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d , 因为d 出现了5次

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

instanceof 是一个运算符。A instancrof B用于判断A 是否是B 的一个实例，或者是A是否是以B为父类型的一个实例。
在上面类Person创建实例p的这个例子中：

 p instanceof Person  //true
 Person instanceof Object  //true
 p instanceof Object   //true

instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。
instanceOf：判断一个对象是否为另一个对象的实例
其内部逻辑是测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。
所以如果表达式obj instanceof Foo 返回true，则并不意味着该表达式会永远返回true，因为Foo.prototype属性的值有可能会改变，改变之后的值很有可能不存在于obj的原型链上，这时原表达式的值就会成为false。

继承相关问题

问题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);

区别：方法1的printName方法是在函数Person实例对象里的，方法2是在Person的prototype对象上的。
当再创建一个Person实例对象的时候，方法1又将会再创建一个printName方法，占用新的内存，而方法2将一个公用的printName方法写在原型上，当对象要使用该方法只需到原型链里调用就可以了，达到节省内存的效果。

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

Object.create方法可以创建一个拥有指定原型和若干个指定属性的对象。
在继承中，Object.create可以用于继承属性。
Object.create是在ES5中规定的，其兼容性见下图：

Paste_Image.png

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

作用：判断一个对象是否包含自定义属性而不是原型链上的属性，是JavaScript中唯一一个处理属性但是不查找原型链的函数.
hasOwnProperty方法会返回一个布尔值，其用来判断某个对象是否含有特定的自身属性，该方法会忽略掉那些从原型链上继承到的属性。
语法为obj.hasOwnProperty(prop)，参数prop为要检测的属性
自身属性与继承属性

下面的例子演示了 hasOwnProperty 方法对待自身属性和继承属性的区别：

o = new Object();
o.prop = 'exists';
o.hasOwnProperty('prop');             // 返回 true
o.hasOwnProperty('toString');         // 返回 false
o.hasOwnProperty('hasOwnProperty');   // 返回 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的作用是改变构造函数People的作用域，这样就可以让People在Male的作用域中执行，这样People中的一些属性赋值语句也会在Male中执行。
通过这种方式就实现了属性的继承。
call()方法可以将传入的第一个参数设置为this对象。代码中在Male这个类下面执行另一个类Person可以把Person的属性 赋值到Male上，但是需要在执行的时候通过call来把环境改到自己的作用域下。

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

function Person(name, sex){
    // todo ...
}

Person.prototype.getName = function(){
    // todo ...
};    

function Male(name, sex, age){
   //todo ...
}

//todo ...
Male.prototype.getAge = function(){
    //todo ...
};

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