apply、call 、bind有什么作用，什么区别

• fn.apply( obj，[])
  将fn函数里的this指向改为obj，然后后面的数组当成参数传入函数
• fn.apply( obj， arr1, arr2, ...)
  将fn函数里的this指向改为obj，后面的的arr1，arr2为传入函数的参数，与apply的区别为，apply传入的是数组，call传入的只是几个参数
• fn().bind( obj )
  将fn函数里的this指向改为obj

以下代码输出什么?

var john = { 
  firstName: "John" 
}
function func() { 
  alert(this.firstName + ": hi!")
}
john.sayHi = func
john.sayHi()
输出: John: hi!
因为函数func赋给sayHi,所以tihis指向的是john

下面代码输出什么，为什么

func() 
function func() { 
  alert(this)
}
因为this指向的window

下面代码输出什么

document.addEventListener('click', function(e){
    console.log(this);
    setTimeout(function(){
        console.log(this);
    }, 200);
}, false);
输出 document   window
因为会先输出第一个this,第一个this指向document, 然后是setTimeout, 这个this指向的window

下面代码输出什么，why

var john = { 
  firstName: "John" 
}

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

输出John   因为 func.call(john) 是执行func函数,将this指向的john 所以函数的this.firstName 是 john.firstName,所以输出John

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

var module= {
  bind: function(){
    $btn.on('click', function(){
      console.log(this) //this指什么
      this.showMsg();
    })
  },
  
  showMsg: function(){
    console.log('饥人谷');
  }
}
第一个this是指$btn,$btn没有this.showMsg()方法

修改为:
var module= {
  bind: function(){
    $btn.on('click', function(){
      console.log(this) //this指什么
      this.showMsg();
    }).bind(this)
  },
  
  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 是构造函数  Person.prototype指向 prototype   Person是prototype的constructor    p是Person的实例     p.__proto__ 指向 prototype    p.sayName()会首先查找自身有这个方法没.没有会找p,__proto__指向的prototype 是否有这个方法  p.__proto__ == Person.prototype

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

QQ图片20170702230159.png

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

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

var str = 'ahbbccdeddddfg';
String.prototype.getMostOften = function () {
  var strArray = {};
  var maxString = "";
  var maxIndex = 0;
  
  for (let i = 0; i < this.length; i++) {
    
     if (!strArray[this[i]]) {
       strArray[this[i]] = 1;
     } else {
       strArray[this[i]]++;
     }
  }
  
  for (var key in strArray) {
    if (maxIndex < strArray[key]) {
      maxIndex = strArray[key];
      maxString = key;
    }
  }
  
  return maxString;
};

var ch = str.getMostOften();

console.log(ch); //d , 因为d 出现了5次

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

• instanceof运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。即判断是不是一个对象的实例，是返回 true，不是返回false。

var arr = [1，2，3]，
    obj = {name:'xuguojun'};

arr instanceof Array     //true
    //内部逻辑为看实例的 __proto__ 是否等于构造函数的 prototype 。    
arr.__proto__ === Array.prototype //true
    //如果为 true ，则返回结果 true

arr instanceof Object     //true
    //内部逻辑为看实例的 __proto__ 是否为构造函数的 prototype 原型   
arr.__proto__ === Object.prototype //false
    //如果为 false ，则继续看下一层的 __proto__
arr.__proto__.__proto__ === Object.prototype //true
    //如果为 true ，则返回结果 true

obj instanceof Array     //false
    //内部逻辑为看实例的 __proto__ 是否为构造函数的 prototype 原型
obj.__proto__ === Array.prototype //false
    //如果为 false ，则继续看下一层的 __proto__
obj.__proto__.__proto__ === Array.prototype //false
    //如果到最深一层的 __proto__ （最深一层为null）比较还是不相等，则返回 false

继承有什么作用?

• 继承是指一个对象直接使用另一对象的属性和方法。

• 作用：继承划分了类的层次性，父类代表的是更一般、更泛化的类，而子类则是更为具体、更为细化；继承是实现代码重用、扩展软件功能的重要手段，子类中与父类完全相同的属性和方法不必重写，只需写出新增或改写的内容，这就是说子类可以复用父类的内容，不必一切从零开始。

下面两种写法有什么区别?

//方法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);
方法一把属性和方法都放在类里面，当new的时候就赋予一次全部的属性和方法，比较占内存，而方法二把部分写在原型里，让对象继承，节省内存

Object.create 有什么作用？兼容性如何？

• 作用：使用指定的原型对象和其属性创建一个子对象
  方法：Son.prototype = object.create( Father.prototype );
  Son.prototype.constructor = Son
  不支持ie8以下浏览器

hasOwnProperty有什么作用？ 如何使用？

• hasOwnProperty() 方法会返回一个布尔值，指示对象是否具有指定的属性作为自身（不继承）属性。

o = new Object();
o.prop = 'exists';

function changeO() {
  o.newprop = o.prop;
  delete o.prop;
}

o.hasOwnProperty('prop');   // 返回 true
changeO();
o.hasOwnProperty('prop');   // 返回 false

如下代码中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;
}
Male继承Person的属性

补全代码，实现继承

function Person(name, sex){
    this.name = name;
    this.sex = sex;
}

Person.prototype.getName = function(){
    return this.name;
};    

function Male(name, sex, age){
    // 继承父类的属性
   Person.call(this, name, sex);
  /*
   或者
   (
   Person.bind(this)(name, sex)
   )
  */
   this.age = age;
}

// 继承父类的prototype
Male.prototype = Object.create(Person.prototype);
Male.prototype.constructor = Male;

/*
或者
(
// 继承父类的prototype
function parent() {};
parent.prototype = Person.prototype;
Male.prototype = new parent();
Male.prototype.constructor = Male;
)
*/

Male.prototype.getAge = function(){
    return this.age;
};

Male.prototype.printName = function () {
  console.log(this.getName());
};
var ruoyu = new Male('若愚', '男', 27);
ruoyu.printName();