高级2

问题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是哪里来的? 画出原型图?并解释什么是原型链。

toString.png
原型图.png
因为任何类的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

兼容性.png

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