this 、原型链 、继承

this 相关问题

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

• Function.prototype.call()
  可以指定该函数内部 this的指向（即函数执行时所在的作用域），然后在所指定的作用域中，调用该函数。并且会立即执行该函数。
• Function.prototype.apply()
  apply方法的作用与call方法类似，也是改变this指向（函数执行时所在的作用域），然后在指定的作用域中，调用该函数。同时也会立即执行该函数。唯一的区别就是，它接收一个数组作为函数执行时的参数。
• Function.prototype.bind()
  bind方法用于指定函数内部的this指向（执行时所在的作用域），然后返回一个新函数。bind方法并非立即执行一个函数。
  来源

以下代码输出什么?

var john = { 
  firstName: "John" 
}
function func() { 
  alert(this.firstName + ": hi!")
}
john.sayHi = func
john.sayHi()

//John: hi!

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

func() 
function func() { 
  alert(this)
}

//window 直接用，作用域是全局作用域

下面代码输出什么

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

下面代码输出什么，why

var john = { 
  firstName: "John" 
}

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

// John       将func的this指向john对象

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

var module= {
  bind: function(){
    var _this = this // 这里的this指调用这个方法的对象 存在_this里
    $btn.on('click', function(){
//      console.log(this) // this指被点击的$btn
//      this.showMsg(); //$btn没有这个方法       
        _this.showMsg() // 现在可以使用showMsg()了

    })
  },
  
  showMsg: function(){
    console.log('饥人谷');
  }
}
module.bind()

原型链相关问题

有如下代码，解释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.__proto__ === Function.prototype
   Person.prototype.__proto__ === Object.prototype
   p.__proto__ === Person.prototype
   Person.prototype.constructor === Person

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

原型图.png

JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型，以及该对象的原型的原型，依此层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾。

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

String.prototype.getMostOften = function(){
   var arr = this.split('')
   var counts = {}  
   var max = 0
   var maxkey = 0
   arr.forEach(function(val){
         if(!counts[val]){ counts[val] = 1; }
         else{ counts[val]++ }
   })
   for( val in counts){
      if(counts[val] > max){ 
          max = counts[val]
          maxkey = val   
      }      
   }
return maxkey
}

var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d 

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

instanceof判断一个对象是否是某个构造函数的实例

如：object instanceof constructor
检测 constructor.prototype 是否存在于参数 object 的原型链上

function People(){}
var john = new People()
john instanceOf People //true

//john.__proto__ === People.prototype

继承相关问题

继承有什么作用?

把公用的方法属性放在父类，子类就不需要单独再写，可以通过继承使用。子类还可以单独添加自己的方法和属性，不会影响到父类。

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

//方法1   每次new People()都会使用各自的printName()
function People(name, sex){
    this.name = name;
    this.sex = sex;
    this.printName = function(){
        console.log(this.name);
    }
}
var p1 = new People('饥人谷', 2)


//方法2   把printName()放在Person.prototype，这样实例化出来的对象使用的就是同一个printName()

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

Person.prototype.printName = function(){
    console.log(this.name);
}
var p1 = new Person('若愚', 27);

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

Object.create() 会使用指定的原型对象及其属性去创建一个新的对象。(克隆指定的原型对象及其属性)
Object.create是ES5的方法，IE9及以上支持，兼容性良好。

使用Object.create()来实现类式继承

//Shape - superclass
function Shape() {
  this.x = 0;
  this.y = 0;
}

Shape.prototype.move = function(x, y) {
    this.x += x;
    this.y += y;
    console.info("Shape moved.");
};

// Rectangle - subclass
function Rectangle() {
  Shape.call(this); //call super constructor.
}

// subclass extends superclass
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;

var rect = new Rectangle();

console.log('Is rect an instance of Rectangle?',
  rect instanceof Rectangle); // true
console.log('Is rect an instance of Shape?',
  rect instanceof Shape); // true
//rect instanceof Object  //true
rect.move(1, 1); //Outputs, "Shape moved."

来源

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

所有继承了 Object 的对象都会继承到hasOwnProperty
方法。这个方法可以用来检测一个对象是否含有特定的自身属性；和 in
运算符不同，该方法会忽略掉那些从原型链上继承到的属性。

o = new Object();
o.prop = 'exists';
function changeO() {
  o.newprop = o.prop;
  delete o.prop;
}

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

o.hasOwnProperty('toString');         // 返回 false
o.hasOwnProperty('hasOwnProperty');   // 返回 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;
}

call 调用Person函数，this指向Male，使Male获取Person下的属性

补全代码，实现继承

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)
   this.age = age
}

Male.prototype = Object.create(Person.prototype)
Male.prototype.constructor = Male

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

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