精华内容
下载资源
问答
  • 什么是js原型对象

    2021-05-15 13:53:18
    原型对象也有一个自己的原型对象( __proto__ ) ,层层向上直到一个对象的原型对象为null。根据定义,null没有原型,并作为这个原型链中的最后一个环节。 这句话有三个意思, 第一,每个构造函数和实例对象都有...

    关于js原型及原型链MDN上的定义是,

    每个实例对象( object )都有一个私有属性(称之为 __proto__ )指向它的构造函数的原型对象(prototype )。该原型对象也有一个自己的原型对象( __proto__ ) ,层层向上直到一个对象的原型对象为 null。根据定义,null 没有原型,并作为这个原型链中的最后一个环节。

    这句话有三个意思,

    第一,每个构造函数和实例对象都有其原型对象;

    第二,函数中的原型对象通过prototype来访问,实例对象通过__proto__来访问

    第三,实例对象的__proto__指向函数的prototype

    那么这三句话又是什么意思呢,打开vscode创建一个构造函数以及它的实例对象

    
        //构造函数
        function a(){
            
        }
    
        //实例化对象
        var ab = new a()
    
    
        console.log(a.prototype);//打印构造函数的原型对象
        console.log(ab.__proto__);//打印实例对象的原型对象

    打印结果如下

    可以看出构造函数与实例对象都打印出了结构一样的Object对象,那么它们是否关联呢?

    结合上面第三句话(第三,实例对象的__proto__指向函数的prototype),我们打印console.log(a.prototype===ab.__proto__);

        //构造函数
        function a(){
            
        }
    
        //实例化对象
        var ab = new a()
    
    
        console.log(a.prototype);//打印构造函数的原型对象
        console.log(ab.__proto__);//打印实例对象的原型对象
        
        console.log(a.prototype===ab.__proto__);

    打印结果如下

    a.prototype全等于ab.__proto__,也就是说它两地址是同一个地址,换句话说,构造函数和实例对象的原型对象是同一个

    如果它们是同一个对象,那么更改实例对象中的__proto__,构造函数中的prototype也应该会随之变化!

    为了验证这句话,将上面代码改为

        //构造函数
        function a(){
            
        }
    
        //实例化对象
        var ab = new a()
    
    
        //给实例化对象的原型对象,设置方法
        ab.__proto__.set = function(){
            console.log(3);
        }
    
        console.log(a.prototype);//打印构造函数的原型对象
        console.log(ab.__proto__);//打印实例对象的原型对象
        
        console.log(a.prototype===ab.__proto__);

    打印结果

    可以看出,结果都出现了set方法,所以上述结果成立,构造函数和实例对象的原型对象是同一个!

    结论:构造函数和其实例对象,有个共同的原型对象,两者可以通过这个对象建立连接,互相访问,调用方法!

    那么原型对象也是实例对象,那么他是否也有实例对象呢?答案是有的,详情请点击关注,了解下个知识内容,原型链!

    展开全文
  • 构造函数的实例的原型就是构造函数的原型对象 ...什么是原型,什么是原型对象什么是构造函数,下面我们通过代码解释 function foo(name,age){ this.name = name this.age = age console.log(this.name)

    构造函数的实例的原型就是构造函数的原型对象

    原型链是js的一种继承方式,他的基本思想就是通过原型链继承多个引用类型的属性和方法。每个构造函数都有一个原型对象,原型有一个属性指回构造函数
    在这之前大家思考一个问题?什么是原型,什么是原型对象,什么是构造函数,下面我们通过代码解释
    function foo(name,age){
                this.name = name
                this.age = age
                console.log(this.name)
                console.log(this.age)
         }
         foo.prototype.del = function(a,b){
             console.log(a-b)
         }
         var childfoo = new foo("杨雨",25)
         childfoo.del(20,10)
         console.log(foo.prototype)
         console.log(childfoo.__proto__)
         console.log(childfoo.__proto__ == foo.prototype)
    

    效果:

    11
    分析:

    首先要明白:构造函数是用于创建特定类型对象的。我们有一个构造函数,他有一个原型对象:foo.prototype,我们通过foo.prototype加点的形式来创建原型对象的方法,原型对象的方法可以被实例继承使用,但是不能自己直接使用,比如我们直接使用foo.del(),就会报错(foo.del is not a function),而我们又创建了一个foo实例,名为childfoo,实例都会有一个__proto__属性,这个属性指向原型,实例的原型就是构造函数的原型对象(这个可以从上图输出第四十五行看到)。所以我们的实例可以使用构造函数的方法。实例要想使用某个方法或者某个属性先在自己内部找,找不到再通过__proto__,去他的原型里边找,还没有的话,再次通过__proto__去他的原型的原型里边找,这样链式寻找就形成了原型链。有的话就直接使用,没有就该报啥错报啥错吧。

    生活举例

    我们想买苹果(home是smallMarket的一个实例),发现家里没有,我们就去最近的smallMarket去寻找(home.__proto__ = smallMarket.prototype )结果发现smallMarket也没有,但是superMarket有,所以,我们需要建立联系,smallMarket.prototype.apple = superMarket.prototype.apple 在这个例子当中,home的原型就是苹果,smallMarket的原型对象也是苹果

    代码实现:

    function superMarket() {
    
            }
            superMarket.prototype.apple = "苹果"
    
            function smallMarket() {
    
            }
            smallMarket.prototype.apple = superMarket.prototype.apple
            var home = new smallMarket()
            console.log(smallMarket.prototype)
            console.log(home.apple)
    

    效果:

    11

    一个构造函数也可以成为另一个构造函数的实例

    function aa(say){
                this.say = say
            }
            aa.prototype.wawa = function(){
                console.log('wawawawa')
            }
            function Animal(name){
                this.name = name
                console.log(this.name)
            }
            Animal.prototype.say=function(){
                console.log("旺旺")
            }
           
            Animal.prototype =new aa("哈哈哈")
            let cat = new Animal('喵喵')
            console.log(Animal.prototype)
            console.log(cat.__proto__.__proto__)
            cat.__proto__.__proto__.wawa()
    

    log:

    xiaog

    展开全文
  • 对象 对象基础 对象的定义 对象是一个包含相关数据和方法的集合(通常由一些变量和函数组成,我们称之为对象里面的属性和方法)。 对象有时被称之为关联数组(associative array)了——对象做了字符串到值的映射,...

    对象
    对象基础
    对象的定义


    对象是一个包含相关数据和方法的集合(通常由一些变量和函数组成,我们称之为对象里面的属性和方法)。

    对象有时被称之为关联数组(associative array)了——对象做了字符串到值的映射,而数组做的是数字到值的映射。

    创建一个对象通常先定义初始化变量。

    var person = {};
    person  // Object {}
    

    点表示法


    对象的名字表现为一个命名空间(namespace),它必须写在第一位-----当你想访问对象内部的属性或方法时,然后是一个点(.),紧接着是你想要访问的项目,标识可以是简单属性的名字(name),或者是数组属性的一个子元素,又或者是对象的调用方法。例如:

    person.age
    person.interests[1]
    person.bar()

    子命名空间


    可以用一个对象来做另一个对象成员值。例如将name成员

    name:['wh','xi'],

    改成

    name :{
        first : 'wh',
        last : 'xi'
    },

    这样,我们实际上创建了一个子命名空间,听起来有点复杂,但用起来很简单,你只需要链式的再使用一次点表示法,像这样:

    person.name.first
    person.name.last
    

    注意:你需要改变你之前的代码,从

    name[0]
    name[1]
    

    改成

    name.first
    name.last

    否则,你的方法不再有效。

    括号表示法
    另外一种访问属性的方式是使用括号表示法(bracket notation),替代这样的代码

    person.age
    person.name.first
    

    使用如下所示的代码:

    person['age']
    person['name']['first']

    这看起来很像访问一个数组的元素,从根本上来说是一回事儿,你使用了关联了值的名字,而不是索引去选择元素。难怪对象有时被称之为关联数组(associative array)了——对象做了字符串到值的映射,而数组做的是数字到值的映射。

    原型原型链
    原型对象


    在JavaScript 中,每当定义一个对象(函数) 时候,对象中都会包含一些预定义的属性。其中函数对象的一个属性就是原型对象 prototype 。注:普通对象没有prototype,但是有_ _ proto _ _ 属性 。

    原型对象其实就是普通对象 (Function.prototype 除外,它是函数对象,但它很特殊,他没有prototype 属性(前面说道函数对象都有prototype 属性))。

    原型对象是用来做什么的呢?

    主要作用是用于继承。举个例子

    var person = function(name){
        this.name = name;
    };
    person.prototype.getName = function(){
        return this.name;
    }
    var veb = new person('Veblen');
    veb.getName(); // Veblen

    从这个例子可以看出,通过给person.prototype设置了一个函数对象的属性,那有person实例

    function Person() {
    
    }
    // 虽然写在注释里,但是你要注意:
    // prototype是函数才会有的属性
    Person.prototype.name = 'Kevin';
    var person1 = new Person();
    var person2 = new Person();
    console.log(person1.name) // Kevin
    console.log(person2.name) // Kevin

    (例中:veb) 出来的普通对象就继承了这个属性。具体是怎么实现的继承,就要讲到下面的原型链了。

    prototype
    每个函数都有一个 prototype 属性,就是我们经常在各种例子中看到的那个 prototype ,比如:
    那这个函数的 prototype 属性到底指向的是什么呢?是这个函数的原型吗?

    其实,函数的 prototype 属性指向了一个对象,这个对象正是调用该构造函数而创建的实例的原型,也就是这个例子中的 person1 和 person2 的原型。

    那什么是原型呢?你可以这样理解:每一个JavaScript对象(null除外)在创建的时候就会与之关联另一个对象,这个对象就是我们所说的原型,每一个对象都会从原型"继承"属性。

    让我们用一张图表示构造函数和实例原型之间的关系:

    构造函数和实例原型的关系图

    在这里插入图片描述

    在这张图中我们用 Object.prototype 表示实例原型。

    原型链


    JS 在创建对象(不论是普通对象还是函数对象) 的时候,都有一个叫做   
    _ _ proto _ _ 的内置属性,用于指向创建它的函数对象的原型对象 prototype 。

    console.log(veb.__proto__ == person.prototype)  //true
    同样,person.prototype 对象也有__proto__ 属性,它指向创建它的函数对象(Object)的 prototype
        console.log(person.prototypr.__proto__ Object.prototype)   //true
    继续,Object.prototype对象也有__proto__属性,但是它比较特殊,为null
    console.log(Object.prototype.__proto__)  //null


    我们把这个有_ _ proto _ _ 串起来的直到Object.prototype. _ _proto _ _ 为null的链叫做原型链。

     

    js new一个对象的过程

      function mon(name) {
                this.name = name
            }
            var son = new mon()
    

    1、创建一个新对象:son
    2、新对象会执行一个[[prototype]]连接

    son.__proto__=mon.prototype
    

    3、对象实例和对象的this会绑定起来
    4、执行对象中的代码 

     this.name = name
    

     5、如果函数没有返回值,就是返回新对象

    什么是原型链

            function supermarket() {
    
            }
            supermarket.prototype.product = "salks"
    
            console.log(supermarket.prototype)
    
            function shop() {}
    
            shop.prototype = new supermarket()
    
            console.log(shop.prototype)
    
            var person = new shop()
    
            console.log(person.product)

    说明:我并没有在shop中定义product,按理说它应该为空,但是我让shop的原型对象指向supermarket的实例,它就会去supermarket中寻找有没有product属性。
    作用:我们可以利用这特性实现类的继承

    展开全文
  • 面向对象和面向过程是程序员经常使用到的思想,必须要深刻理解才好的呀。面向对象思想面向过程:亲力亲为,有些代码顺序不可改变,执行者;面向对象:管理者,在解决问题时首先看是否有...原型原型指函数的protot...

    面向对象和面向过程是程序员经常使用到的思想,必须要深刻理解才好的呀。

    面向对象思想

    面向过程:亲力亲为,有些代码顺序不可改变,执行者;

    面向对象:管理者,在解决问题时首先看是否有对象可以解决,如果有就使用该对象解决问题。

    面向对象:实质是找一个对象帮你解决问题,如果没有此对象,就可以考虑自己封装一个。

    优点:可维护性;可扩展性;

    缺点:在使用面向对象编程时,会造成代码的复杂度提高。

    原型

    原型指函数的prototype属性所引用的对象

    Person.prototype.sayHi = function(){

    console.log('hi');

    }

    - 只要定义一个函数,那么就会创建其原型

    - 由上述函数创建出来的所有对象,都可以直接访问到原型上的成员

    作用:实现同类对象之间的数据共享,可以动态添加属性并共享,另一个重要作用是继承。

    获取原型方式

    通过函数:.prototype

    通过对象:._proto_

    以两个下划线开头和结尾的属性均为非标准属性;原型上默认具有constructor属性,引用的就是其构造函数。兼容__proto__写法:

    function getPrototype(obj){

    return obj.__proto__?obj.__proto__:obj.constructor.prototype;

    }

    特性:

    动态性

    在已有的原型上扩展成员,直接反映到已创建出来的对象上。

    如果置换了已有的原型,那么会反映到后面新创建的对象,而不会影响之前创建的对象。

    唯一性

    由同一个构造函数创建出来的所有对象,都共享一个原型。

    不可变性

    不能通过对象来修改原型上的成员。

    共享性

    所有的对象都可以直接访问其原型上的成员。

    扩展创建对象方式

    原型式

    组合方式创建对象(原型和构造函数)

    组合原型和构造函数一起来创建对象

    将私有的属性写在构造函数内

    将共有的属性或行为写到其原型上

    继承

    指一个对象有权去访问另一个对象上的成员(属性和方法)

    实现:

    原型式继承

    a: 在原有的原型上扩展

    b: 置换原型

    混入式:将要继承的对象上的所有成员拷贝一份,添加到本身。

    Object.create方法

    实现原型式继承(通过置换原型方法)

    var newObj = Object.create(parent);

    - Object.prototype的原型为null

    - 默认原型对象的原型为Object.prototype

    扩展继承方式---对象冒充

    function parent(name,age){

    this.name = name;

    this.age = age;

    }

    function child(name,age,gender,address){

    this.parent = parent;

    this.parent(name,age);

    delete this.parent;

    this.gender = gender;

    this.address = address;

    }

    var newObj = new child('tom', 18, 'boy', 'beijing');

    console.log(newObj);

    ```

    - 局限性:不能指定构造函数。

    ### 属性搜索原则

    + 当访问对象的某个属性时,

    + 首先在对象本身上查找,如果找到就返回值,并停止查找;

    + 如果没有找到就会向其原型对象上查找,如果找到就返回值,并停止查找;

    + 如果再没有找到,就继续向其原型的原型对象上查找,直到Object.prototype(不会到Null),此时如果找到就返回值,否则值为undefined(如果找不到方法的原型对象的属性,则会报错)。

    好了,这次就先说这么多了,之后会一一补充起来的,gogogo!

    展开全文
  • JS中的原型对象

    2021-04-23 15:22:46
    无论什么时候,只要创建了一个新函数,就会根据一组特定的规则为该函数创建一个prototype属性,这个属性指向函数的原型对象。 在默认情况下,所有原型对象会自动获得一个constructor属性,这个属性指向prototype属性...
  • 每个函数都有一个特殊的属性叫作原型(prototype)每个对象拥有一个原型对象 [[Prototype]] / __proto__ / Object.getPrototypeOf(object1)通过原型对象一级一级的往上找的这个过程就是原型链原型每个函数都有一个...
  • 任何对象实例都有一个原型,也叫原型对象,这个原型对象由对象的内置属性_proto_指向它的构造函数的 prototype 指向的对象,即任何对象都是由一个构造函数创建的,但是不是每一个对象都有 prototype,只有方法才有 ...
  • 什么是原型对象 原型对象包括显示原型对象和隐式原型对象 显示原型对象原型对象就是函数对象的一个属性prototype的值( 地址),这个prototype属性值是原型对象, 也被叫做显式原型对象.ES5中适合在原型内部添加...
  • 原型对象,是用来解决构造函数在创建实例的时候,防止重复执行所导致的性能的降低(这里主要指占用内存),来为服用带来方便 如果在构造函数上添加一个方法 当你每次调用这个构造函数的时候都会调用里面的方法如果用...
  • 原型对象prototype和对象原型__proto__ 原型对象只存在于类中的,在对象中是没的原型对象的,只有对象原型 查找情况一:(实例对象使用__proto__进行查找),对象 =》类.prototype =》object.prototype =》null...
  • 1.什么是原型 prototype叫原型,是每一个构造函数身上的一个属性,这个属性是以对象的形式存在的 function People() { this.uname = 'zs'; } console.dir(People);
  • 类的原型对象

    2021-08-04 09:10:43
    什么是原型对象原型对象----构造函数每次在声明的时候,系统会自动的帮我们创建一个与之对应的对象 prototype---- 属于构造函数,指向原型对象 __proto__----属于构造函数的实例化对象,指向原型对象 为什么使用...
  • 文章目录原型对象构造函数的原型对象对象的原型对象原型对象原型对象原型链原型链结构图函数在原型链中的结构 原型对象 构造函数的原型对象 每个构造函数都有一个原型对象存在,这个原型对象通过构造函数的...
  • 每个函数创建后,解析器都会向函数中添加一个属性prototype 这个属性对应一个对象,这...原型对象就相当于一个公共区域,所有同一类的实例都可以访问到这个原型对象 我们可以将对象共有的内容,统一设置到原型对象 ...
  • 01-构造函数-原型对象(利用原型挂载解决内存占用问题) 构造函数链接:构造函数解决内存占用问题方法之一 <body> <script> // 解决内存占用问题 function CreateTeacher(name, age) { this.name = ...
  • 示例: function Person (name, age) { this.name = name;...解析:Person是构造函数,具有name,age,prototype属性,每个构造函数都有一个原型对象(prototype),Person的prototype属性指向该构造函数的..
  • 首先要知道js中有哪几种数据类型、知道原型的作用是什么原型是如何在对象中存在的、原型如何使用。 JavaScript只有一种结构:对象 js中万物皆是对象。 出去五种基本类型以外的都是对象。 五种基本数据类型包括:...
  • 原型对象、原型链超详细讲解(附图解)一、函数的原型对象二、prototype(函数的原型)三、__ proto__(原型链)四、constructor(构造函数)五、prototype继承六、结论1.实例对象的原型链指向当前类的原型对象。2.原型...
  • ES6面向对象1、面向对象1.1、对象1.2、类1.2.1、创建类1.2.2、构造函数1.2.3、类中添加方法...prototype2.4、对象原型 __ proto __constructor 构造函数2.6、构造函数、实例、原型对象三者关系2.7、原型链查找规则2.8
  • js原型对象

    2021-08-17 17:05:40
    在js中每个函数都有一个原型对象,每个函数都有一个默认的属性prototype,用来指向原型对象(即prototype的属性值是这个原型对象),原型对象中有一个属性constructor,用来指向这个函数(即constructor属性值是这个...
  • 原型对象: prototype 每个对象中都有 __ proto __ 1.构造函数原型prototype (也叫做原型对象) 构造函数通过原型分配的函数是所有对象所共享的,不用单独开辟内存空间。 每一个构造函数中都有一个prototype属性,...
  • 原型对象、原型链

    2021-10-11 09:27:12
    什么是原型对象? 我们可以对原型对象这个词进行拆分,没错是原型和对象,js里的对象相信可以不用解释了,也就是说原型对象不过也是一个对象罢了。那么什么是原型呢,这里又要引出一个概念叫构造函数 构造函数: ...
  • 构造函数、对象实例、原型对象三者之间的关系
  • JS原型对象

    2021-06-29 21:18:29
    原型对象 如果将属性和方法都设置在构造函数中,每次new一个新的对象,这个对象的内存中都会基于构造函数中的属性和方法,创建属于自己的属性和方法. 如果有一些公共的属性和方法,创建出来的每一个对象,都可以公用这些...
  • 1.在构造函数中,里面的this指向的是对象实例 方法:设置一个全局变量that,让构造函数里面的that=this 然后判断实例化对象和that是否相等 测试代码 <script> var that=this; function Star(uname,usex){ ...
  • 2、原型链是原型对象创建过程的历史记录,当访问一个对象的某个属性时,会先在这个对象本身属性上查找。 js的原型和原型链是: JavaScript是一门基于原型的语言,在软件设计模式中,有一种模式叫做原型模式,...
  • 原型对象和原型链

    2021-06-21 19:06:16
    本文主要介绍了什么是原型原型链及其练习题。和一个小问题:a什么情况下可以等于1等于2等于3。
  • 大家都应该知道构造函数很好用。但是构造函数也存在浪费内存的问题。 function Star(uname, age) { this.uname = uname;...在图中我们可以看出来只要我们实例化出一个对象里面的sing方法都是一样得不管我们实例化多
  • <body> <script> console.log(Array) //console.dir()可以显示一个对象所有的属性和方法 ...可以通过原型对象,对原来的内置对象进行扩展自定义的方法。比如给数组增加自定义求偶数和的功能 <body&
  • 答: __proto__指向的是该对象的构造函数的原型对象(prototype)。 构造函数与原型对象、对象原型的关联图 constructor属性 constructor属性帮助我们指向构造函数本身。 constructor属性不能指向构造函数的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 398,272
精华内容 159,308
关键字:

原型对象是什么