高级2-this_原型链_继承

作者: Maggie_77 | 来源:发表于2017-01-18 20:20 被阅读0次

高级2-this_原型链_继承
高级2-this_原型链_继承
高级2-this_原型链_继承
Javascript 继承
继承
js中的实现继承的几种方式
JavaScript 原型、原型链与原型继承
js基础之实现继承的几种方式
es5的部分继承以及es6的class
构造函数原型的继承方式分析

this 相关问题

问题1： apply、call 有什么作用，什么区别

Javascript的每个Function对象中有一个apply方法：
function.apply([thisObj[,argArray]])
还有一个类似功能的call方法：
function.call([thisObj[,arg1[, arg2[, [,.argN]]]]])

它们各自的定义：
apply：应用某一对象的一个方法，用另一个对象替换当前对象。
call：调用一个对象的一个方法，以另一个对象替换当前对象。
它们的共同之处：
都“可以用来代替另一个对象调用一个方法，将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。
它们的不同之处：
apply：
最多只能有两个参数——新this对象和一个数组 argArray。如果给该方法传递多个参数，则把参数都写进这个数组里面，当然，即使只有一个参数，也要写进数组里面。如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。如果没有提供 argArray 和 thisObj 任何一个参数，那么 Global 对象将被用作 thisObj，并且无法被传递任何参数。
call：
则是直接的参数列表，主要用在js对象各方法互相调用的时候，使当前this实例指针保持一致,或在特殊情况下需要改变this指针。如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。

更简单地说，apply和call功能一样，只是传入的参数列表形式不同：如 func.call(func1,var1,var2,var3) 对应的apply写法为：func.apply(func1,[var1,var2,var3])
也就是说：call调用的为单个，apply调用的参数为数组

function sum(a,b){
    console.log(this === window);//true
    console.log(a + b);
 }
 sum(1,2);
 sum.call(null,1,2);
 sum.apply(null,[1,2]);

作用　　

调用函数

var info = 'tom';
function foo(){   
    //this指向window 
    var info = 'jerry';
    console.log(this.info);   //tom
    console.log(this===window)  //true
}
foo(); 
foo.call();
foo.apply();

call和apply可以改变函数中this的指向

var obj = {
        info:'spike'
}
foo.call(obj);    //这里foo函数里面的this就指向了obj
foo.apply(obj);

借用别的对象的方法
eg:求数组中的最大值

var arr = [123,34,5,23,3434,23];
//方法一
var arr1 = arr.sort(function(a,b){
    return b-a;
});
console.log(arr1[0]);
//方法二
var max = Math.max.apply(null,arr)   //借用别的对象的方法
console.log(max);

问题2：以下代码输出什么?

var john = { 
  firstName: "John" 
}
function func() { 
alert(this.firstName + ": hi!")
}
john.sayHi = func
john.sayHi()  // John: hi!，this指向调用sayHi()的john对象

问题3：下面代码输出什么，为什么

func() 

function func() { 
  alert(this)    //window，因为在函数被直接调用时this绑定到全局对象。在浏览器中，window 就是该全局对象
}

问题4：下面代码输出什么

document.addEventListener('click', function(e){
    console.log(this);  //#document.
                        //在事件处理程序中this代表事件源DOM对象
    setTimeout(function(){
        console.log(this);  //window.
                            //setTimeout、setInterval这两个方法执行的函数this也是全局对象
    }, 200);
}, false);

问题5：下面代码输出什么，why

var john = { 
  firstName: "John" 
}

function func() { 
  alert( this.firstName )
}
func.call(john)    //John
                   //call(john)传入了john这个执行上下文，this指向john这个对象

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

var module= {
  bind: function(){
    $btn.on('click', function(){
      console.log(this) //this指$btn
      this.showMsg();
    })
  },
  
  showMsg: function(){
    console.log('饥人谷');
  }
}
//修改后：
var module= {
  bind: function(){
     var cur = this;  //将this代表的module存到cur
    $btn.on('click', function(){
      console.log(this) //$btn
      cur.showMsg(); //饥人谷
    })
  },
  
  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();

Person是构造函数，也是一个对象，这个对象里面存在一个prototype属性，而构造函数内部定义了实例的属性和方法，这些属性和方法是属于该类的所有实例的特征；
p是通过构造函数Person构造出来的实例，也是拥有__proto__属性。所以p.__proto__ === Person.prototype;
prototype是构造函数内部的原型对象，所以拥有contructor和__proto__属性，其中contructor属性指向构造函数Person，__proto__指向该对象的原型，即

Person.prototype.__proto__ === Object.prototype;
Person.prototype.constructor == Person

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

p.toString()方法是继承构造函数Object的原型对象里定义的toString方法，首先p会找自己的toString方法，如果没有找到，会沿着__proto__属性继续到构造函数Person的prototype里找toString方法，如果还未找到，再继续往Person.prototype的__proto__即Object.prototype找toString方法，最后找到toString()方法。
原型链：由于原型对象本身也是对象，而每个javascript对象都有一个原型对象，每个对象都有一个隐藏的__proto__属性，原型对象也有自己的原型，而它自己的原型对象又可以有自己的原型，这样就组成了一条链，这个就是原型链。在访问对象的属性时，如果在对象本身中没有找到，则会去原型链中查找，如果找到，直接返回值，如果整个链都遍历且没有找到属性，则返回undefined。原型链一般实现为一个链表，这样就可以按照一定的顺序来查找。

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

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

代码如下：

//方法一：
String.prototype.getMostOften = function(){
    var obj = {};
    for(var i=0,k;i<this.length;i++){
        k = this[i];
        if(obj[k]){
            obj[k]++
        }else{
            obj[k] = 1
        }
    }

    var max = 0,key;
    for(var k in obj){
        if(obj[k]>max){
           max = obj[k];
           key = k;
        }
     }

    return key;
}
//方法二：
String.prototype.getMostOften = function(){
    var arr = this.split("");
    var result = arr.reduce(function(allLetters,letter){
        if(allLetters[letter]){
            allLetters[letter]++
        }else{
            allLetters[letter] = 1
        }
    
        return allLetters;          
    },{});
  var max = 0,k;
        for(var key in result){
            if (result[key]>max){
                max = result[key];
                k = key
            }
        }
    return k;
}
var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d

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

instanceOf：判断一个对象是否为另一个对象的实例

function instanceOf(obj,fn){
    var oldpro = obj.__proto__;
    while(oldpro){
    if(oldpro === fn.prototype){
        return true;
    }else{
        oldpro = oldpro.__proto__;
    }
    }
    return false;
}

继承相关问题

问题11：继承有什么作用?

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

问题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);

区别：同样都是创建printName方法，方法1的printName方法是在函数Person实例对象里的，方法2是在Person的prototype对象上的。当再创建一个Person实例对象的时候，方法1又将会再创建一个printName方法，占用新的内存，而方法2将一个公用的printName方法写在原型上，当对象要使用该方法只需到原型链里调用就可以了，达到节省内存的效果。

问题13： Object.create 有什么作用？兼容性如何？

作用：创建一个拥有指定原型和若干个指定属性的对象。
兼容性：
使用：

function Person(name, age){
  this.name = name;
  this.age = age;
}
Person.prototype.sayName = function(){
  console.log(this.name);
}
function Male(name, age, sex){
  Person.call(this, name, age);
  this.sex = sex;
}
// Male.prototype = new Person(); //该方法同下，代替不兼容Object.create()的使用场景
Male.prototype = Object.create(Person.prototype);
Male.prototype.constructor = Male;
Male.prototype.sayAge = function(){
    console.log(this.age);
};
var p1 = new Male('hunger', 20, 'nan');
p1.sayName();//hunger
p1.sayAge();//20

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

作用：判断一个对象是否包含自定义属性而不是原型链上的属性，是JavaScript中唯一一个处理属性但是不查找原型链的函数
语法：obj.hasOwnProperty(prop)(prop为要检测的属性名称)
使用（以上一题为例）：

p1.hasOwnProperty('name');//true
p1.hasOwnProperty('sayName');//false
Male.prototype.hasOwnProperty('sayAge');//true

问题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;
}

作用：在Male函数中，调用Person函数，使Male函数能够执行Person上的初始化代码，实现构造函数继承。

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

Male.prototype = Object.create(Person.prototype);
Male.prototype.constructor = Male;
Male.prototype.getAge = function(){
    console.log(this.name);
};

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

高级2-this_原型链_继承
作业 this 相关问题问题1： apply、call 有什么作用，什么区别apply()和call()函数都可...
高级2-this_原型链_继承
this：1. apply、call 、bind有什么作用，什么区别共同作用：通过传入参数都可以改变this的值区...
高级2-this_原型链_继承
this 相关问题问题1： apply、call 有什么作用，什么区别 Javascript的每个Functio...
Javascript 继承
参考：JavaScript高级程序设计(第3版) 原型链原型式继承寄生式继承寄生组合式继承
继承
原型链直接继承原型链直接继承prototype 原型链继承_prototype属性继承_构造函数绑定
js中的实现继承的几种方式
大纲：原型链借用构造函数组合继承原型式继承寄生式继承寄生组合式继承 1、原型链：什么是原型链？原型链的基本思想...
JavaScript 原型、原型链与原型继承
原型，原型链与原型继承用自己的方式理解原型，原型链和原型继承 javascript——原型与原型链 JavaSc...
js基础之实现继承的几种方式
js 实现继承的方式有：原型链继承；构造函数继承；组合继承（原型链继承 + 构造函数继承）（最常用）；（原型...
es5的部分继承以及es6的class
一、JavaScript常用的原型继承方式原型链继承 2，构造函数继承（对象冒充继承） 3，组合继承（原型链继承...
构造函数原型的继承方式分析
1.通过原型链继承综上我们可以总结出通过原型链来实现继承的原理通过原型链来实现继承的原理原型链继承方案中，父类...