精华内容
下载资源
问答
  • 原型链面试回答

    2020-08-02 04:09:13
    什么是原型链 一个对象有原型对象,它的原型对象也有自己的原型对象,一直往上找,找到Object对象,Object对象的的原型对象是null,在往上就没了。这个像链式一样的结构称为原型链。其本质描述的是对象的一种继承...

    什么是原型链

    一个对象有原型对象,它的原型对象也有自己的原型对象,一直往上找,找到Object对象,Object对象的的原型对象是null,在往上就没了。这个像链式一样的结构称为原型链。其本质描述的是对象的一种继承关系。就是说一个对象是怎么来的,是继承自它的原型对象。所以说绝大多数对象,其实都是继承自Object这个构造函数的原型对象,为什么是大多数,因为我们可以通过修改构造函数的原型来破坏这种继承关系,可以,但没必要

    看图
    –> 代表 继承自
    __proto __ 指向 实例的原型对象(浏览器的实现方法,非ECMA标准方法)在这里插入图片描述

    继承关系:o --> Object.prototype --> null

    在这里插入图片描述

    继承关系:a --> Array.prototype --> Object.prototype --> null

    在这里插入图片描述

    继承关系:a --> Function.prototype --> Object.prototype --> null

    在这里插入图片描述

    继承关系:cat --> Animal.prototype --> Object.prototype --> null
    继承关系:ssc --> People.prototype --> Animal.prototype --> Object.prototype --> null

    在这里插入图片描述

    继承关系:a --> Foo.prototype
    通过修改构造函数Foo的prototype来破坏继承关系
    上面修改了Foo原型对象中的__proto__属性为null
    导致Foo的实例a想要通过属性__proto__来找到自己的原型对象,找不到
    进而终止了此原型链,
    但是继承关系依然保留有,证据就是实例a可以访问到Foo.prototype中的属性prop1
    a访问不到Object的属性hasOwnProperty,说明它不是从Object继承来的,继承关系被破坏

    展开全文
  • 原型链面试问题

    千次阅读 2019-06-27 12:12:28
    创建对象有几种方法 字面量 //字面量 var o1 = {name:'o1'} var o2 = new Object({name:'o2'}) //构造函数 var M = function(name){ this.name = name ...// Object.create Object.create是用原型链的方...

    创建对象有几种方法

     字面量

    //字面量
    var o1 = {name:'o1'}
    var o2 = new Object({name:'o2'})
    
    //构造函数
    var M = function(name){
           this.name = name
        }
    var o3 = new M('o3')
    
    // Object.create  Object.create是用原型链的方式连接的 o4.__proto__===p 。所以打印o4与上面不同,因为name属性并不是o4本身的属性,而是它原型对象的属性
    var p = {name:'p'}
    var o4 = Object.create(p)
    
    在控制台会打印什么样的结果

    什么是原型 构造函数 实例 原型链

    对象就是实例

    任何一个函数只要被new使用了,这个函数就是一个构造函数

    对图解释:

    构造函数使用new运算符生成一个实例,构造函数也是函数,函数都有一个prototype属性,这个属性就是原型对象

    原型对象怎么区分出是被那个构造函数所引用呢?

    原型对象中有一个构造器,这个构造器默认指向你声明的那个函数

    M.prototype.constructor === M
    o3._proto_ === M.prototype
    

    通过原型链的方式找到原型对象,原型对象的方法是被不同的实例所共有的。

    原型链:当实例调用某一个属性时,先在本身找,如果没有找到,就到它的原型对象上逐级往上找(_proto_),直到找到Object.prototype,如果还找不到则原路返回(constructor),告诉它方法或属性未定义

    只有函数有prototype属性,对象都有_proto_。

    实例的_proto_属性指向的是它的构造函数的原型对象

    å¾çæè¿°

    总结:原型链就是在访问一个对象属性的时候,如果自身没有找到的情况下会去它的原型对象中查找,如果还没有,会去它的原型对象的原型对象中查找,如此循环直到顶层的Object对象的原型对象(是个null,Object.prototype.__proto__===null)为止的这么个机制

     

    instanceof的原理

    判断实例对象的__proto__与构造函数的prototype是不是引用的同一个原型对象

    因果关系
    o3.__proto__ === M.prototype
    o3 instanceof M
    
    M.prototype._proto_ === Object.prototype //针对M来说
    o3 instanceof Object
    
    

    实例 instanceof 构造函数

    C继承B,B继承A。C创建了实例则 该实例 instanceof A|B|C都返回true,那么如何判断实例是哪个构造函数创建的呢?

    o._proto_.constructor === C //true
    o._proto_.constructor === Object //false

     

    new运算符的工作原理

    第一步创建一个新对象,这个对象继承自构造函数的prototype属性

    第二步 把上下文this指向这个新对象

    第三步,要不要返回这个新对象,用return会取代,不用就返回这个新对象

    var new2 = function(func){
        var o = Object.create(func.prototype)
        var k = func.call(o)
        if(typeof k === 'object'){
            return k
        }
        else {
            return o
        }
    }

    参考自慕课网

     

    展开全文
  • 原型链面试

    2020-12-12 21:56:57
    关于原型链的特殊情况的几条总结: Object并不是原型链顶层,Object.prototype才是原型链的顶层,有:Object.prototype.__proto__ = null 所有函数都是Function的实例(包括Function),有:Function.prototype = ...

    关于原型链的特殊情况的几条总结:

    1. Object并不是原型链顶层,Object.prototype才是原型链的顶层,有:Object.prototype.__proto__ = null
    2. 所有函数都是Function的实例(包括Function),有:Function.prototype = Function.__proto__
    3. 所有对象都是Object的实例(包括原型对象),有:Function.prototype.__proto__=Object.prototype

    测试题1

    var A = function() {}
    
    A.prototype.n = 1
    
    var b = new A()
    
    A.prototype = {
      n: 2,
      m: 3
    }
    
    var  c = new A()
    
    console.log(b.n, b.m, c.n, c.m) // 1 undefined 2 3
    
    

    测试题2

    var F = function() {}
    
    Object.prototype.a = function() {
      console.log('a()')
    }
    
    Function.prototype.b = function() {
      console.log('b()')
    }
    
    var f = new F()
    
    f.a() // a()
    f.b() // b is not a function(报错)
    F.a() // a()
    F.b() // b()
    
    

    注:

    Object.prototype.constructor.__proto__ === Function.prototype // true
    
    Function.prototype.__proto__ === Object.prototype // true
    
    Object.prototype.__proto__ === null // true
    

    构造函数的原型继承的Function, Function继承的是Object, 意思就是Object的prototype就是尽头了

    在这里插入图片描述

    展开全文
  • //f对象和g对象是构造函数的实例 构造函数上面添加了原型的方法在查找方法的时候就会在__proto__上面去查看所以g和f就能获取到b()函数对象,产生层级的原因看(1) console.log(f); console.log(g);//通过构造函数...
     var F = function () {
    
        };
        var G = function(){
            this.name = 'xiaoming'
    
        };
        G.prototype.each=function(){
            console.log("吃货")
        };
        Object.prototype.a=function () {//(2)所有的对象函数的__proto__都会有a函数对象
            console.log("a()")
        };
    
        Function.prototype.b = function () {
            console.log("b()")
        };
        //Function 指的是继承在所有的window上面的声明的函数
    
        var f = new F();
        var g = new G();
        console.log(a instanceof Function);//(1)
        //(1) Object是所有的对象的根,在根上面添加了一个对象a,其实就是添加到__proto__上面,Function默认是在object手动添加的对象a;以后添加的对象是a的子集可以这么理解 b就是子集
        console.log(Function instanceof Object);//true
        console.log(Object instanceof Function);//true
        console.log(F instanceof Object);//true
        console.log(F instanceof Function);//true
        console.log(f instanceof Function);//false
        console.log(f instanceof Object);//true
        console.log(F.prototype.__proto__);//原型的规则就是现在他自己的本身去查找然后早__proto__上面去找一层一层的去查看找
        console.log(f  instanceof F.prototype.constructor);//实力化的对象是构造函数的constructor的属性
    
    
        f.a.__proto__.b();//打印出 b() 结合(1)理解  所以在a对象的原型下面就可以找到b();如果直接f.b();就会找不到
      //  f.b();//报错 Uncaught TypeError: f.b is not a function 因为b对象是a对象的子集所以直接调用就会没有
        g.a.__proto__.b();//打印出 b() 结合(1)和(2)理解 也可以拿到b函数对象
    
        //f对象和g对象是构造函数的实例 构造函数上面添加了原型的方法在查找方法的时候就会在__proto__上面去查看所以g和f就能获取到b()函数对象,产生层级的原因看(1)
        console.log(f);
        console.log(g);//通过构造函数this添加就不会在__proto__,直接在实例化对象上面
        console.log(Object.prototype);//手动给Object对象添加的所有属性
    
    //不足之处提出大家共同进步!谢谢

     

    展开全文
  • function A() { } A.prototype.n = 1 var b = new A() A.prototype = { ... // A的原型对象被改变了,但是b的原型对象可没变 var c = new A() console.log(b.n, b.m, c.n, c.m) //1 underfined ...
  • 明确foo 和 F的原型链,沿着原型链找A属性和B属性; console.log(foo.a) foo 是个对象 对象的原型链 是Object foo.a 的原型链上a 所以 输出 value a console.log(foo.b) undefined foo的原型链上 没有 F ...
  • 题目1.如何准确判断一个变量是数组类型 var arr = []; typeof arr; // obj typeof无法判断是不是数组 ... 1、验证原型对象 Object.getPrototypeof(obj) 要检测的类型的构造函数.prototype 2、验证构造函
  • 原型原型链 面试

    2019-10-07 13:28:51
    4、zepto(或其他框架)源码中如何使用原型链 (1)阅读源码是高效提高技能的方式 (2)但不能‘埋头苦钻’有技巧在其中 (3)慕课网搜索‘zepto设计和源码分析’ 二、知识点 1、构造函数 构造函数有个特点,函数名首...
  • 分析: 这道题主要的用到了原型链,先查看自身是否有,没有找原型,原型也没有找Object,再找不到就是undefined。 这道题中console.log(b.n); 在查找b.n是首先查找 b 对象自身有没有 n 属性,如果没有会去原型...
  • <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>... f.
  • 2、原型机原型链 3、类的继承 4、原始类型和引用类型的区别 5、每一个知识点都可以拿出来做单独的专题研究。 解题需要的知识点细节 1.构造函数,都有一个prototype属性,指向构造函数的原型对象,...
  • 这道题是我面试的时候碰到的 function Parent() { this.a = 1; this.b = [1, 2, this.a]; this.c = { demo: 5 }; this.show = function () { console.log(thi...
  • 上一篇文章原型链面试题答案: 1. 说说JS中的原型链以及最顶端是什么 访问一个属性时,会先在实例本身查找该属性,如果没有,就到其原型对象中去查找,若还是没有会去构造这个对象的构造函数中去查找,如果没有就...
  • 原则,即先查找实例属性,然后顺着原型链去查找指定的属性,直至原型链末端的 Object.prototype 和 null ,如果实例自身及整个原型链都不存在所查找的属性则返回 undefined 7.赋值语句对于原始值赋值和引用类型...
  • 原则,即先查找实例属性,然后顺着原型链去查找指定的属性,直至原型链末端的 Object.prototype 和 null ,如果实例自身及整个原型链都不存在所查找的属性则返回 undefined 7.赋值语句对于原始值赋值和引用类型...
  • 有关原型与原型链面试题目

    千次阅读 2018-07-03 21:46:22
    //有关原型与原型链面试题目 { function Fn(){ this.x = 100; this.y = 200; this.getX = function () { console.log(this.x); } } Fn.prototype.getX = function () { console.log(this.x); }; ...
  • 原型链学习面试

    2018-12-05 12:01:39
    原型链类 创建对象有几种方法 1、字面量对象var o1 = {name:'1'}var o11 = new Object({name:'11'})2、显示构造函数创建var M = function(){this.name ='o2'}var o2 = new M();3.Object.create 方法来创建var P = {...
  • 原型与原型链的常见面试题 1. var A=function(){} A.prototype.n=1 var b=new A() A.prototype={ n:2, m:3 } var c=new A() console.log(b.n,b.m,c.n,c.m)//1,undefined,2,3 分析一下:b.n 因为b是A的实例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,704
精华内容 681
关键字:

原型链面试