美文网首页
this_原型链_继承

this_原型链_继承

作者: 李永州的FE | 来源:发表于2017-06-23 14:10 被阅读0次

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

    apply和call就是为了改变函数内部this的指向；

    如果使用apply或call方法，那么this指向他们的第一个参数，apply的第二个参数是一个参数数组，call的第二个及其以后的参数都是数组里面的元素，就是说要全部列举出来；bind与apply、call最大的区别就是：bind不会立即调用，其他两个会立即调用
    举例：

    var info = 'tom';
function foo(){   
  //this指向window 
  var info = 'jerry';
  console.log(this.info);   //tom
  console.log(this===window)  //true
}
foo(); 
var obj = {
      info:'spike'
}
foo.call(obj);    //这里foo函数里面的this就指向了obj
foo.apply(obj);//输出

    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.获取数组中的最大值和最小值，利用他们扩充作用域拥有Math的min和max方法；
由于没有什么对象调用这个方法，所以第一个参数可以写作null或者本身；
var  numbers = [5, 458 , 120 , -215 ]; 
var  maxInNumbers = Math.max.apply(Math, numbers),   //458
       maxInNumbers = Math.max.call(Math,5, 458 , 120 , -215); 

    验证是否是数组（前提是toString（）方法没有被重写过）
function   isArray(obj){ 
    return Object.prototype.toString.call(obj) === '[object Array]' ;
}

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

    func() 
function func() { 
  alert(this)
}
输出为window对象。由于func是在全局作用域下被调用

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

    document.addEventListener('click', function(e){
    console.log(this);//document，是DOM对象本身，
    setTimeout(function(){
        console.log(this);//window，这是由于setTimeout函数是挂在window
对象下的
    }, 200);
}, false);

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

    var john = { 
  firstName: "John" 
}

function func() { 
  alert( this.firstName )
}
func();//输出undefined,因为全局下访问不到firstname

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

    var module= {
  bind: function(){
    $btn.on('click', function(){
      console.log(this) //this指的是btn
      this.showMsg();
    })
  },
  
  showMsg: function(){
    console.log('饥人谷');
  }
}
bind属性中，this.showMsg()语句的this指的是$btn，是无法调用showMsg()的，
此时需要保存事件绑定函数外部的this，修改如下
var module= { 
 bind: function(){ 
     var cur = this//这里的this指的是module,先把它保存起来以后用
     $btn.on('click', function(){ 
         console.log(this) //this指的是btn
         cur.showMsg(); 这里就可以名正言顺调用自己的方法了相当于module.showMsg
     }) 
 },
 showMsg: function(){ 
     console.log('饥人谷'); 
 }
}

    补充类似题目

    1

    var o = {
foo:'bar',
func: function(){
  console.log(this)
}
}
var a = o.func;
a();//打印出来的this变成了全局对象window，不再是o
在浏览器中输入a，返回的是一个函数，当再次调用a，就是相当于在全局作用域下调用函数
    2 Paste_Image.png

    先打印的是person的name2，然后是全局name1
    假如最后添加两行代码，var a=person.say; a()
    意思是先把函数赋给a，则a就是一个函数了，在调用a相当于在全局下调用

     var myobject={
        foo:"bar",
        func:function () {
            var self=this;
            console.log(this.foo);//bar无疑问
            (function() {
                console.log(this)//window，立即执行函数有自己的作用域
                console.log(this.foo)//理所当然undefined
                console.log(self.foo);//还为bar
            })();

        }
    }
    myobject.func();
   假如变形把最后一行改为var f=myobject.func;
                    f()，则this指的就是window，根本拿不到foo的值，全是undefined


    var name='name1';
    function say() {
        console.log(name);
    }

    var person={
        name:'name2',
        say:say
    }
    person.say();
    say();//注意与上题的不同，这里的打印出来的name都是全局name!!!!!

    var user='jrg';
var box={
    user:'hh',
    getuser:function () {
       var self=this;
        return function () {
            return self.user
        }
    }
}
console.log(box.getuser()())
非常具有迷惑性一个题目，首先把box.getuser打印出来就一目了然了，是打印hh,因为有var self=this;所以无论怎么变形都是打印hh,box.getuser().call（box）这个也是打印相同结果

    function func1() {
     var n=99;
     nadd=function () {
         console.log(this)
         this.n+=1;
         console.log(this.n)
     }
     function func2() {
         console.log(n)
     }
     return func2;
 }
 var result=func1();
    result();
    nadd();NAN,这个函数能访问到有点不懂
    result();


    var obj={
    name:'obj',
    close:function () {
        this.name="close";
        return function () {
            return this.name;
        }
    }
}
console.log(obj.close().call(obj))不call的话输出为空，加了输出为close，obj的name已经改变

    原型链相关问题

    问题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。原型链一般实现为一个链表，这样就可以按照一定的顺序来查找。
    Paste_Image.png

    补充：

    var a={n:4399}
var b=function () {
    this.n=9999
}
var c=function () {
    var n=8888
}
b.prototype=a;
c.prototype=a;
var d=new b();
    var e=new c()
    a.n++;
    console.log(d.n)9999自己的
    console.log(e.n)4400a的
这个实在理解不了。。。

     var F=function () {
     
 }
 Object.prototype.a=function () {
     
 }
 Function.prototype.b=function () {
     
 }
 var f=new F();
F能拿到b，f拿不到因为他自己是对象

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

    String.prototype.getMostOften = function() {
     var obj = {};
     for (var i = 0; i < this.length; i++) {
       if(!obj[this[i]]) {
         obj[this.charAt(i)] = 1;
       }else if(obj[this[i]]) {
         obj[this.charAt(i)]++;
       }
     }
     console.log(obj);
     var val = '';
     var num = 0;
     for(var key in obj) {
       if (obj[key] > num) {
         num = obj[key];
         val = key
       }
     }

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

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

    简单来记就是如果实例的_proto不等于构造函数的prototype就去实例的
_proto_._proto_去找
function instanceOf(obj,Func){
    var __proto__=obj.__proto__;
    do{
      if(__proto__===Func.prototype) {
        return true;
      } 
      if(!__proto__) return false;
    }
    while(__proto__=__proto__.__proto__);
    return false;
  }

    继承相关问题

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

    JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型，以及该对象的原型的原型，依此层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾。这就意味着，JS对象可以使用所有其原型的所有方法，如果我们在原型上添加新的方法，那么实例也会拥有该方法，能够大大减少冗余代码

    问题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有什么作用？ 如何使用？

    function Person(name,age) {
    this.name = name;
    this.age = age;
  }
  Person.prototype.printName = function() {
    console.log(this.name);
  }
  function people(name) {
    this.name = name;
  }
  people.prototype = Object.create(Person.prototype);
  var p = new people('John');
  console.log(p.hasOwnProperty('printName'));//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;
}
Male中的call，指定了其执行环境在Person下。换句话说，实现了从People的继承

    问题16： 补全代码，实现继承

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

  Person.prototype.getName = function(){
    return this.name;
  };    
  Person.prototype.printName = function () {
    console.log(this.name)
  }
  function Male(name, sex, age){
     this.sex = sex;
     Person.call(this,name,sex);
  }

  Male.prototype = Object.create(Person.prototype);
  Male.prototype.constructor = Male;
  Male.prototype.getAge = function(){
      return this.age;
  };

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

    相关文章

      网友评论

          本文标题：this_原型链_继承

          本文链接：https://www.haomeiwen.com/subject/xeqxcxtx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|this_原型链_继承|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！