精华内容
下载资源
问答
  • 之前对js中的原型链和原型对象有所了解,每当别人问我什么是原型链和原型对象时,我总是用很官方(其实自己不懂)的解释去描述。有一句话说的好:如果你不能把一个很复杂的东西用最简单的话语描述出来,那就说明你...
  • 本文实例讲述了javascript 原型原型链的理解及应用。分享给大家供大家参考,具体如下: javascript中一切皆对象,但是由于没有Class类的概念,所以就无法很好的表达对象与对象之间的关系了。 比如对象A与对象B之间...
  • 主要和大家一起深入理解JS原型原型链,原型JavaScript中一个比较难理解的概念,本文为大家解决这个难题,感兴趣的小伙伴们可以参考一下
  • 对于js原型原型链的理解

    万次阅读 多人点赞 2019-06-23 22:20:23
    JavaScript是一门基于原型的语言,在软件设计模式中,有一种模式叫做原型模式,JavaScript正是利用这种模式而被创建出来 原型模式是用于创建重复的对象,同时又能保证性能,这种类型的设计模式属于创建型模式,它...

    一、原型与原型链

    1. JavaScript是一门基于原型的语言,在软件设计模式中,有一种模式叫做原型模式,JavaScript正是利用这种模式而被创建出来
    2. 原型模式是用于创建重复的对象,同时又能保证性能,这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。原型模式的目的是用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象,也就是说利用已有的一个原型对象,可以快速地生成和原型对象一样的新对象实例
    3. 原型:一个可以被复制(或者叫克隆)的一个类,通过复制原型可以创建一个一模一样的新对象,也可以说原型就是一个模板,在设计语言中更准确的说是一个对象模板
      1)原型是定义了一些公用的属性和方法,利用原型创建出来的新对象实例会共享原型的所有属性和方法
      实例代码:
        // 创建原型
        var Person = function(name){
            this.name = name;
        };
    
        // 原型的方法
       Person.prototype.sayHello = function(){
           console.log(this.name+",hello");
       };
    
       // 实例化创建新的原型对象,新的原型对象会共享原型的属性和方法
       var person1 = new Person("zhangsan");
       var person2 = new Person("lisi");
    
       // zhangsan,hello
       person1.sayHello();
       // lisi,hello
       person2.sayHello();
    

    2)严格模式下,原型的属性和方法还是会被原型实例所共享的
    实例代码:

        // 开启严格模式,原型的属性和方法还是会被原型实例所共享的
       "use strict";
    
        // 创建原型
        var Person = function(name){
            this.name = name;
        };
    
        // 原型的方法
       Person.prototype.sayHello = function(){
           console.log(this.name+",hello");
       };
    
       // 实例化创建新的原型对象,新的原型对象会共享原型的属性和方法
       var person1 = new Person("zhangsan");
       var person2 = new Person("lisi");
    
       // zhangsan,hello
       person1.sayHello();
       // lisi,hello
       person2.sayHello();
    

    3)通过原型创建的新对象实例是相互独立的,为新对象实例添加的方法只有该实例拥有这个方法,其它实例是没有这个方法的
    实例代码:

        // 创建原型
        var Person = function(name){
            this.name = name;
        };
    
        // 原型的方法
       Person.prototype.sayHello = function(){
           console.log(this.name+",hello");
       };
    
       // 实例化创建新的原型对象,新的原型对象会共享原型的属性和方法
       var person1 = new Person("zhangsan");
       var person2 = new Person("lisi");
    
       // zhangsan,hello
       person1.sayHello();
       // lisi,hello
       person2.sayHello();
    
       
       // 为新对象实例添加方法
       // 通过原型创建的新对象实例是相互独立的
       person1.getName = function(){
           console.log(this.name);
       }
    
       // zhangsan
       person1.getName();
       // Uncaught TypeError: person2.getName is not a function
       person2.getName();
    

    4)原型的总结

    • 所有引用类型都有一个__proto__(隐式原型)属性,属性值是一个普通的对象
    • 所有函数都有一个prototype(原型)属性,属性值是一个普通的对象
    • 所有引用类型的__proto__属性指向它构造函数的prototype

    5)函数的原型prototype:函数才有prototype,prototype是一个对象,指向了当前构造函数的引用地址
    6)函数的原型对象__proto__:所有对象都有__proto__属性, 当用构造函数实例化(new)一个对象时,会将新对象的__proto__属性指向 构造函数的prototype
    7)原型对象和函数的原型的关系
    在这里插入图片描述
    说明

    • 所有函数的__proto__都是指向Function的prototype
    • 构造函数new出来的对象__proto__指向构造函数的prototype
    • 非构造函数实例化出的对象或者对象的prototype的__proto__指向Object的prototype
      Object的prototype指向null

    8)所有的原型对象都会自动获得一个 constructor(构造函数)属性,这个属性(是一个指针)指向 prototype 属性所在的函数(Person)
    9)实例的构造函数属性(constructor)指向构造函数 :person1.constructor == Person
    10)原型对象(Person.prototype)是 构造函数(Person)的一个实例
    11)原型的分类:
    隐式原型(_proto_):上面说的这个原型是JavaScript中的内置属性[[prototype]],此属性继承自object对象,在脚本中没有标准的方式访问[[prototype]],但Firefox、Safari和Chrome在每个对象上都支持一个属性_proto_,隐式原型的作用是用来构成原型链,实现基于原型的继承
    显示原型(prototype):每一个函数在创建之后,便会拥有一个prototype属性,这个属性指向函数的原型对象,显示原型的作用是用来实现基于原型的继承与属性的共享
    12)原型的使用方式
    通过给Calculator对象的prototype属性赋值对象字面量来设定Calculator对象的原型
    在赋值原型prototype的时候使用function立即执行的表达式来赋值,可以封装私有的function,通过return的形式暴露出简单的使用名称,以达到public/private的效果

    1. 原型链
      1)原型链:原型链是原型对象创建过程的历史记录,当访问一个对象的某个属性时,会先在这个对象本身属性上查找,如果没有找到,则会去它的__proto__隐式原型上查找,即它的构造函数的prototype,如果还没有找到就会再在构造函数的prototype的__proto__中查找,这样一层一层向上查找就会形成一个链式结构
      2)原型设计的问题:当查找一个对象的属性时,JavaScript 会根据原型链向上遍历对象的原型,直到找到给定名称的属性为止,直到到达原型链的顶部仍然没有找到指定的属性,就会返回 undefined
      也可以理解为原型链继承时查找属性的过程是先查找自身属性,当自身属性不存在时,会在原型链中逐级查找
      3)hasOwnProperty 函数:可以用来检查对象自身是否含有某个属性,返回值是布尔值,当属性不存在时不会向上查找对象原型链,hasOwnProperty是 JavaScript 中唯一一个处理属性但是不查找原型链的函数
      4)getOwnPropertyNames 函数:可以获取对象所有的自身属性,返回值是由对象自身属性名称组成的数组,同样不会向上查找对象原型链
      5)原型链的小结
    • 一直往上层查找,直到到null还没有找到,则返回undefined
    • Object.prototype.__proto__ === null
    • 所有从原型或更高级原型中的得到、执行的方法,其中的this在执行时,指向当前这个触发事件执行的对象

    6)JavaScript的原型是为了实现对象间的联系,解决构造函数无法数据共享而引入的一个属性,而原型链是一个实现对象间联系即继承的主要方法

    二、原型与原型链的常见面试题

    1. 谈谈你对原型的理解
      在 JavaScript 中,每当定义一个对象(函数也是对象)时候,对象中都会包含一些预定义的属性。其中每个函数对象都有一个prototype 属性,这个属性指向函数的原型对象,使用原型对象的好处是所有对象实例共享它所包含的属性和方法

    2. 什么是原型链?原型链解决的是什么问题
      1)原型链解决的主要是继承问题
      2)每个对象拥有一个原型对象,通过 proto 指针指向其原型对象,并从中继承方法和属性,同时原型对象也可能拥有原型,这样一层一层,最终指向 null(Object.proptotype.__proto__指向的是null)。这种关系被称为原型链(prototype chain),通过原型链一个对象可以拥有定义在其他对象中的属性和方法
      3)构造函数 Parent、Parent.prototype 和 实例 p 的关系如下:(p.__proto__ === Parent.prototype)
      在这里插入图片描述

    3. prototype 和 proto 区别是什么
      1)prototype是构造函数的属性
      2)__proto__是每个实例都有的属性,可以访问 [[prototype]] 属性
      3)实例的__proto__与其构造函数的prototype指向的是同一个对象

    展开全文
  • 对于javascript原型链,以前都觉得是个很深的东西,一直没有理解很明白,今天看了一些介绍后,发现这张图,表示再没有什么语言能比这张图说得清楚了。 看了这张图后突然对javascript有了质的理解javascript的...
  • 原型JavaScript中一个比较难理解的概念,原型相关的属性也比较多,对象有”prototype”属性,函数对象有”prototype”属性,原型对象有”constructor”属性。 一、初识原型JavaScript中,原型也是一个对象,...
  • 一、理解原型对象当创建一个新函数时,系统会根据一组特定的规则为函数创建一个prototype属性,该属性会指向一个名为原型对象的对象,在默认情况下,该对象会自动生成一个构造函数(constructor),该构造函数是一个...

    一、理解原型对象

    当创建一个新函数时,系统会根据一组特定的规则为函数创建一个prototype属性,该属性会指向一个名为原型对象的对象,在默认情况下,该对象会自动生成一个构造函数(constructor),该构造函数是一个指向函数的指针。而在原型对象中,除了有这个构造函数,我们还可以添加其他的属性和方法。

    通俗来讲就是,当我们新建一个函数A时,函数A内部会有一个属性,该属性指向一个对象(名字叫原型对象),而这个对象里面默认有一个构造函数,这个构造函数指向我们最初新建的函数A。然后,我们还可以在原型对象中添加属性和方法。

    下面我们来看构造函数、构造函数的原型属性和实例之间的关系:
    构造函数内部会有一个prototype属性,该属性指向构造函数的原型对象,当通过构造函数创建实例时,该实例内部将包含一个指针,指向构造函数的原型属性。该关系如图所示

    这里写图片描述

    来看下面的例子:

    //①默认情况下,构造函数是空的
    
    function Person(){//构造函数首字母大写
    
    }
    
    //②添加属性和方法
    
    Person.prototype.name="dp";
    Person.prototype.doSomething=function(){
        alert(this.name);
    };
    
    //③定义好构造函数和其他属性方法之后,就可以创建实例了
    
    var person1=new Person();
    var person2=new Person();

    这两个对象都是由A创建的,他们都可以调用A的原型中的属性和方法

    alert(person1.name);//dp
    alert(person2.name);//dp

    当然也可以将其重写

    person1="god";
    alert(person1.name);//god

    重写后的属性也可以删除

    delete person1.name;
    alert(person1.name);//dp

    注意原型的动态性,如果你将①和②调换位置,如下:
    function Person(){ }
    var person3=new Person();
    Person.prototype.name=”dp”;
    然后你再执行alert(person3.name)会报错,因为new完person3之后,相当于person3的构造函数和原型属性都是默认值(空),而接下来的Person.prototype.name=”dp”相当于重写了其原型对象,重写原型对象的同时,割裂了原型对象和实例的关系,既然原型对象和实例没有关系了,那么person3.name就没有意义,所以会报错。

    二、理解原型链

    让我们回顾一下构造函数、原型和实例的关系:构造函数内部会有原型对象,该原型对象中包含一个指向构造函数的指针,而实例包含一个指向原型对象的指针。

    那么,假如原型对象是另一个类型的实例呢?也就是说,原型对象包含一个内部指针,指向另一个类型的原型对象,相应的,该原型对象也包含一个指向其构造函数的指针,如图所示。如果将这种关系延续下去,就形成了原型链。

    这里写图片描述

    实现原型链的基本模式如下:

    <script type="text/javascript">
        function Animal(name) {
            this.name = name;//设置对象属性
        }
        Animal.prototype.getName = function() {  
            alert("It is a "+this.name);
        }
        function Dog(name){
            this.name=name;
        }
        Dog.prototype=new Animal();//继承了Animal
        Dog.prototype.getName=function(){
            alert("It is a "+this.name);
        };
        var tom = new Dog("dog");//创建Dog对象
        alert(tom.getName());//It is a dog
    </script>

    三、继承

    许多语言都支持两种继承方式:接口继承和实现继承。在ECMAscript中不支持接口继承,只支持实现继承,而实现继承主要是依靠原型链来实现。根据js语言的本身的特性,js实现继承有五种方式,详见博客

    展开全文
  • 主要介绍了小白谈谈对JS原型链的理解的相关资料,需要的朋友可以参考下
  • 要弄清楚原型链就要先弄清楚 function 类型,在javascript中没有类的概念,都是函数,所以它是一门函数式的编程语言。类有一个很重要的特性,就是它可以根据它的构造函数来创建以它为模板的对象。在javascript中,...
  • prototype:每个函数都有一个prototype属性,它默认指向一个object空对象(即称为:原型对象)。原型对象中有个属性constructor,它指向该函数对象。 xianshi

    prototype

    每个函数都有一个prototype属性,函数的prototype属性是在定义函数时解析器自动添加的,对应着一个对象,这个对象就是我们所谓的原型对象。它默认指向一个object空对象(即称为:原型对象)。原型对象中有个属性constructor,它指向该函数对象。

    显式原型和隐式原型

    每个函数都有一个prototype属性,即显式原型(属性)。

    每个实例对象都有一个__proto__属性,即隐式原型(属性),对象的__proto__属性是创建对象时自动添加的,默认值是构造函数的prototype属性值。

    在ES6之前程序员可以直接操作显式原型,但是不能直接操作隐式原型。

     

    //构造函数
    function School(name,address){
        this.name = name;
        this.address = address;
    }
    
    //实例对象
    var school= new School();
    
    //实例对象的私有属性 __proto__  指向它的原型对象(prototype)
    console.log(school.__proto__ === School.prototype); 
    
    //该原型对象也有一个自己的原型对象 ,层层向上直到一个对象的原型对象为 null。
    console.log(School.prototype.__proto__.__proto__); // null
    
    // 每个原型对象都有一个 constructor 属性指向关联的构造函数。
    console.log(School=== School.prototype.constructor); // true
    
    //当获取 school.constructor 时,其实 school中并没有 constructor 属性,当不能读取到constructor 属性时
    //会从 school的原型也就是 School.prototype 中读取,正好原型中有该属性,
    //相当于:school.constructor === School.prototype.constructor
    console.log(school.constructor === School); // true
    
    
    //Object.prototype.__proto__ 的值为 null 跟 Object.prototype 没有原型
    console.log(Object.prototype.__proto__ === null); // true
    
    //跟上面的类似,每个原型对象都有一个 constructor 属性指向关联的构造函数
    console.log(Object.prototype.constructor === Object); // true

    原型链

    当访问一个对象的属性时,先在自身查找,找到就返回。如果自身没有就会沿着__proto__这条链向上查找,找到就返回结果,若没有找到就返回undefined.

    所以原型链别名:隐式原型链。

    作用:就是查找对象的属性或者方法。

    总结一下:

    • 所有的对象(实例对象,函数对象,原型对象)都有隐式原型__proto__
    • 所有的函数都是Function的实例,包括Function自身。Function.__proto__ === Function.prototype
    • 函数的显式原型的隐式原型指向Object.prototype
    • Object的原型对象是原型链的尽头。Object.prototype.__proto__=== null
    • 函数的显式原型指向的对象默认是空对象{}(空对象{}是Object的实例对象)。Fn.prototype instanceof Object  // ture

    这里补充一下什么是构造函数,有些道友不知道构造函数和普通函数有啥区别。

    构造函数

    构造函数就是一个普通的函数,创建方式和普通函数没有区别。

    不同的是:

    • 构造函数习惯上首字母大写。
    • 调用方式不同,普通函数是直接调用,构造函数需要使用new关键字来调用。

    可以将一个构造函数称为一个类。使用同一个构造函数创建的对象是该类的实例,也成为了一类对象。

    展开全文
  • JS原型链怎么理解

    2020-11-24 00:38:28
    在谈原型链之前,我们首先要了解自定义函数与 Function 之间是什么关系,而构造函数、原型和实例之间又存在什么千丝万缕的关系呢?其实,所有的函数都是 Function 的实例。在构造函数上都有一个原型属性 prototype,...
  • 本文实例讲述了javascript 原型原型链的理解。分享给大家供大家参考,具体如下: javascript中一切皆对象,但是由于没有Class类的概念,所以就无法很好的表达对象与对象之间的关系了。 比如对象A与对象B之间,它们...
  • 理解JavaScript原型

    2020-11-28 03:14:42
    每一个JavaScript对象都和另一个对象相关联,相关联的这个对象就是我们所说的“原型”。每一个对象都会从原型继承属性和方法。有一个特殊的对象没有原型,就是Object。在之后的图示中会进行说明。 举个栗子,我们...
  • 主要介绍了从原型原型链开始讲起,如果你想知道构造函数的实例的原型原型原型原型原型原型是什么,就来看看这篇文章吧。下面小编就来带大家一起学习一下
  • js原型理解

    2020-06-12 10:45:14
    原型Javascript中的继承的基础,JavaScript的继承就是基于原型的继承。

    好多刚入门的程序员,都对这个原型的理解,模模糊糊,还有就是再面试的时候 ,面试官也总是再问谈谈你对原型或者原型链的理解,再网上找了很多资料,觉得这个写的很是通俗易懂(地址),所以就拿来给大家分享一下

    一,什么是原型

    原型是Javascript中的继承的基础,JavaScript的继承就是基于原型的继承。

    1.1原型解释的时候 先理解构造函数和原型对象

    声明一个函数(也就是文中所说的构造函数),则这个函数默认会有一个属性叫 prototype 。而且浏览器会自动按照一定的规则
    创建一个对象,这个对象就是这个函数的原型对象,prototype属性指向这个原型对象。这个原型对象
    有一个属性叫constructor 执行了这个函数(此时的constructor指向声明的这个函数)

     <script type="text/javascript">
    function gets() {
    	    	//我就是构造函数 我有一个属性叫prototype 并且指向了浏览器创建的对象(原型对象)
    	    }	 
     <script/>
    

    二,使用构造函数创建对象

    我们的构造函数使用new来创建对象的时候,就像下面这样:

     <script type="text/javascript">
    function gets() {
    	    	
    	    }	 
     let z1 = new gets();
     <script/>
    

    此时,z1就是那个构造函数gets创建出来的对象,这个z1对象中是没有prototype属性的,prototype属性只有在构造函数gets中有,请看图!
    在这里插入图片描述
    可以看出,构造函数gets中有prototype属性,指向的是gets对应的原型对象;而z1是构造函数gets创建出来的对象,他不存在prototype属性,所以在调用prototype的时候的结构是undefined,但z1有一个__proto__属性,z1调用这个属性可以直接访问到构造函数gets的原型对象(也就是说,z1的__proto__属性指向的是构造函数的原型对象)
    在这里插入图片描述
    说明(引用前面提到的文章的内容,因为很重要):

    • 从上面的代码中可以看到,创建z1对象虽然使用的是gets构造函数,但是对象创建出来之后,这个stu对象其实已经与gets构造函数没有任何关系了,z1对象的__proto__属性指向的是students构造函数的原型对象。
    • 如果使用new gets()创建多个对象z2z3z4,则多个对象都会同时指向gets构造函数的原型对象。
    • 我们可以手动给这个原型对象添加属性和方法,那么z2,z3,z4…这些对象就会共享这些在原型中添加的属性和方法。
    • 如果我们访问z1中的一个属性name,如果在z1对象中找到,则直接返回。如果z1对象中没有找到,则直接去z1对象的__proto__属性指向的原型对象中查找,如果查找到则返回。(如果原型中也没有找到,则继续向上找原型的原型—原型链)。
    • 如果通过z1对象添加了一个属性name,则z1对象来说就屏蔽了原型中的属性name。换句话说:在z1中就没有办法访问到原型的属性name了。
    • 通过z1对象只能读取原型中的属性name的值,而不能修改原型中的属性name的值。 z1.name =
      “李四”;并不是修改了原型中的值,而是在z1对象中给添加了一个属性name。
    <script type="text/javascript">
           function gets() {
    			
    		}
    		// 可以使用gets.prototype 直接访问到原型对象
    		//给gets函数的原型对象中添加一个属性 name并且值是 "张三"
    		gets.prototype.name = "张三";
    		gets.prototype.age = 20;
    
    		var z1 = new gets();
    		/*
    		    访问z1对象的属性name,虽然在z1对象中我们并没有明确的添加属性name,但是
    		    z1的__proto__属性指向的原型中有name属性,所以这个地方可以访问到属性name
    		    就值。
    		    注意:这个时候不能通过z1对象删除name属性,因为只能删除在z1中删除的对象。
    		*/
    		alert(z1.name); // 张三
    
    		var z2 = new gets();
    		alert(z2.name); // 张三  都是从原型中找到的,所以一样。
    
    		alert(z1.name === z2.name); // true
    
    		// 由于不能修改原型中的值,则这种方法就直接在z1中添加了一个新的属性name,然后在z1中无法再访问到
    		//原型中的属性。
    		z1.name = "李四";
    		alert(z1.name); //李四
    		// 由于z2中没有name属性,则对z2来说仍然是访问的原型中的属性。    
    		alert(z2.name); // 张三
        </script>
    
    

    三、与原型有关的几个方法

    1. prototype属性

    prototype 存在于构造函数中 (其实任意函数中都有,只是不是构造函数的时候prototype我们不关注而已) ,他指向了这个构造函数的原型对象。

    2.constructor属性

    constructor属性存在于原型对象中,他指向了构造函数
    看下边代码

    <script type="text/javascript">
        function gets() {
        }
        alert(gets.prototype.constructor === gets); // true
    </script>
    

    我们根据需要,可以gets.prototype
    属性指定新的对象,来作为gets的原型对象。但是这个时候有个问题,新的对象的constructor属性则不再指向students构造函数了。

    看代码

    <script type="text/javascript">
    	function gets() {
    		
    	}
    	//直接给Person的原型指定对象字面量。则这个对象的constructor属性不再指向Person函数
    	gets.prototype = {
    		name:"志玲",
    		age:20
    	};
    	var z1 = new gets();
    	alert(z1 .name);  // 志玲
         //使用instanceof 操作符可以判断一个对象的类型。  
      	//typeof一般用来获取简单类型和函数。而引用类型一般使用instanceof,因为引用类型用typeof 总是返回object。
    	alert(z1 instanceof gets); // true
    	alert(gets.prototype.constructor === gets); //false
      	//如果constructor对你很重要,你应该在gets.prototype中添加一行这样的代码:
      	/*
      	gets.prototype = {
          	constructor : gets	//让constructor重新指向gets函数
      	}
      	*/
    </script>
    
    

    3.proto 属性(注意:左右各是2个下划线)

    ​ 用构造方法创建一个新的对象之后,这个对象中默认会有一个属性__proto__, 这个属性就指向了构造方法的原型对象。

    展开全文
  • 彻底理解JavaScript原型 原型JavaScript中一个比较难理解的概念,原型相关的属性也比较多,对象有"[[prototype]]"属性,函数对象有"prototype"属性,原型对象有"constructor"属性。 为了弄清原型,以及原型相关...
  • JS原型原型链的理解 每个函数function都有一prototype属性,也就是通常所说的显使原型。 每一个函数的实例对象都有一个__ proto __属性,被称为隐式原型。 对象的隐式原型的值等于构造函数显式原型的值 ​ ...
  • 深入理解javascript原型和闭包(01)——一切都是对象 深入理解javascript原型和闭包(02)——函数和对象的关系
  • 那么,如果原型对象等于另一个原型的实例,此时的原型对象将包含一个指向另一个原型的指针,相应地,另一个原型中也包含着一个指向另一个构造函数的指针。如果另一个原型又是另一个原型的实例,那么上述关系依然成立...
  • js-理解什么是原型

    2021-04-11 16:33:58
    1.什么是原型 首先要明白一点:原型存在于对象中的。 接下来阐述什么原型:在js中,...或者用另一种简单却难理解的说法是:js中的对象都有一个特殊的[[Prototype]]内置属性,其实这就是原型。 function Animal() {
  • 原型理解

    2020-12-10 22:14:34
    我对原型理解是,每个函数都有一个prototype属性,该属性指向的这个函数的原型. 原型是一个对象,最初的原型即为一个空的对象,原型上面有一个constructor属性,而该属性指向的是该函数. // An highlighted block ...
  • 相信学习前端的朋友对这两个词都不陌生,甚至当我们提到Js的时候就会提到这两个名词(原型,跟原型链) 在知道原型链之前我们要先知道原型他俩是相对关系因为没有原型就没有原型链 ! 废话不多说直接上干货!!! ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,520
精华内容 27,808
关键字:

原型js的理解