精华内容
下载资源
问答
  • JS原型和原型链

    2021-03-06 21:58:04
    JS原型和原型链一、prototype和__proto__的概念1.显示原型(prototype )2.隐式原型(__proto __)3.例题二、原型链图1.构造函数2._proto_与prototype3.person → Person → Object4.完整原型链 一、prototype和__...



    一、prototype和__proto__的概念

    1.显示原型(prototype )

    • 所有的函数都有一个属性,prototype 称之为函数原型
    • 默认情况下,prototype是一个普通的对象
    • 默认情况下,prototype中有一个属性,constructor ,它也是一个对象,它指向构造函数本身

    2.隐式原型(__proto __)

    • 所有的对象都有一个属性:__proto __,称之为隐式原型
    • 在默认的情况下,隐式原型指向创建该对象构造函数的原型
    function Test(name,age){
        this.name = name;
        this.age = age;
        this.init = function(){
            console.log(123)
        }
    }
    var a = new Test('csdn',666);
    console.log(a.__proto__ === Test.prototype)//true
    console.log(a.__proto__.constructor === Test.prototype.constructor)//true
    //在默认的情况下,隐式原型指向创建该对象构造函数的原型
    

    3.例题

    代码如下(示例1):

    function Create(name,age){
        this.name = name;
        this.age = age;
        this.say = function(){
        console.log('hello world');
        }
    }
    var u1 = new Create('lihua',21);
    var u2 = new Create('xiaoming',18);
    
    console.log(u1.say === u2.say);	//false
    u1.__proto__.abc = 456;
    console.log(u2.abc);// undefined
    console.log(u1.abc);456
    Create.prototype.say = function(){
          console.log('js');
    }
    u1.say = null;
    u2.say(); // js
    // u1.say();// 报错
    

    代码如下(示例2):

    function Create(name,age){
                this.name = name;
                this.age = age;
    }
    Create.prototype.init = function(){
         console.log('oys');
    }
    var u1 = new Create();
    var u2 = new Create();
    console.log(u1.init === u2.init);// true    
    

    总结:由例1和例2可以看出来,this和prototype是有区别的,一个会产生两个不同的存储空间,而通过prototype都是在操作同一个东西,所以u1.init全等于u2.init

    二、原型链图

    1.构造函数

    在这里插入图片描述

    2._proto_与prototype

    在这里插入图片描述

    3.person → Person → Object

    在这里插入图片描述

    4.完整原型链

    在这里插入图片描述

    展开全文
  • js原型和原型链

    2021-03-10 15:41:07
    js原型和原型链1、原型2、constructor3、原型链4、继承 1、原型 在JavaScript中,原型也是一个对象,原型的作用,则是实现对象的继承。在js的所有函数对象中,都存在一个属性prototype,该属性对应当前对象的原型。 ...

    1、原型

    在JavaScript中,原型也是一个对象,原型的作用,则是实现对象的继承。在js的所有函数对象中,都存在一个属性prototype,该属性对应当前对象的原型。

    我们先来看一个例子:
    在这里插入图片描述
    每一个函数都有一个prototype属性
    再来看一下,下一个例子:
    在这里插入图片描述
    看一下 ‘测试2’ 的打印和‘测试6’的结果是一样的,下面我们来一个大胆的猜测
    打印看看 Person.prototype === person.__proto__ 这个是否相等?
    在这里插入图片描述
    oh my god!居然相等了。。。。。。
    没错,通过上面的代码可以看出person是实例对象,Person是构造函数,实例的 _proto_ 属性指向构造函数Person的原型 prototype

    2、constructor

    我们可以看到‘测试2’和‘测试6’打印的都有一个constructor,我们来打印看看:
    在这里插入图片描述
    constructor构造函数 创建的 实例的属性,该属性的作用是 指向创建当前对象的构造函数。
    在这里插入图片描述

    3、原型链

    所有的对象和原型都有自己的原型,对象的原型指向原型对象。在层级多的关系中,多个原型层层相连则构成了原型链。
    在查找一个对象的属性时,倘若在当前对象找不到该属性,则会沿着原型链一直往上查找,知道找到为止,如果到了原型链顶端,还没找到,则返回undefined

    4、继承

    我们接着来看一个例子:
    在这里插入图片描述

    显然,person1实例继承Person的action属性
    而且通过hasOwnProperty()可以判断对象是否包含特定的自身(非继承)属性

    这个其实不是很难,自己写两个例子,打印看看就知道了

    溜了溜了

    转载需标注!* . *

    展开全文
  • Js 原型和原型链

    2019-09-27 09:01:32
    首先,JS的继承是用原型链实现的,传统java里拷贝属性方法到子类里不一样。 1. 原型 原型呢,他其实就是一个对象,目的是为了让实例共享属性方法,毕竟实例之间是有共性的。 2. 原型链 当我们查找一个...

    首先,JS的继承是用原型链实现的,和传统java里拷贝属性和方法到子类里不一样。

     

    1. 原型

       原型呢,他其实就是一个对象,目的是为了让实例共享属性和方法,毕竟实例之间是有共性的。

    2. 原型链

       当我们查找一个对象的属性或者方法的时候,如果本身没有,则会去原型对象查找,如果还没有,则去原型对象的原型对象,

    如此直到找到或者返回undefined;这是一个链式的查找,每个对象都有一个它自身原型对象的链接,这些链接组成的整个链条

    就是原型链;

    3. __proto__和prototype

     前者在浏览器中存在; new 一个函数创建出来的对象,这个对象的__proto__指向函数的prototype属性

     

     

    参考:https://segmentfault.com/a/1190000010817337

     

    转载于:https://www.cnblogs.com/ljyqd/p/11507581.html

    展开全文
  • js 原型和原型链

    2020-09-22 23:29:29
    通过该构造函数产生的対象,可以継承该原型的属性方法。原型也是対象。 2.利用原型特点概念,可以提取共有属性。 *原型的增删改查 3.对象如何査看原型一>隐形属性_ proto_ 4.对象如何査看对象的构造函数一>...

    原型

    1.定义:原型是function对象的一个属性,它定义了构造函数制造出的对象的公共祖先。通过该构造函数产生的对象,可以継承该原型的属性和方法。原型也是对象。

       /***1.定义***/
    
        Person.prototype.name = "hehe"
        Person.prototype.say = function() {
          console.log('hehe')
        }
        function Person() {
        }
        var person = new Person
        var person1 = new Person  //継承该原型的属性和方法
        
    

    2.利用原型特点和概念,可以提取共有属性。
    *原型的增删改查(只能在原型的本身上进行)

    // 原先:
    function Car(color,owner){  //每一执行都会执行,代码藕合
      this.height=1200;
      this.color=color;
      this.lang= 4900;
      this.owner = owner;
      this.name = 'bmw'
    }
    
    var car = new Car("red","lili")
    var car1 = new Car('black','xuming')
    
    // 使用原型:
    Car.prototype.height=1200;
    Car.prototype.lang= 4900;
    Car.prototypename = 'bmw'
    

    3.对象如何査看对象的构造函数一> constructor
    (构造器,会返回对象的构造函数)–查找自己的本身的构造函数
    *(虽然是系统自带的,但是我们是可以自己更改的)

    更改:
     Person.prototype = {
            constructor: Car
          }
          function Car() {
          }
          var car = new Car
    

    4.对象如何査看原型一>隐形属性_ proto_
    *访问对象的时候如果不存在的会回顺着_ proto_的索引去找原型,相当与连接的关系,指向原型也就是链接原型的作用

    *补充知识点:
    用构造函数创建对象时,new的行为
    用构造函数创建对象:
    var obj=new 类型名(属性值,…)
    new: 4件事:

    1. 创建一个空对象
    2. 让新的子对象继承构造函数的原型对象设置(自动设置新对象的__proto__属性指向构造函数的原型对象)
    3. 调用构造函数:
        1. this->new
        2. this.属性名=值: 通过强行赋值的方式,为对象添加新属性,并保存属性值
    4. 返回新对象的地址,保存在变量中
         function Penson() {
           // var this = {
           //   __proto__:Person.prototype   //new新对象的时候发生4段式,第一,二步
           // }
         }
    
         var penson = new Person()
    
    

    在这里插入图片描述

    原型链

    1.如果构造原型链

    Grand.prototype.__proto__ = 	Object.prototype(大部分对象的最终原型) ---测试Object.prototype.__proto__ = null
    
    Grand.prototype.lastName ="Deng"
    function Grand(){
    }
    var grand = new Grand();
    
    Father.prototype=grand 
    function Father(){
    }
    var father= new Father();
    
    Son.prototype=father
    function Son(){
    }
    var son= new Son();
    
    

    这样一层层的向上查询的过程就是原型链
    原型加原型,把原型连成链的,访问的顺序依照链的顺序,像作用链一样的访问顺序,可近的来的过程

    2.原型链上属性的增删改查
    (与原型一直)–通过子孙进行删除是不可能的,只有自己本身

    Father.prototype=grand 
    function Father(){
    this.num = 100
    }
    var father= new Father();
    
    Son.prototype=father
    function Son(){
    }
    var son= new Son();
    

    son.num++

    3.绝大多数对象的最终都会继承自Object.prototype —null
    因为4,在自己创建Object.create(null) 就没有原型

    4.Object.create(原型)—可以自己创建原型(必须是对象或者null)

    创建对象并且原型自己指定
    var obj = {name:"sunny",age:123}
    var obj1=Object.create(obj)
    

    5.那 Object.prototype 的原型呢?

    Object.prototype.__proto__ === null
    

    引用阮一峰老师的 《undefined与null的区别》 就是:

    null 表示“没有对象”,即该处不应该有值

    所以 Object.prototype.proto 的值为 null 跟 Object.prototype 没有原型,其实表达了一个意思。

    所以查找属性的时候查到 Object.prototype 就可以停止查找了。
    在这里插入图片描述

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

    2019-08-11 17:31:32
    //原型和原型链 //1.构造函数 function Person(name, age){ this.name = name this.age = age return this // 默认会有这一行,不写也可以 } let p1 = new Person('zhangsan',20) let p2 = new Person('lisi', ...

空空如也

空空如也

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

js原型和原型链