精华内容
下载资源
问答
  • 显式原型与隐式原型显式原型:prototype 隐式原型:__proto__在js中万物皆对象,方法(Function)是对象,方法的原型(Function.prototype)是对象,对象具有属性(__proto__)称为隐式原型,对象的隐式原型指向构造...

     显式原型与隐式原型

    显式原型:prototype             

     隐式原型:__proto__

    1. 每个函数function都有一个prototype,即显式原型(属性)
    2. 每个实例对象都有一个__proto__,可称为隐式原型(属性)

    3. 对象的隐式原型的值为其对应构造函数的显式原型的值

    4. 总结:

      * 函数的prototype属性: 在定义函数时自动添加的, 默认值是一个空Object对象

      * 对象的__proto__属性: 创建对象时自动添加的, 默认值为构造函数的prototype属性值

      *Object.prototype的__proto__属性指向null。

    区别:

    __proto__是每个对象都有的一个属性,而prototype是函数才会有(函数也有__proto__)的属性。

    __proto__指向的是当前对象的原型对象,而prototype指向它的构造函数的原型对象。

    作用:

    1、肯定是为了继承!

    2、prototype用来实现基于原型的继承与属性的共享。

    3、__proto__就构成了我们常说的原型链 访问构造方法中的显示原型,同样用于实现基于原型的继承。

    在js中万物皆对象,方法(Function)是对象,方法的原型(Function.prototype)是对象,对象具有属性(__proto__)称为隐式原型,对象的隐式原型指向构造该对象的构造函数的显式原型


    [javascript]  view plain  copy
    1. //定义构造函数  
    2.   function Fn() {   // 内部语句: this.prototype = {}  
    3.   
    4.   }  
    5.   // 1. 每个函数function都有一个prototype,即显式原型属性, 默认指向一个空的Object对象  
    6.   console.log(Fn.prototype)  
    7.   // 2. 每个实例对象都有一个__proto__,可称为隐式原型  
    8.   //创建实例对象  
    9.   var fn = new Fn()  // 内部语句: this.__proto__ = Fn.prototype  
    10.   console.log(fn.__proto__)  
    11.   // 3. 对象的隐式原型的值为其对应构造函数的显式原型的值  
    12.   console.log(Fn.prototype===fn.__proto__) // true  
    13.   //给原型添加方法  
    14.   Fn.prototype.test = function () {  
    15.     console.log('test()')  
    16.   }  
    17.   //通过实例调用原型的方法  
    18.   fn.test()

    •     构造函数的显示原型的隐式原型:
    1. 内建对象(built-in object):比如Array(),Array.prototype.__proto__指向什么?Array.prototype也是一个对象,对象就是由 Object() 这个构造函数创建的,因此Array.prototype.__proto__ === Object.prototype //true,或者也可以这么理解,所有的内建对象都是由Object()创建而来。
    • 自定义对象
    1. 默认情况下:
    function Foo(){}
    var foo = new Foo()
    Foo.prototype.__proto__ === Object.prototype //true 理由同上
    Foo.prototype===foo._proto_ //true
    2. 其他情况: 
    (1)
     function Bar(){}
    //这时我们想让Foo继承Bar
    Foo.prototype = new Bar()
     Foo.prototype.__proto__ === Bar.prototype //true
    (2)
    //我们不想让Foo继承谁,但是我们要自己重新定义Foo.prototype
    
    复制代码
    Foo.prototype = {
      a:10,
      b:-10
    }
    //这种方式就是用了对象字面量的方式来创建一个对象,根据前文所述 
    Foo.prototype.__proto__ === Object.prototype
    复制代码

    : 以上两种情况都等于完全重写了Foo.prototype,所以Foo.prototype.constructor也跟着改变了,于是乎constructor这个属性和原来的构造函数Foo()也就切断了联系。

    • 构造函数的隐式原型

    既然是构造函数那么它就是Function()的实例,因此也就指向Function.prototype,比如 Object.__proto__ === Function.prototype



    手绘原型链





    原型链是什么

    实现继承主要依赖原型链。 

    什么是原型对象。我们知道每个构造函数一旦创建都有prototype指针指向它的原型对象(构造函数.prototype)。而原型对象(构造函数.prototype)会默认生成一个constructor指针又指向构造函数。在创建实例时,实例有一个内部属性[[prototype]]指向该原型对象。原型对象内创建的所有方法会被所有实例共享。 

    原型是什么?

    在JavaScript中原型是一个prototype对象,用于表示类型之间的关系。

    什么是原型链。

    JavaScript万物都是对象,对象和对象之间也有关系,并不是孤立存在的。对象之间的继承关系,在JavaScript中是通过prototype对象指向父类对象,直到指向Object对象为止,这样就形成了一个原型指向的链条,专业术语称之为原型链。

    原型链就是创建一个构造函数,它会默认生成一个prototype属性并指向原型对象。使用下一个构造函数的原型对象作为这个构造函数的实例。即 nextFuction.prototype = new thisFuction(); 

    在下下一个构造函数的原型对象 = new nextFuction。这样下去就会构成一条实例与原型之间的链条,这就是原型链。


    为什么要有原型链

    构造函数的所有实例都可以访问构造函数原型中的方法和属性。

    也就是把共有的东西统一存放到一个共享空间。这样可以避免相同函数重复声明,减少空间占用,节省内存。

    实现继承,子类继承父类的方法和变量;

    原型上可以定义一些方法和变量;

    以这个原型建立的对象,可以使用原型方法和变量,从而实现继承。


    展开全文
  • 简述原型链什么,有什么用处?

    千次阅读 2018-12-30 23:34:38
    这里是修真院前端小课堂,每篇分享文从 ...【简述原型链什么,有什么用处?】 【修真院web小课堂】 大家好,我是IT修真院上海分院第8期的学员周能,一枚正直纯洁善良的web程序员,今天给大家分...

    这里是修真院前端小课堂,每篇分享文从

    【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】

    八个方面深度解析前端知识/技能,本篇分享的是:

    【简述原型链是什么,有什么用处?】

     

    【修真院web小课堂】

    大家好,我是IT修真院上海分院第8期的学员周能,一枚正直纯洁善良的web程序员,今天给大家分享一下,修真院官网web任务4,深度思考中的知识点——简述原型链是什么,有什么用处?若想访问一个对象的原型,应该使用什么方法

     

     
    (1)背景介绍:
    什么是原型

    一个函数可以看成一个类,原型是所有类都有的一个属性,原型的作用就是给这个类的每一个对象都添加一个统一的方法

     

     

    PROTOTYPE

    JS都是用new来从构造函数生成一个实例对象

    构造函数生成的实例无法共享属性和方法,考虑到这点于是将prototype属性引入到了JS中

    PROTOTYPE这个属性包含一个对象,里面放着所有实例需要共享的方法和属性,而不需要共享的属性和方法可以放在构造函数中

    由于所有的实例对象共享同一个prototype对象,那么从外界看起来,prototype对象就好像是实例对象的原型,而实例对象则好像"继承"了prototype对象一样。

     

     

    (2)知识剖析:
    __PROTO__和PROTOTYPE

    每个对象都有一个__proto__属性,而prototype只有函数才有

    clipboard.png

    对象是由构造函数创建的,函数也是对象,函数是由Function创建的,对象的__proto__等于创建者的prototype

     

     

     

     

    什么是原型链

    每个对象都有一个__proto__,它指向它的prototype原型对象,而prototype原型对象又具有一个自己的原型对象,就这样层层向下上直到一个对象的原型prototype为null 这个查询的路径就是原型链

     

     

     

    (3)常见问题:
    如何访问一个对象的原型?

     

     

     

    (4)解决方案:
     

    __PROTO__,PROTOTYPE,OBJECT.GETPROTOTYPEOF()

    prototype,只有函数对象才拥有一个属性,用来访问其原型对象

    __proto__,是任何引用类型都拥有的属性,指向其构造函数的prototype,但是并不是标准写法,是一个特殊的内部属性

    Object.getPrototypeOf()该属性是ES5引入的一个标准属性,用来获取对象的原型,其作用和__proto__是一样

     

    function Pig(name) {

    this.name = name

    }

     

    var a = new Pig("胖胖");

    var b = new Pig("瘦瘦");

     

    Pig.prototype.like = "red"

    a.__proto__.like="red";

    Object.getPrototypeOf(a).like="red"

     

     

    (5)编码实战:
     

     

    (6)拓展思考:
     

    使用PROTOTYPE需要注意什么

    尽量去修改增添,使用对象字面量创建原型方法要谨慎

     

     

    function Pig(name) {

    this.name = name

    }

    Pig.prototype = {//这个写法必须写到最上面,必须要在实例对象前面

    like: "red",

    }

     

    var a = new Pig("胖胖");

    var b = new Pig("瘦瘦");

     

    Object.getPrototypeOf(a).like="red"

     

     

     

    (7)参考文献:
    https://www.jb51.net/article/...

    https://zhuanlan.zhihu.com/p/...

     

     

    (8)更多讨论:
    1、什么是原型?

       答:一个函数可以看成一个类,原型是所有类都有的一个属性,原型的作用就是给这个类的每一个对象都添加一个统一的方法

     

     

     

    2、什么是原型链

        答:每个对象都有一个__proto__,它指向它的prototype原型对象,而prototype原型对象又具有一个自己的原型对象,就这样层层向下上直到一个对         象的原型prototype为null 这个查询的路径就是原型链

     

     

     

    3、如何访问一个对象的原型?

    答:prototype,只有函数对象才拥有一个属性,用来访问其原型对象

          __proto__,是任何引用类型都拥有的属性,指向其构造函数的prototype,但是并不是标准写法,是一个特殊的内部属性

          Object.getPrototypeOf()该属性是ES5引入的一个标准属性,用来获取对象的原型,其作用和__proto__是一样

    展开全文
  • JS原型和原型链什么

    万次阅读 多人点赞 2018-06-15 17:50:58
    原型链"(prototype chain)模式,来实现继承。 Brendan Eich设计javascript之初是为了实现网页与浏览器之间交互的一种简单的脚本语言 如果真的是一种简易的脚本语言,其实不需要有"继承"机

    Javascript语言的继承机制一直很难被人理解。

    它没有"子类"和"父类"的概念,也没有"类"(class)和"实例"(instance)的区分,全靠一种很奇特的"原型链"(prototype chain)模式,来实现继承。

    Brendan Eich设计javascript之初是为了实现网页与浏览器之间交互的一种简单的脚本语言

    如果真的是一种简易的脚本语言,其实不需要有"继承"机制。但是,Javascript里面都是对象,必须有一种机制,将所有对象联系起来。所以,Brendan Eich最后还是设计了"继承"。


     

    背景介绍

    1.构造函数

    构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象。每个构造函数都有prototype(原型)属性

    2.原型模式

    每个函数都有prototype(原型)属性,这个属性是一个指针,指向一个对象,这个对象的用途是包含特定类型的所有实例共享的属性和方法,即这个原型对象是用来给实例共享属性和方法的。
    而每个实例内部都有一个指向原型对象的指针。

    image.png

    原型链

    每个构造函数都有一个原型对象,原型对象都包含一个指向构造函数的指针,而实例都包含指向原型对象内部的指针。我们让原型对象的实例(1)等于另一个原型对象(2),
    此时原型对象(2)将包含一个指向原型对象(1)的指针,
    再让原型对象(2)的实例等于原型对象(3),如此层层递进就构成了实例和原型的链条,这就是原型链的概念


     

    构造函数

    构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象。 即为对象变量赋初始值。每个构造函数的实例都将共享构造函数的初始值。 构造函数的出现是为了解决使用Object构造函数和字面量表示法不方便创建大量重复对象的问题。

    传统创建对象实例的方法

    
       var person={
           name:'张女士',
           age:'80',
           gender:'女'
       };
     console.log(person)
    

    注:这个方法如果用于创建大量相同属性和方法的对象时,会产生大量重复代码

    构造函数的方法

    
         //构造函数方法创建对象实例
         function Person(name,age,gender) {
         this.name=name;
         this.age=age;
         this.gender=gender;
         this.say=function () {
         alert(this.name)
               }
         }
        var person1=new Person('钟女士',80,'女');
        var person2=new Person('张女士',80,'女');
        console.log(person2)
        console.log(person1)
    

    原型模式

    使用构造函数的问题是,每个方法都要在每个实例上重新创建一遍,即在构造函数的不同实例上的同名函数是不相等的。而我们创建每个构造函数都有一个prototype(原型)属性,这个属性是个指针,指向一个对象,而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法,我们使用这个原型对象来共享实例的属性和方法的模式就叫原型模式

    
      //原型模式创建对象
    function Person(){
     }
    Person.prototype.name='钟女士';
    Person.prototype.age=80;
    Person.prototype.gender='女';
    var person1= new Person();
    console.log(person1)
    //简写原型模式
    Person.prototype={
       constructor:Person
       name:'钟女士',
       age:80,
       gender:'女'
     }
    

    注:每个原型对象都有constructor属性,由于简写模式重写了默认的prototype对象,所以constructor也会被重新定义,不再指向他的构造函数,所以可以自己写一个constructor属性指向他的构造函数

    原型链

    每个构造函数都有原型对象,每个构造函数实例都包含一个指向原型对象的内部指针(proto),如果我们让第一个构造函数的原型对象等于第二个构造函数的实例,结果第一个构造函数的原型对象将包含一个指向第二个原型对象的指针,再然第三个原型对象等于第一个构造函数的实例,这样第三个原型对象也将包含指向第一个原型对象的指针,以此类推,就够成了实例于原型的链条,这就是原型链的基本概念

    
    function One(){
     }
     function Two(){
     }
     function Three(){
     }
     Two.prototype=new One();
     Three.prototype=new Two();
     var three=new Three();
     console.log(three);
     console.log(three.__proto__===Three.prototype) //true
     console.log(three.__proto__.__proto__===Two.prototype) //true
     console.log(three.__proto__.__proto__.__proto__===One.prototype)  //true
     console.log(three.__proto__.__proto__.__proto__.__proto__===Object.prototype)  //true
    

     

    在对象实例中,访问对象原型的方法

    • 1、使用proto属性
      此属性是浏览器支持的一个属性,并不是ECMAScript里的属性

    • 2.Object.getPrototypeOf

    • 3.使用constructor.prototype的方法
      对于不支持proto的浏览器,可以使用constructor,访问到对象的构造函数,在用prototype访问到原型

     

    使用原型链解释ANUGLAR作用域

    在开发过程中,我们可能会出现控制器的嵌套,看下面这段代码:

        <div ng-controller="OuterCtrl">
            <span>{{a}}</span>
             <div ng-controller="InnerCtrl">
                <span>{{a}}</span>
             </div>
         </div>
        <script>
        function OuterCtrl($scope) {
        $scope.a = 1;
        }
        function InnerCtrl($scope) {
        }
        </script>
    

    我们可以看到界面显示了两个1,而我们只在OuterCtrl的作用域里定义了a变量,但界面给我们的结果是,两个a都有值,现在自控制器里的a是从父控制器里继承过来的

    我们可以父子级的作用域看成两个原型对象,其中一个原型对象继承另一个原型对象的实例

    
    function Outer() {
        this.a = 1;
    }
    
    function Inner() {
    }
    
    var outer = new Outer();
    Inner.prototype=new Outer();
    var inner = new Inner();
    console.log(outer.a)
    console.log(inner.a)
    

    Angular的实现机制其实也就是把这两个控制器中的$scope作了关联,外层的作用域实例成为了内层作用域的原型。

    既然作用域是通过原型来继承的,自然也就可以推论出一些特征来。比如说这段代码,点击按钮的结果是什么?

    <div ng-controller="OuterCtrl">
        <span>{{a}}</span>
        <div ng-controller="InnerCtrl">
            <span>{{a}}</span>
            <button ng-click="a=a+1">a++</button>
        </div>
    </div>
    <script>
    function OuterCtrl($scope) {
        $scope.a = 1;
    }
    
    function InnerCtrl($scope) {
    }
    </script>
    

    点了按钮之后,两个a不一致了,里面的变了,外面的没变,这是为什么?

    
    function Outer() {
        this.a = 1;
    }
    
    function Inner() {
    }
    
    var outer = new Outer();
    Inner.prototype=new Outer();
    var inner = new Inner();
    inner.a = inner.a + 1;
    console.log(outer.a)
    console.log(inner.a)
    

    因为在原型链中,访问一个实例属性时,会在实例本身查找,如果找不到,则搜索实例的原型,如果再搜索不到,则继续沿着原型链往上查找。找到之后则会赋给该实例,所以inner上面就被赋值了一个新的a,outer里面的仍然保持原样,这也就导致了刚才看到的结果。

    上下级共享变量

    比如说,我们就是想上下级共享变量,不创建新的,该怎么办呢?

    
    function Outer() {
        this.data = {
            a: 1
        };
    }
    
    function Inner() {
    }
    
    var outer = new Outer();
    Inner.prototype = outer;
    
    var inner = new Inner();
    
    console.log(outer.data.a);
    console.log(inner.data.a);
    inner.data.a += 1;
    
    console.log(outer.data.a);
    console.log(inner.data.a);
    

    我们可以把a写在一个对象里,当inner找到对象data并赋值到自己身上时,其实是复制了对象的指针(参考高程第4章复制引用类型和基本类型的区别),我们对对象里的属性的改动都会反映到所有引用该对象的元素上。
    反映到AngularJs,我们可以这么写

    <div ng-controller="OuterCtrl">
        <span>{{data.a}}</span>
        <div ng-controller="InnerCtrl">
            <span>{{data.a}}</span>
            <button ng-click="data.a=data.a+1">increase a</button>
        </div>
    </div>
    <script>
    function OuterCtrl($scope) {
        $scope.data = {
            a: 1
        };
    }
    
    function InnerCtrl($scope) {
    }
    </script>
    

    这样点击按钮两个控制器的a都会+1

     

    展开全文
  • 学习原型链之前我们首先要明白什么是原型;那么什么是原型呢?我们来简单学习一下: 只要我们像这样简单的定义一个函数foo(),就可以访问像访问其他对象一样访问该函数的属性: &gt;&gt;&gt;function ...

    1 背景介绍

    1.1什么是原型

    学习原型链之前我们首先要明白什么是原型;那么什么是原型呢?我们来简单学习一下:

    只要我们像这样简单的定义一个函数foo(),就可以访问像访问其他对象一样访问该函数的属性:

    >>>function foo(a,b){return a*b;}

    >>>foo.length

    2

    >>>foo.constructor

    Function()

    其实我们在创建一个函数的时候,这个函数就包括了prototype属性,它的初始值是一个空对象(object),

    >>>typeof foo.prototype

    "object"

    所以我们可以自己在这个空对象中添加属性,像这样:

    >>>foo.prototype = {}

    1.2 原型有什么作用

            简述一下prototype属性的出现:

            第一版浏览器无用户交互—》需要脚本语言—》借鉴C++和Java语言,又想节省服务器资源和时间—》prototype。

             由于所有的实例对象共享同一个prototype对象,那么从外界看起来,prototype对象就好像是实例对象的原型,而实例对象则好像"继承"了prototype对象一样。

              这个属性包含一个对象(以下简称"prototype对象"),所有实例对象需要共享的属性和方法,都放在这个对象里面;那些不需要共享的属性和方法,就放在构造函数里面。

            而实例对象一旦创建,将自动引用prototype对象的属性和方法。也就是说,实例对象的属性和方法,分成两种,一种是本地的,另一种是引用的。

    2 知识剖析

    2.1 原型链是什么

            我们上面说到,每个构造函数在创建时都包含一个属性prototype,其初始值是一个空对象;

     

    原型链(图片来源与网络)

    原型对象结构:

    Function.prototype={ 

     constructor :Function,

    __proto__:parentprototype,

    someprototypeproperties: ... 

     };

           函数的原型对象constructor默认指向函数本身,原型对象除了有原型属性外,为了实现继承,还有一个原型链指针__proto__,该指针指向上一层的原型对象,而上一层的原型对象的结构依然类似,这样利用__proto__一直指向Object的原型对象上,而Object的原型对象用Object.prototype.__proto__ = null表示原型链的最顶端,如此变形成了javascript的原型链继承,同时也解释了为什么所有的javascript对象都具有Object的基本方法。

     

     

     

     

    3 常见问题

    Array.isArray(Array.prototype)输出什么?

    4 解决方案

    Array.prototype是Array构造函数实例的原型,构造函数实例化后仍为数组,所以输出true。

    5 编码实战

    6 扩展思考

     

    7 参考文献

    参考一:Javascript继承机制的设计思想

    参考二:《JavaScript面向对象编程指南》

    参考三:JavaScript 世界万物诞生记

    参考三:JavaScript.The Core(推荐)

    8 更多讨论

    Q1:  prototype与_proto_是什么关系?

    __proto__(隐式原型)、prototype(显式原型)

    A1:   显式原型 explicit prototype property:每一个函数在创建之后都会拥有一个名为prototype的属性,这个属性指向函数的原型对象。

    隐式原型 implicit prototype link:JavaScript中任意对象都有一个内置属性[[prototype]],在ES5之前没有标准的方法访问这个内置属性,但是大多数浏览器都支持通过__proto__来访问。ES5中有了对于这个内置属性标准的Get方法Object.getPrototypeOf().

    Q2:若想访问一个对象的原型,应该使用什么方法?

    获取实例对象obj的原型对象,有三种方法

    1. obj.__proto__

    2. obj.constructor.prototype

    3. Object.getPrototypeOf(obj)

    上面三种方法之中,前两种都不是很可靠。最新的ES6标准规定,__proto__属性只有浏览器才需要部署,其他环境可以不部署。而obj.constructor.prototype在手动改变原型对象时,可能会失效。

    二者的关系:

    隐式原型指向创建这个对象的函数(constructor)的prototype

    Q2:在IE中可以使用_proto_属性吗?

    A:_proto_将在ES6中进行标准化,目前在ES6的草案附录B中。

    Q3:_proto_的兼容性怎么样?

    A:_proto_目前是浏览器的内置属性,不同的浏览器有不同的情况。

    Q3:new function 和 new object 的差别?

    A3:JS之中没有new fuction,我的理解是通过构造函数实例化一个对象?

    new Object()就是通过Objec()t这个函数产生的,它会继承Object的所有东西;

    同样的,通过构造函数new出来(实例化)的,会继承构造函数里面的属性和方法。js的new关键字传承的机制,这点倒是和其他语言差不多。

    展开全文
  • 题目点评 这道题目是属于JavaScript比较难理解的知识点,涉及到的知识也非常抽象深奥,属于JavaScript面向对象思维范畴,如果没有一点面向对象的编程思维的同学,想必是难倒了,...原型什么? 在JavaScript中原型是
  • 简述原型链什么,有什么用处?若想访问一个对象的原型,应该使用什么方法? 1.背景介绍 1.1普通对象与函数对象  JavaScript 中,万物皆对象!但对象也是有区别的。分为普通对象和函数对象,Object ,Function ...
  • 原型链什么是原型链?新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一...
  • 在我初学 JS 语言的继承机制原型和原型链的时候,我一直理解不了这种设计机制,再加上之前原有对 Java继承的理解,在学习 JS 继承机制的设计上踩了一个大坑,很多知识点前期都是死记硬背,无法真正的理解它的设计...
  • 【原型和原型链什么是原型和原型链

    万次阅读 多人点赞 2018-06-21 15:21:55
    一、原型 ①所有引用类型都有一个__proto__(隐式原型)属性,属性值是一个普通的对象 ②所有函数都有一个prototype(原型)属性,属性值是一个普通的对象 ③所有引用类型的__proto__属性指向它...二、原型链 ...
  • 原型:JS声明构造函数(用来实例化对象的函数)时,会在内存中创建一个对应的对象,这个对象就是原函数的原型。构造函数默认有一个prototype属性,prototype的值指向函数的原型。同时原型中也有一个constructor属性,...
  • 本文实例讲述了javascript 原型与原型链的理解及应用。分享给大家供大家参考,具体如下: javascript中一切皆对象,但是由于没有Class类的概念,所以就无法很好的表达对象与对象之间的关系了。 比如对象A与对象B之间...
  • 什么是原型链原型链通俗易懂的理解就是可以把它想象成一个链条,互相连接构成一整串链子! 而原型链中就是实例对象和原型对象之间的链接。每个函数都有一个prototype属性,这个prototype属性就是我们的原型对象...
  • 一、什么是原型链? 简单回顾下构造函数,原型和实例的关系:  每个构造函数(constructor)都有一个原型对象(prototype),原型对象都包含一个指向构造函数的指针,而实例(instance)都包含一个指向原型对象的内部指针. ...
  • 主要介绍了js对象继承之原型链继承,以实例形式分析了原型链继承的实现方法与注意事项,具有一定参考借鉴价值,需要的朋友可以参考下
  • 对象的隐式原型的值为其对应构造函数的显式原型的值。 function Fn(){} //显式原型--->空的Object对象 console.log(Fn.prototype); //隐式原型---> var fn = new Fn();//this.__proto__ = Fn...
  • 主要介绍了JavaScript作用域、闭包、对象与原型链,结合实例形式总结分析了javascript中变量与函数的作用域、闭包、对象、原形链相关概念、用法及注意事项,需要的朋友可以参考下
  • 1、原型原型——构造函数的属性prototype对象的属性__proto__隐式原型、显式原型原型对象prototype的属性constructor2、原型链 1、原型 原型——构造函数的属性prototype es6 才提出了类的概念:之前使用构造函数...
  • javascript中的原型与原型链

    千次阅读 多人点赞 2020-05-09 17:07:46
    一、什么是原型 原型:每一个javascript对象(除null外)创建的时候,都会与之关联另一个对象,这个对象就是我们所说的原型,每一个对象都会从原型中“继承”属性。 例如 var obj = new Object(); 创建一个对象的...
  • 原型链什么特点? 构造函数原型 prototype 对象原型 __ proto __ 回答思路: 1.构造函数原型 2.对象原型 3.原型链 4.原型链的特点 在 js 中我们是使用构造函数来新建一个对象的,每一个构造函数的内部都有一个 ...
  • 前端JS原型、原型链

    千次阅读 2018-09-16 14:15:39
    首先来说一下什么是原型、原型链和构造函数。 原型:JS中的对象都包含了一个prototype的内部属性,这个属性所对应的就是该对象的原型。 原型链原型链是是有一些用来继承和共享属性的对象组成的对象链。并且原型...
  • 每创建一个函数,内部都会带有一个指向具有共享属性和方法的 prototype 属性,这个属性是一个对象,称为原型(简单来说,就是由该函数创建的实例,都可以通过这个原型来共享属性和方法) 每个原型对象中都有 ...
  • 前段时间我朋友从上家公司离职,上周开始了前端面试(现在已经上班了),一天我下班回到出租房时,他问我原型链什么?一时半会我竟然也不知道从何说起能够让他很清楚的明白,又忽然想起之前我一个朋友也问过我闭包的...
  • 之前对js中的原型链和原型对象有所了解,每当别人问我什么是原型链和原型对象时,我总是用很官方(其实自己不懂)的解释去描述。有一句话说的好:如果你不能把一个很复杂的东西用最简单的话语描述出来,那就说明你...
  • 浅谈Vue原型链

    千次阅读 2020-11-09 13:44:48
    浅谈Vue原型链 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>...
  • 一、原型 ①所有引用类型都有一个__proto__(隐式原型)属性,...二、原型链 当访问一个对象的某个属性时,会先在这个对象本身属性上查找,如果没有找到,则会去它的__proto__隐式原型上查找,即它的构造函数的proto...
  • 什么是原型、原型链、继承?

    千次阅读 2019-05-23 19:50:44
    prototype的概念: 每一个构造函数都有一个prototype属性,这个属性会在生成实例的时候,成为实例对象的原型对象。javascript的每个对象都继承另一个对象,后者称为“原型”对象。 prototype原型: ...
  • 原型和原型链 原型 在JavaScript中有这么一句话万物皆可对象 在声明一个函数跟对象的时候 它在声明的时候就有一个原型对象prototype 这个属性指向函数的原型对象,并且这个属性是一个对象数据类型的值。 而...
  • 主要和大家一起深入理解JS原型与原型链,原型是JavaScript中一个比较难理解的概念,本文为大家解决这个难题,感兴趣的小伙伴们可以参考一下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 223,044
精华内容 89,217
关键字:

原型链是什么