apply、call 、bind有什么作用，什么区别
call方法使用給定的this参数以及分別給定的参数來调用某个函数，语法如下
fun.call(thisArg[, arg1[, arg2[, ...]]])
//thisArg为fun运行时指定的this值
//arg1，arg2为函数参数
示例用法
window.color = 'red'
let obj = {color: 'blue'}
function sayColor() {
console.log(this.color)
}
sayColor() // red，在全局中调用，this指向window
sayColor.call(obj) // blue，call指定了this为obj
var array = [1,3,7,10]
Math.max.call(null,1,3,7,10) //10,借用Math.max()方法
apply与call的功能是一样的，区别在于call方法接受的是若干个参数的列表，而apply方法接受的是一个包含多个参数的数组
var array = [1,3,7,10]
Math.max.apply(null,array) //10,借用Math.max()方法
bind函数会创建一个新函数（称为绑定函数），新函数与被调函数（绑定函数的目标函数）具有相同的函数体（在 ECMAScript 5 规范中内置的call属性）。当目标函数被调用时 this 值绑定到 bind() 的第一个参数，该参数不能被重写。绑定函数被调用时，bind() 也接受预设的参数提供给原函数
window.color = 'red'
let obj = {color: 'blue'}
function sayColor() {
console.log(this.color)
}
let sayColor1 = sayColor.bind(obj)
sayColor() //red
sayColor1() //blue
以下代码输出什么?
var john = {
firstName: "John"
}
function func() {
alert(this.firstName + ": hi!")
}
john.sayHi = func //john对象上添加属性sayHi，指向func这个函数
john.sayHi() //'John: hi!'
//john对象中的sayHi方法中的this指向john
下面代码输出什么？为什么？
func() //window；
function func() { //全局作用域中this指向window
alert(this)
}
下面代码输出什么？
document.addEventListener('click', function(e){
console.log(this); //document
setTimeout(function(){
console.log(this); //window
}, 200);
}, false);
//事件中的this指向发生事件的目标元素
//setTimeout和setIntval调用的函数中的this都指向window
下面代码输出什么？为什么？
var john = {
firstName: "John"
}
function func() {
alert( this.firstName )
}
func.call(john) //'John'
//通过call方法调用的函数改变了其this的指向，指向call中传递的context
//这个例子中context为john，于是func中的this就指向join
以下代码有什么问题，如何修改
var module= {
bind: function(){
$btn.on('click', function(){
console.log(this) //this指什么
this.showMsg();
})
},
showMsg: function(){
console.log('饥人谷');
}
}
//例中的this指向$btn，事件中的this指向发生事件的目标事件
//因此this.showMsg()不存在，会报错
//修改
var module= {
bind: function(){
let _this = this //保存最初的this
$btn.on('click', function(){
console.log(_this)
_this.showMsg();
})
},
showMsg: function(){
console.log('饥人谷');
}
}
有如下代码，解释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();
Person是一个构造函数，p是通过new Person建造的Person的实例
每一个构造函数都会有一个prototype，是这个函数的原型对象
prototype中默认都会有一个constructor属性，指向这一个构造函数
在本例中，Person的prototype有constructor，指向Person，还有一个sayName方法
p是Person通过new创建的实例，其中有一个__proto__这么个属性，这个属性指向了构造函数的prototype，本例中指向了Person的prototype
上例中，对象 p可以这样调用 p.toString()。toString是哪里来的? 画出原型图?并解释什么是原型链。
toString是继承而来，详见下图
p调用toString方法，先从它本身开始寻找，没有找到，便向上来到Person.prototype中寻找，也没有找到。
因为prototype本身是个对象，一切对象都是Object的实例，prototype也不例外，因此prototype中也有__proto__这么属性，指向了Object的原型对象。
因此当在寻找toString方法时，在Person.prototype中没有找到，就会进入Object.prototype中寻找，最终找到该方法，调用之。
这样一层层关系相互链接，层层关系递进，构成了实例与原型的链条，称为原型链
对String做扩展，实现如下方式获取字符串中频率最高的字符
var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d , 因为d 出现了5次
String.prototype.getMostOften = function {
let strArray = this.split('')
let obj = {}
let a = 0
let maxKey
strArray.forEach((item,index) => {
if(obj[item]){
obj[item]++
} else {
obj[item] = 1
}
})
for(let key in obj) {
if(obj[key] > a) {
a = obj[key]
maxKey = key
}
}
return maxKey
}
instanceOf有什么作用？内部逻辑是如何实现的？
object instanceof constructor
instanceof运算符用来测试一个对象(object)的原型链上是否有某个构造函数(constructor)的原型(prototype)
如上面的Person例子
p instanceOf Person //true
//p.__proto__ === Person.prototype，因此返回true
p instanceOf Object //true
//p.__proto__.proto__ === Object.prototye，因此返回true
其内部逻辑是，看看检测对象上是否有指定的构造函数的原型，有则返回true，反之为false。
instanceOf运算符会一直寻找到原型链的尽头
继承有什么作用?
在ECMAScript中，原型链作为实现继承的主要方法
为什么要继承？继承可以让一个对象得以使用另一对象的属性和方法，而不用重新创建，达到重用的目的
这里示例一个使用原型链实现继承的基本例子
function Person(name) {
this.name = name
}
Person.prototypr.sayName = function () {
alert(this.name)
}
function Male(name,age) {
//继承Person的属性
Person.call(this,name)
this.age = age
}
//怎么样才能让Male的实例拥有Person的sayName方法呢
Male.prototype = new Person()
let male1 = new Male()
下面两种写法有什么区别?
//方法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，每次new一个对象时，printName方法都会创建一次，new100次，创建100次printName方法
对于方法2，printNmae方法放在了Person的原型对象中，由于Person实例中的__proto__会指向Person的原型对象,这样所有的实例都可以访问到printName方法，printName只创建了一次
Object.create 有什么作用？兼容性如何
Object.create可以改变一个对象指向的原型
其接受两个参数，1.用作新对象原型的对象，2.（可选的）一个为新对象定义额外属性的对象
let person = {
name: 'Jack',
age: 20
}
let obj = Object.create(person)
obj.__proto__=== person // true
Object.create是ES5新方法，支持ES5的引擎都能使用该方法
hasOwnProperty有什么作用？如何使用？
hasOwnProperty可以判断一个属性或者方法是本身具有还是通过原型链继承而来
hasOwnProperty只在属性存在于实例中时才返回true
//语法
Object.hasOwnProperty(attributeName)
如下代码中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起到继承属性的作用
call可以改变函数中this为指定的值
当new Male时，Male中的this指向创建的对象，call把Person中的this设置为创建的对象，达到继承Person属性的目的
补全代码，实现继承
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.getName();
function Person(name, sex){
this.name = name
this.sex = sex
}
Person.prototype.getName = function(){
alert(this.name)
};
function Male(name, sex, age){
Person.call(this,name,sex)
this.age = age
}
Male.prototype = Object.create(Person.prototype)
Male.prototype.getAge = function(){
alert(this.age)
};
var ruoyu = new Male('若愚', '男', 27);
ruoyu.getName();
