prototype_prototype模式 - CSDN
精华内容
参与话题
  • js中的prototype有什么作用?

    千次阅读 2017-05-10 20:35:17
    prototype对象是实现面向对象的一个重要机制。每个函数也是一个对象,它们对应的类就是 function,每个函数对象都具有一个子对象prototypePrototype 表示了该函数的原型, prototype表示了一个类的属性的...

    1、

    prototype对象是实现面向对象的一个重要机制。每个函数也是一个对象,它们对应的类就是

    function,每个函数对象都具有一个子对象prototype。Prototype 表示了该函数的原型,

    prototype表示了一个类的属性的集合。当通过new来生成一个类的对象时,prototype对象的属

    性就会成为实例化对象的属性。

    下面以一个例子来介绍prototype的应用,代码如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <script language="javascript">
    //定义一个空类
    function HelloClass(){
    }
    //对类的prototype对象进行修改,增加方法method
    HelloClass.prototype.method=function(){
    alert("prototype测试");
    }
    var obj=new HelloClass(); //创建类HelloClass的实例
    obj.method(); //调用obj的method方法
    </script>

    当用new创建一个对象时,prototype对象的属性将自动赋给所创建的对象,例如:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    <script language="javascript">
    //定义一个只有一个属性的类
    function HelloClass(){
    this.name="javakc";
    }
    //使用函数的prototype属性给类定义新属性
    HelloClass.prototype.showName=function(){
    alert(this.name);
    }
    var obj=new HelloClass(); //创建类HelloClass的一个实例
    //调用通过prototype原型对象定义的showName方法
    obj.showName();
    </script>

    56

    2、利用prototype实现继承

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    <script language="javascript">
    function HelloClass(){
    //构造方法
    }
    function HelloSubClass(){
    //构造方法
    }
    HelloSubClass.prototype=HelloClass.prototype;
    HelloSubClass.prototype.Propertys="name";
    HelloSubClass.prototype.subMethods=function(){
    //方法实现代码
    alert("in Methods");
    }
    var obj=new HelloSubClass();
    obj.subMethods();
    </script>

    在以上的代码中,首先是HelloSubClass具有了和HelloClass一样的prototype,如果不考

    虑构造方法,则两个类是等价的。随后,又通过prototype给HelloSubClass赋予了额外的属性和方法

    所以HelloSubClass是在HelloClass的基础上增加了新的属性和方法,从而实现了类的继承。

    展开全文
  • JS中prototype介绍

    万次阅读 多人点赞 2019-06-19 20:41:22
    用过JavaScript的同学们肯定都对prototype如雷贯耳,但是这究竟是个什么东西却让初学者莫衷一是,只知道函数都会有一个prototype属性, 可以为其添加函数供实例访问,其它的就不清楚了,最近看了一些 JavaScript高级...

    转载 原文点这里
    用过JavaScript的同学们肯定都对prototype如雷贯耳,但是这究竟是个什么东西却让初学者莫衷一是,只知道函数都会有一个prototype属性,
    可以为其添加函数供实例访问,其它的就不清楚了,最近看了一些 JavaScript高级程序设计,终于揭开了其神秘面纱。
    每个函数都有一个prototype属性,这个属性是指向一个对象的引用,这个对象称为原型对象,原型对象包含函数实例共享的方法和属性,
    也就是说将函数用作构造函数调用(使用new操作符调用)的时候,新创建的对象会从原型对象上继承属性和方法。

    私有变量、函数

    在具体说prototype前说几个相关的东东,可以更好的理解prototype的设计意图。
    之前写的一篇JavaScript 命名空间文章中提到过JavaScript的函数作用域,在函数内定义的变量和函数如果不对外提供接口,那么外部将无法访问到,也就是变为私有变量和私有函数。
    复制代码 代码如下:

    function Obj(){
                    var a=0; //私有变量
                    var fn=function(){ //私有函数
    
                    }
                }
    

    这样在函数对象Obj外部无法访问变量a和函数fn,它们就变成私有的,只能在Obj内部使用,即使是函数Obj的实例仍然无法访问这些变量和函数
    复制代码 代码如下:

    var o=new Obj();
                console.log(o.a); //undefined
                console.log(o.fn); //undefined
    

    静态变量、函数

    当定义一个函数后通过 “.”为其添加的属性和函数,通过对象本身仍然可以访问得到,但是其实例却访问不到,这样的变量和函数分别被称为静态变量和静态函数,用过Java、C#的同学很好理解静态的含义。
    复制代码 代码如下:

    function Obj(){
                }
                Obj.a=0; //静态变量
                Obj.fn=function(){ //静态函数   
                }
    
                console.log(Obj.a); //0
                console.log(typeof Obj.fn); //function
    
                var o=new Obj();
                console.log(o.a); //undefined
                console.log(typeof o.fn); //undefined
    

    实例变量、函数

    在面向对象编程中除了一些库函数我们还是希望在对象定义的时候同时定义一些属性和方法,实例化后可以访问,JavaScript也能做到这样
    复制代码 代码如下:

    function Obj(){
                    this.a=[]; //实例变量
                    this.fn=function(){ //实例方法
    
                    }
                }
    
                console.log(typeof Obj.a); //undefined
                console.log(typeof Obj.fn); //undefined
    
                var o=new Obj();
                console.log(typeof o.a); //object
                console.log(typeof o.fn); //function
    

    这样可以达到上述目的,然而
    复制代码 代码如下:

    function Obj(){
                    this.a=[]; //实例变量
                    this.fn=function(){ //实例方法
    
                    }
                }
    
                var o1=new Obj();
                o1.a.push(1);
                o1.fn={};
                console.log(o1.a); //[1]
                console.log(typeof o1.fn); //object
                var o2=new Obj();
                console.log(o2.a); //[]
                console.log(typeof o2.fn); //function
    

    上面的代码运行结果完全符合预期,但同时也说明一个问题,在o1中修改了a和fn,而在o2中没有改变,由于数组和函数都是对象,是引用类型,
    这就说明o1中的属性和方法与o2中的属性与方法虽然同名但却不是一个引用,而是对Obj对象定义的属性和方法的一个复制。
    这个对属性来说没有什么问题,但是对于方法来说问题就很大了,因为方法都是在做完全一样的功能,但是却又两份复制,如果一个函数对象有上千和实例方法,
    那么它的每个实例都要保持一份上千个方法的复制,这显然是不科学的,这可肿么办呢,prototype应运而生。

    prototype

    无论什么时候,只要创建了一个新函数,就会根据一组特定的规则为该函数创建一个prototype属性,默认情况下prototype属性会默认获得一个constructor(构造函数)属性,
    这个属性是一个指向prototype属性所在函数的指针,有些绕了啊,写代码、上图!
    复制代码 代码如下:

    function Person(){
    
                }
    

    在这里插入图片描述
    根据上图可以看出Person对象会自动获得prototyp属性,而prototype也是一个对象,会自动获得一个constructor属性,该属性正是指向Person对象。
    当调用构造函数创建一个实例的时候,实例内部将包含一个内部指针(很多浏览器这个指针名字为__proto__)指向构造函数的prototype,这个连接存在于实例和构造函数的prototype之间,
    而不是实例与构造函数之间。
    复制代码 代码如下:

    function Person(name){
                    this.name=name;
                }
    
                Person.prototype.printName=function(){
                    alert(this.name);
                }
    
                var person1=new Person('Byron');
                var person2=new Person('Frank');
    

    在这里插入图片描述
    Person的实例person1中包含了name属性,同时自动生成一个__proto__属性,该属性指向Person的prototype,可以访问到prototype内定义的printName方法,大概就是这个样子的

    在这里插入图片描述

    写段程序测试一下看看prototype内属性、方法是能够共享
    复制代码 代码如下:

    function Person(name){
                    this.name=name;
                }
    
                Person.prototype.share=[];
    
                Person.prototype.printName=function(){
                    alert(this.name);
                }
    
                var person1=new Person('Byron');
                var person2=new Person('Frank');
    
                person1.share.push(1);
                person2.share.push(2);
                console.log(person2.share); //[1,2]
    

    果不其然!实际上当代码读取某个对象的某个属性的时候,都会执行一遍搜索,目标是具有给定名字的属性,搜索首先从对象实例开始,如果在实例中找到该属性则返回,
    如果没有则查找prototype,如果还是没有找到则继续递归prototype的prototype对象,直到找到为止,如果递归到object仍然没有则返回错误。
    同样道理如果在实例中定义如prototype同名的属性或函数,则会覆盖prototype的属性或函数。
    复制代码 代码如下:

    function Person(name){
                    this.name=name;
                }
    
                Person.prototype.share=[];
                var person=new Person('Byron');
                person.share=0;
    
                console.log(person.share); //0而不是prototype中的[]
    

    构造简单对象

    当然prototype不是专门为解决上面问题而定义的,但是却解决了上面问题。了解了这些知识就可以构建一个科学些的、复用率高的对象,如果希望实例对象的属性或函数则定义到prototype中,
    如果希望每个实例单独拥有的属性或方法则定义到this中,可以通过构造函数传递实例化参数。
    复制代码 代码如下:

    function Person(name){
                    this.name=name;
                }
    
                Person.prototype.share=[];
    
                Person.prototype.printName=function(){
                    alert(this.name);
                }
    
    展开全文
  •   作为一名前端工程师,必须搞懂JS中的prototype、__proto__与constructor属性,相信很多初学者对这些属性存在许多困惑,容易把它们混淆,本文旨在帮助大家理清它们之间的关系并彻底搞懂它们。这里说明一点,__...

    提示:不要排斥,静下心来,认真读完,你就搞懂了!(可以先看一下最后的总结部分再回过头来完整看完)

    1. 前言

      作为一名前端工程师,必须搞懂JS中的prototype__proto__constructor属性,相信很多初学者对这些属性存在许多困惑,容易把它们混淆,本文旨在帮助大家理清它们之间的关系并彻底搞懂它们。这里说明一点,__proto__属性的两边是各由两个下划线构成(这里为了方便大家看清,在两下划线之间加入了一个空格:_ _proto_ _,读作“dunder proto”,“double underscore proto”的缩写),实际上,该属性在ES标准定义中的名字应该是[[Prototype]],具体实现是由浏览器代理自己实现,谷歌浏览器的实现就是将[[Prototype]]命名为__proto__,大家清楚这个标准定义与具体实现的区别即可(名字有所差异,功能是一样的),可以通过该方式检测引擎是否支持这个属性:Object.getPrototypeOf({__proto__: null}) === null。本文基于谷歌浏览器(版本 72.0.3626.121)的实验结果所得。
       现在正式开始! 让我们从如下一个简单的例子展开讨论,并配以相关的图帮助理解:

    function Foo() {...};
    let f1 = new Foo();
    

    以上代码表示创建一个构造函数Foo(),并用new关键字实例化该构造函数得到一个实例化对象f1。这里稍微补充一下new操作符将函数作为构造器进行调用时的过程:函数被调用,然后新创建一个对象,并且成了函数的上下文(也就是此时函数内部的this是指向该新创建的对象,这意味着我们可以在构造器函数内部通过this参数初始化值),最后返回该新对象的引用,详细请看:详解JavaScript中的new操作符。虽然是简简单单的两行代码,然而它们背后的关系却是错综复杂的,如下图所示:
    整体的联系看到这图别怕,让我们一步步剖析,彻底搞懂它们!
      图的说明:右下角为图例,红色箭头表示__proto__属性指向、绿色箭头表示prototype属性的指向、棕色实线箭头表示本身具有的constructor属性的指向,棕色虚线箭头表示继承而来的constructor属性的指向;蓝色方块表示对象,浅绿色方块表示函数(这里为了更好看清,Foo()仅代表是函数,并不是指执行函数Foo后得到的结果,图中的其他函数同理)。图的中间部分即为它们之间的联系,图的最左边即为例子代码。

    2. _ _ proto _ _ 属性

      首先,我们需要牢记两点:①__proto__constructor属性是对象所独有的;② prototype属性是函数所独有的。但是由于JS中函数也是一种对象,所以函数也拥有__proto__constructor属性,这点是致使我们产生困惑的很大原因之一。上图有点复杂,我们把它按照属性分别拆开,然后进行分析:
    __proto__
      第一,这里我们仅留下 __proto__ 属性,它是对象所独有的,可以看到__proto__属性都是由一个对象指向一个对象,即指向它们的原型对象(也可以理解为父对象),那么这个属性的作用是什么呢?它的作用就是当访问一个对象的属性时,如果该对象内部不存在这个属性,那么就会去它的__proto__属性所指向的那个对象(可以理解为父对象)里找,如果父对象也不存在这个属性,则继续往父对象的__proto__属性所指向的那个对象(可以理解为爷爷对象)里找,如果还没找到,则继续往上找…直到原型链顶端null(可以理解为原始人。。。),再往上找就相当于在null上取值,会报错(可以理解为,再往上就已经不是“人”的范畴了,找不到了,到此结束,null为原型链的终点),由以上这种通过__proto__属性来连接对象直到null的一条链即为我们所谓的原型链
      其实我们平时调用的字符串方法、数组方法、对象方法、函数方法等都是靠__proto__继承而来的。

    3. prototype属性

      第二,接下来我们看 prototype 属性:
    prototype属性  prototype属性,别忘了一点,就是我们前面提到要牢记的两点中的第二点,它是函数所独有的,它是从一个函数指向一个对象。它的含义是函数的原型对象,也就是这个函数(其实所有函数都可以作为构造函数)所创建的实例的原型对象,由此可知:f1.__proto__ === Foo.prototype,它们两个完全一样。那prototype属性的作用又是什么呢?它的作用就是包含可以由特定类型的所有实例共享的属性和方法,也就是让该函数所实例化的对象们都可以找到公用的属性和方法。任何函数在创建的时候,其实会默认同时创建该函数的prototype对象。

    4. constructor属性

      最后,我们来看一下 constructor 属性:
    constructor属性  constructor属性也是对象才拥有的,它是从一个对象指向一个函数,含义就是指向该对象的构造函数,每个对象都有构造函数(本身拥有或继承而来,继承而来的要结合__proto__属性查看会更清楚点,如下图所示),从上图中可以看出Function这个对象比较特殊,它的构造函数就是它自己(因为Function可以看成是一个函数,也可以是一个对象),所有函数和对象最终都是由Function构造函数得来,所以constructor属性的终点就是Function这个函数。
    constructor继承
      感谢网友的指出,这里解释一下上段中“每个对象都有构造函数”这句话。这里的意思是每个对象都可以找到其对应的constructor,因为创建对象的前提是需要有constructor,而这个constructor可能是对象自己本身显式定义的或者通过__proto__在原型链中找到的。而单从constructor这个属性来讲,只有prototype对象才有。每个函数在创建的时候,JS会同时创建一个该函数对应的prototype对象,而函数创建的对象.__proto__ === 该函数.prototype,该函数.prototype.constructor===该函数本身,故通过函数创建的对象即使自己没有constructor属性,它也能通过__proto__找到对应的constructor,所以任何对象最终都可以找到其构造函数(null如果当成对象的话,将null除外)。如下:
    constructor说明

    5. 总结

       总结一下:

    1. 我们需要牢记两点:①__proto__constructor属性是对象所独有的;② prototype属性是函数所独有的,因为函数也是一种对象,所以函数也拥有__proto__constructor属性。
    2. __proto__属性的作用就是当访问一个对象的属性时,如果该对象内部不存在这个属性,那么就会去它的__proto__属性所指向的那个对象(父对象)里找,一直找,直到__proto__属性的终点null,再往上找就相当于在null上取值,会报错。通过__proto__属性将对象连接起来的这条链路即我们所谓的原型链
    3. prototype属性的作用就是让该函数所实例化的对象们都可以找到公用的属性和方法,即f1.__proto__ === Foo.prototype
    4. constructor属性的含义就是指向该对象的构造函数,所有函数(此时看成对象了)最终的构造函数都指向Function

      本文就此结束了,希望对那些对JS中的prototype__proto__constructor属性有困惑的同学有所帮助。

    最后,感谢这两篇博文,本文中的部分内容参考自这两篇博文:
    https://www.cnblogs.com/xiaohuochai/p/5721552.html
    https://www.cnblogs.com/Narcotic/p/6899088.html

    若对你有帮助,可以支持一下作者创作更多好文章哦~
    一分钱也是爱~
    赞赏码

    展开全文
  • 深入理解prototype(原型对象)

    千次阅读 2017-05-14 17:08:15
    对JavaScript中原型模式的理解一:什么是原型对象?...其实我们平常的叫法就是指:prototype就是通过该构造函数创建的某个实例的原型对象,但是其实prototype是每个构造函数的属性而已,只能说万物皆

    对JavaScript中原型模式的理解

    一:什么是原型对象?有什么优点?
       简单的来说,无论何时,我们创建的每一个函数都有一个prototype属性,这个属性是一个指针,指向一个对象,这个对象包含了通过调用该构造函数所创建的对象共享的属性和方法。其实我们平常的叫法就是指:prototype就是通过该构造函数创建的某个实例的原型对象,但是其实prototype是每个构造函数的属性而已,只能说万物皆对象罢了。
       原型对象的优点是:所有的对象实例都可以共享它包含的属性和方法。这一点可以在构造函数里就可以看出来,因为构造函数在函数里面就定义了对象的实例信息,而原型对象可以在任何地方定义属性和方法。例如:

    function Person(){}
    Person.prototype.name = 'bangbang';
    Person.prototype.age = 18;
    Person.prototype.job = 'programmer';
    Person.prototype.dream = function(){
        console.log('Change yourself');
    }
    
    var person1 = new Person();
    person1.dream();    //Change yourself
    
    var person2 = new Person();
    person2.dream();
    //判断两个实例继承的方法和属性是否全等
    console.log(person1.dream === person2.dream);
    console.log(person1.age === person2.age);

    由以上的代码可以看出它比构造函数方法的好处就是,person1和person2访问的都是同一个dream()函数,即他们的属性和方法都是共享的。
    二:深入理解原型对象和prototype?
      由上面可知,我们创建了一个函数,就会根据ECMAscript特定的规则为该函数创建一个prototype属性,这个属性指向函数的原型对象。在默认情况下,所有原型对象都会自动获得一个constructor(构造函数)属性,这个属性是一个指向prototype属性所在函数的指针。就像前面的例子,Person.prototype.constructor指向Person,而通过这个构造函数,我们还可以继续为原型对象添加其他属性和方法。
      下面,我们就开始从原理上说明上面代码运行机制的:
    1. 创建一个自定义的构造函数后,它的原型对象默认只会有constructor属性,其他属性和方法都是从Object继承而来的;
    2. 当调用构造函数创建一个新实例后,该实例的内部将包含一个指针,指向构造函数的原型对象。ECMA5中称这个指针叫[[prototype]]。虽然在脚本中没有标准的方式访问[[prototype]],但Firefox、Safari和Chrome在每个对象上都支持一个属性proto;而在其他浏览器中,这个属性则是完全不可见的。不过要明确的真正一点就是,这个连接存在于 实例构造函数的原型对象 之间,而不是存在于实例和构造函数之间,用前面使用Person构造函数和Person.prototype创建实例的代码为例,各个对象之间的关系如下图所示:
    这里写图片描述
      上图展示了Person构造函数、Person的原型以及Person现有的两个实例之间的关系,再次,Person.prototype指向了原型对象,而Person.prototype.constructor又指回了Person。原型对象中除了包含constructor属性之外,还包括后来添加的其他属性。Person的每个实例——person1和person2都包含一个内部属性,该属性指向了Person.prototype;换句话说,他们与构造函数没有直接关系。
      注意:虽然这两个实例都不包含属性和方法,但我们却可以调用name、age、job、dream()方法和属性,这是通过查找对象属性的过程来实现的。
      虽然我们不能访问到[[prototype]],但可以通过isPrototypeOf()方法来确定对象之间是否存在这种关系。因为这两个实例都有一个指向Person.prototype的指针,因此,都返回true如下所示:

    console.log(Person.prototype.isPrototypeOf(person1));//true
    console.log(Person.prototype.isPrototypeOf(person2));//true

    ECMA5增加了一个方法,叫Object.getPrototypeOf(),这个方法返回[[Prototype]]的值,也就是括号里面对象的原型,例如:

    console.log(Object.getPrototypeOf(person1) == Person.prototype; // true
    console.log(Object.getPrototypeOf(person1).name); //'bangbang'

    用hasOwnProperty()方法可以检测一个属性是存在于实例中还是原型中。还是上面的例子:

    console.log(person1.hasOwnProperty('name'); //false
    person1.name = 'qiqi';
    console.log(person1.hasOwnProperty('name'); //true —— 来自实例
    console.log(person1.name);  //'qiqi' ——来自实例
    delete person1.name;
    console.log(person1.name); //'bangbang' —— 来自原型
    console.log(person1.hasOwnProperty('name'); //true ——来自原型

    当我们为person1添加name属性的时候,如下图图所示:
    这里写图片描述
    三:组合使用构造函数模式和原型模式优点最多:
      以上我讲述了用构造函数生成对象的原理以及生成的对象和原型对象之间的关系,原理了解了这么多,我么当然需要知道怎么在合适的时候用他们。创建自定义类型的最常见方式就是组合使用构造函数模式和原型模式。构造函数模式用于定义实例属性,而原型模式用于定义方法和共享的属性。每个实例都会有自己的一份实例属性的副本,但同时又共享着对方发的引用,最大限度的节省了内存。如下例所示:

            function Person(name,age,job){
                this.name = name;
                this.age = age;
                this.job = job;
                this.love = ['qiqi','lili'];
            }
            Person.prototype = {
                constructor : Person,
                dream : function(){
                    console.log(this.love[0]);
                }
            }
            var person1 = new Person('bangbang',18,'programmer');
            var person2 = new Person('xiaoya',18,'teacher');
            console.log(person1.love);
            console.log(person2.love)
            console.log(person1.love === person2.love);  //false
            //给person1的love属性添加元素
            person1.love.push('niuniu');
            console.log(person1.love)  //["qiqi", "lili", "niuniu"]
            console.log(person2.love)  //["qiqi", "lili"]
            console.log(person1.love === person2.love);  //false
            console.log(person1.dream === person2.dream);//true

    以上这种模式是ECMAscript中使用最广泛的,认同度最高的,优点最多的创建自定义类型的方法,也就是创建JavaScript中类的方法。

    展开全文
  • js中的prototype

    千次阅读 2018-11-05 11:30:56
    每个函数是一个对象,它们对应的类就是function,每个函数对象都具有一个子对象prototype(表示该函数的原型),prototype表示了一个类的属性的集合。当通过new来生成一个类的对象时,prototype对象的属性就会成为实例...
  • JavaScript中prototype用法

    千次阅读 2016-12-17 14:23:31
    1 概述 大部分面向对象的编程语言,都是以类class作为对象的基础语法,js语言不是如此,它的面向对象编程基于‘原型对象’。 首先说说构造函数的缺点: js通过构造函数生成新的对象,因此构造函数可以视为独享的模版...
  • 找了好久,才找到下载资源 prototype_1.7.3.js 最新版本
  • 彻底理解什么是原型链,prototype和__proto__的区别。

    万次阅读 多人点赞 2018-04-19 20:45:12
    1.Javascript中所有的对象都是Object的实例,并继承Object.prototype的属性和方法,也就是说,Object.prototype是所有对象的爸爸。(个人感觉搞清楚这一点很重要) 。 在对象创建时,就会有一些预定义的属性,其中...
  • 再说说__proto__和prototype以及js的继承

    千次阅读 2018-08-22 20:37:48
    1.proto和prototype JS中的原型链已经是一个老生常谈的问题,毕竟也是JS 这门语言的特色之一了。 首先“万物皆对象“,虽然这句话一直有争议,但是有它的道理的,null类型这些的争论这里就不说了。 对象中有个...
  • prototype  prototype是函数对象上面预设的对象属性  1. JS中所有的东西都是对象,每个对象都有prototype这个属性,这个属性是一个对象(object)  2. JS中所有的东西都由Object衍生而来, 即所有东西原型链的...
  • 什么是Prototype ?

    2012-08-07 14:31:50
    Prototype概述(介绍什么是Prototype) - 学习如何使用Prototype JavaScript框架操纵DOM和AJAX. 什么是Prototype ? Prototype是一个JavaScript框架,旨在简化动态Web应用程序的开发。Prototype是由山姆...
  • 对以上程序,在编译驱动的时候会出现以下warning: 在网上查到解决办法是:即使函数括号内没有任何参数,也要加一个void类型,来避免这种warning: 解决如下:
  •  error: no previous prototype for function 当我们使用了一个函数,但是没有在头文件中声明时,就会出这个错误。 有时是因为去掉了static。static的函数使用和普通函数还是有区别的。static函数不需要...
  • 详解prototype与__proto__区别

    万次阅读 多人点赞 2016-12-08 18:50:27
    Each constructor is a function that has a property named “prototype” that is used to implement prototype-based inheritance and shared properties. Every object created by a constructor has an ...
  • Vue.prototype详解

    万次阅读 2018-11-07 11:04:18
    如果需要设置全局变量,在main.js中,Vue实例化的代码里添加。 ...不想污染全局作用域。这种情况下,你可以通过在原型上定义它们使其在每个 Vue 的实例中可用。...Vue.prototype.$appName = 'My App' 这样 $appNam...
  • javascript Prototype constructor的理解(一)

    万次阅读 多人点赞 2014-03-26 15:03:29
    javascript prototype constructor
  • Javascript中的__proto__、prototype、constructor

    万次阅读 多人点赞 2016-08-10 19:21:48
    今天重温了下Javacript,给大家带来一篇Javascript博文,相信对于Javacriptyou'y
  • 当在z-stack协议栈中,添加自己的c文件。编译时出现错误,而全部错误都是一个性质。...Error[Pa045]: function "" has no prototype 去掉 Require prototype选项,重新编译即可。应该是一个编译顺序问题。
  • vue的prototype绑定方法

    千次阅读 2018-10-26 15:07:04
    在main.js中(七牛为例) import {uploadQN} from "./util/upload.js"; Vue.prototype.uploadQN = uploadQN; 使用直接 this.uploadQN();
  • 出现Object prototype may only be an Object or null: undefined这个问题,有可能是你在基类中导入了子类,所以在编译时就出错了,根据国外网友的回答这个问题可能在TypeScript后续版本中修复
1 2 3 4 5 ... 20
收藏数 355,967
精华内容 142,386
关键字:

prototype