问题1： apply、call 、bind有什么作用，什么区别.
var value = 100;
var obj4 = {
value: 200
}
function fn4(a, b) {
console.log(this.value + a + b);
}
fn4(3,4); // 107
fn4.call(obj4, 3, 4) // 207
var f = fn4.bind(obj4); // this指代obj4里的this
f(3,4); // 207
fn4.apply(obj4, [3,4]) // 207
Function.prototype.bind
bind，返回一个新函数，并且使函数内部的this为传入的第一个参数。
使用call和apply设置this
fn.call(obj, param1,param2)
fn.apply(obj, paramArray);
第一个参数都是希望设置的this对象，不同之处在于call方法接受参数列表，而apply接受参数数组。
问题2： 以下代码输出什么?
var john = {
firstName: "John"
}
function func() {
alert(this.firstName + ": hi!")
}
john.sayHi = func
john.sayHi()
输出 John: hi!
相当于
var john = {
firstName: "John"
sayHi: function() {
alert(this.firstName + ": hi!")
}
}
john.sayHi() // 这里是john对象调用,那么this指代john对象
问题3： 下面代码输出什么，为什么
func()
function func() {
alert(this)
}
输出 window
在函数被直接调用时this绑定到全局对象。在浏览器中，window就是该全局对象
问题4：下面代码输出什么
document.addEventListener('click', function(e){
console.log(this); // #document // 指代绑定事件的对象即document
setTimeout(function(){
console.log(this); // window // 定时器里执行函数中的this指代全局对象
}, 200);
}, false);
问题5：下面代码输出什么，why
var john = {
firstName: "John"
}
function func() {
alert( this.firstName )
}
func.call(john) // John
因为调用call方法,那么this指代的就是传入的对象。
问题6： 以下代码有什么问题，如何修改
var module= {
bind: function(){
$btn.on('click', function(){
console.log(this) //this指什么
this.showMsg();
})
},
showMsg: function(){
console.log('饥人谷');
}
}
问题 this指代的是$btn 而不是module了，因此调用showMsg方法，这样是错误的.
修改
var module= {
bind: function(){
$btn.on('click', function(){
console.log(this) //this指什么
this.showMsg();
}.bind(this))
},
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();
当new一个函数的时候，首先会创建一个新对象p，其次会
执行这个函数，同时，函数里面的this就会指向这个新创建的对象，如果
对this进行赋值或者进行操作那么就是对这个对象进行赋值，操作。
当函数执行完之后，会把刚刚创建的对象给return出来。
把对象的proto指向了函数的prototype属性。
p1.proto.constructor === Person
Person.prototype.constructor === Person
p1.constructor === Person; // 它自己没有就会去原型里面找
问题8： 上例中，对对象 p可以这样调用 p.toString()。toString是哪里来的? 画出原型图?并解释什么是原型链。
因为任何类的prototype属性本质上都是个类Object的实列，所以prototype也和其他实列一样也有个proto内部属性，指向其类型Object的prototype。自己类型的prototype找不到的话，还会找prototype的类型的prototype属性。
下面再看这个列子,如图
p1下面没有toString()，那么向它的原型上找，即p1.proto ==== Person.prototype.
我们发现Person下也没有toString().再向它的原型上找 即Person.prototype.proto === Object.prototype
这个时候我们发现Object的prototype属性里有toString().
这就是原型链，如果还有找到的话，那么就返回undefined。
问题9：对String做扩展，实现如下方式获取字符串中频率最高的字符
var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d , 因为d 出现了5次
// 针对全是小写字母的情况
String.prototype.getMostOften = function() {
var arr = [];
var letterCount = 'z'.charCodeAt() - 'a'.charCodeAt();
for(var i = 0; i < letterCount; i++) {
arr[i] = 0;
}
for(var i = 0; i < this.length; i++) {
arr[this[i].charCodeAt()-'a'.charCodeAt()]++;
}
return Math.max.apply(null, arr);
}
var ch = str.getMostOften();
console.log(ch); // 5
问题10： instanceOf有什么作用？内部逻辑是如何实现的？
判断一个对象是不是某个类型的实列。
举列说明
[1,2,3] instanceof Array
[1,2,3] instanceof Object
[1,2,3].__proto__ === Array.prototype // ture
[1,2,3].__proto__.___proto__ === Object.prototype // true
a instanceof b
只要判断a的原型是否等于b的prototype属性。如果不相等，继续判断a的原型的原型是否等于
b的prototype属性，如果不相等，那么就继续找，直到，找到最后，没有找到能相等的，那么就返回false
继承相关问题
问题11：继承有什么作用?
1、得到一个类的属性
2、得到一个类的方法
问题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函数。而printName方法实际上作用的相同的，会浪费大量的内存
方法2 printName函数是共用的，这样避免了重复
问题13： Object.create 有什么作用？兼容性如何？
举列说明
var b = {};
a = Object.create(b);
a.__proto__ === b; // true; 即a的原型为b
es5
问题14： hasOwnProperty有什么作用？ 如何使用？
hasOwnPersonty是Object.prototype的一个方法,可以判断一个对象是否包含自定义属性而不是
原型链上的。
举列说明
function Person(name, age) {
this.name = name;
this.age = age;
}
Person.prototype = {
sayName: function() {
console.log("My name is " + this.name);
},
walk: function() {
console.log(this.name + ' is walking');
}
}
var p1 = new Person('tangyue', '20');
p1.hasOwnProperty('name') // ture
p1.hasOwnProperty('sayName') // 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;
}
作用: 将Person方法内部的this指向Male创建的实列对象。
问题16： 补全代码，实现继承
function Person(name, sex){
this.name = name;
this.sex = sex;
}
Person.prototype.getName = function(){
console.log(this.name);
};
function Male(name, sex, age){
Person.call(this, name, sex);
}
Male.prototype = Object.create(Person.prototype);
Male.prototype.getAge = function(){
console.log(this.age);
};
var ruoyu = new Male('若愚', '男', 27);
ruoyu.getName(); // 若愚
