精华内容
下载资源
问答
  • js 原型原型链使用和理解
    2022-02-16 15:29:54

    1、new 时构造函数的4个过程

    (1)创建一个空对象,作为将要返回的对象实例。

    (2)将空对象原型的内存地址__proto__指向函数的原型对象。

    (3)将利用函数的call方法,将原本指向window的绑定对象this指向了空对象

    (4)开始执行构造函数内部的代码。

    function Cat(name, age) {
       var Cat = {}; // 声明一个空对象
       Cat.name = name; // 把值赋值给新声明的Cat
       Cat.age = age; // 同上
       return Cat; // 返回这个对象
    }
    console.log(new Cat('miaomiao', 18));  // {name: "miaomiao", age: 18}
    function Foo(name) {
        this.name = name;
        return this;
    }
    var obj = {};
    obj.__proto__ = Foo.prototype;
    // Foo.call(obj, 'mm');
    var foo = Foo.call(obj, 'mm');
    console.log(foo);

    首先预编译,声明提升,解释执行。
    执行时按照顺序来进行,

    • obj指向空对象;
    • obj的原型地址指向构造函数Foo的原型对象;
    • 执行Foo.call(obj, 'mm');
      • this.name = name; 通过函数的call方法将this绑定到obj(也就是说this就是obj),实参mm传入构造函数Foo中,这样this.name = 'mm',那么obj.name = 'mm',也就是说name属性被挂载到obj对象上。
      • return this; 就是return obj,这样obj这个对象就被返回出来了。
    • 将结果赋值给变量foo。
    • 打印结果。

    2、原型原型链的作用

    就像盖房子用的砖头和水泥,平时对工作几乎没有影响,但是遇到bug、性能优化时,底层东西还是有用的。

    3、什么是原型 是一个对象(每一个对象(null除外)在创建时都会与之关联另外一个对象,这另一个对象就是原型)

    构造函数:每个函数都有一个原型 通过prototype访问。

    function Person(){};
    prototype是函数才有的属性
    Person.prototype.name = 'Kevlin';
    
    var person1 = new Person() // 构造person1实例
    var person2 = new Person() // 构造person2实例
    
    console.log(person1,person2) // Kevlin Kevlin
    
    Person.prototype所指向的对象就是person1、person2的原型

    示意图如下

    对象:js的每个对象都有一个原型,通过__proto__访问到。

    new 参考JS中的new操作符 - 见嘉于世 - 博客园

    更多相关内容
  • js原型链详解

    2018-06-04 15:08:23
    javascript的原型与原型链的详细的解析,一篇从认识到熟悉深入的好文章!
  • javascript原型和原型链

    2021-01-08 18:16:24
    一、原型规则 1、所有的引用类型(数组、对象、函数)都具有对象特性,即可自由扩展属性(除了“null”) var array=[];array.a=1; var object={};object.a=1; function func(){}; func.a=1; 2、所有的引用类型...
  • 一个例子让你彻底明白原型对象和原型链 开篇 之前对js中的原型链和原型对象有所了解,每当别人问我什么是原型链和原型对象时,我总是用很官方(其实自己不懂)的解释去描述。有一句话说的好:如果你不能把一个很复杂...
  • 原型 原型链

    2021-11-30 17:28:58
    一般都是会问:原型什么时候产生? 什么是原型? 谈谈你对原型的理解?原型的作用? 啊啊啊啊啊啊啊啊啊 ,开始思考????淡定 1.原型什么时候产生?? 嗯嗯嗯。 当我们 创建一个构造函数的时候 什么都不做 这...

    面试必问!!!

    一般都是会问:原型什么时候产生? 什么是原型?原型的作用? 谈谈你对原型的理解?

    什么是构造函数? 原型和构造函数的关系?

    啊啊啊啊啊啊啊啊啊 ,开始思考????淡定

    1.原型什么时候产生??

    嗯嗯嗯。 当我们 创建一个构造函数的时候 什么都不做 这个时候肯定看不到原型,比如下面这个;

    但是如果我们去执行函数定义(函数定义懂伐??不懂自行查找与执行函数不同哦)的时候 可以发现 这个prototype这个属性

    function Person(name) {
       this.name = name
    }
    
    

    2.什么是原型??

    首先原型是一个对象;

    它有两种:显示原型prototype和隐式原型__proto__; 函数对象有这两种原型,非函数对象只有隐式原型,该对象的__proto__指向对应构造函数的prototype;

    3. 什么是原型链?

    当访问一个对象的属性时,会先从自身属性查找;如果自身属性没有的话 ,就会往它对应构造函数的原型上去寻找;如果还没有找到,再继续往原型的原型上去寻找,直到找到null;这样就形成了一条链,叫做原型链;

    function person() {console.log('ddd')}
    
    person.prototype.age= '1'
    
    person.age (因为目前person的构造函数的prototype上没这个字段,原型的原型上也没有这个字段,直到null)
    undefined
    
    如果在person的构造函数的prototype 上添加一个字段,那么person 本身也能访问到这个字段比如下面这种:
    
    Function.prototype.age = '1111'
    '1111'
    person.age
    '1111'

    4. 原型的作用

    减少内存空间的使用,共享属性或者方法;实现继承

    5.  谈谈你对原型的理解?

    综合上述:

    原型是执行函数定义时产生的,是一个对象,有两种显示原型prototype 和 隐式原型__proto__,构造函数既是函数又是Function的实例对象,所以它同时有这两种, 对象的__proto__指向该对象对应的构造函数的prototype;Funtion 比较特殊,Funtion.prototype === Function.__proto__;

    原型链的结束是null

    6. 构造函数

      构造函数是一种特殊的方法,可以使用new 关键字用来创建以及初始化对象; 如果不使用new 关键字 直接调用就是普通的方法调用

    7. 构造函数和原型的关系

      实例对象.__proto__.constructor === 实例对象的构造函数 === 构造函数本身 === 构造函数的prototype.constructor

     8. 简单关系图

    学习链接:原来你是这样的---原型和原型链 - 谈晓鸣 - 博客园把JS的原型和原型链重新梳理了一遍,然后动手绘制了一张流程图,原型和原型链的秘密就藏在这张图上。绘制流程图的好处就是在绘制的过程中,既检验自己对这个知识点的掌握状况,同时在绘制过程中会对这个知识点印象https://www.cnblogs.com/tandaxia/p/10966885.html#tanOne

    展开全文
  • 原型和原型链整体例子从原型的创建,原型与对象的关联关系,实例与原型的关系以及原型链的形成和运用等等均做了例子的说明
  • 主要介绍了javascript 原型与原型链的理解及应用,结合实例形式分析了javascript原型与原型链的具体原理、功能、使用方法及操作注意事项,需要的朋友可以参考下
  • 一、什么是原型链? 简单回顾下构造函数,原型和实例的关系:  每个构造函数(constructor)都有一个原型对象(prototype),原型对象都包含一个指向构造函数的指针,而实例(instance)都包含一个指向原型对象的内部指针. ...
  • 详解原型与原型链

    千次阅读 2022-03-16 18:04:20
    详解原型与原型链 其实,刚开始学JavaScript时,就有学过原型与原型链的相关知识了,只是当时还没有养成写笔记的习惯,导致现在已经忘的七七八八了。 这边文章真是花了很多心思,写了两天,看了很多篇篇博文,其中有...

    详解原型与原型链

    其实,刚开始学JavaScript时,就有学过原型与原型链的相关知识了,只是当时还没有养成写笔记的习惯,导致现在已经忘的七七八八了。

    这边文章真是花了很多心思,写了两天,看了很多篇篇博文,其中有小参考的,有解决一点疑惑的,但是最后只标注了一篇帮助最大的。


    构造函数

    实例的构造函数属性(constructor)指向其构造函数

    function Person(name) {
      this.name = name
    }
    
    const person = new Person('clz')
    console.log(person.constructor === Person)    // true
    

    实例的构造函数并不是自身属性,而是从原型对象上继承的属性

    function Person(name) {
      this.name = name
    }
    
    const person = new Person('clz')
    console.log(person.constructor === Person)    // true
    console.log(Person.prototype.constructor === Person)    // true
    
    console.log(person.hasOwnProperty('constructor'))     // false:constructor属性并不是实例自身的属性,而是继承来的
    

    原型对象

    • __proto__(隐式原型):每个对象(除了null)都具有的属性,该属性指向该对象的原型
    • prototype(显式原型):只有函数对象才有的属性,该属性指向函数的原型对象

    来看来看

    const arr = [1, 2, 3]
    const obj = {
      name: 'clz'
    }
    function add(a, b) {
      return a + b
    }
    
    console.log(arr)
    console.log(obj)
    console.log(add)
    

    image-20220314161614197


    红框框中的[[prototype]]__proto__意义相同,都是指对象的内部属性

    而所有函数都拥有prototype属性,所以可以通过f.prototype得到,那么自然也不需要通过[[prototype]]显示出来(毕竟prototype是显式原型,而__proto__是隐式原型,好吧,这是我猜的)

    image-20220314162705526


    箭头函数没有prototype属性


    访问原型

    通过实例对象访问原型对象有 3 种方法

    • obj.__proto__
    • obj.constructor.prototype
    • Object.getPrototypeOf(obj)
    function Person(name) {
      this.name = name
    }
    
    const person = new Person('clz')
    
    const proto1 = person.__proto__
    const proto2 = person.constructor.prototype
    const proto3 = Object.getPrototypeOf(person)
    
    const proto = Person.prototype    // 原型
    
    console.log(proto1 === proto)     // true: 第一种方法
    console.log(proto2 === proto)     // true: 第二种方法
    console.log(proto3 === proto)     // true: 第三种方法
    

    比较安全的做法是Object.getPrototypeOf(obj)

    以下部分会涉及一丢丢原型链的知识(如果没看懂,可以看下原型链再来看)

    • __proto__属性是私有属性,存在浏览器兼容性问题,缺乏非浏览器环境的支持

    • 如果obj的constructor属性被覆盖,那么obj.constructor.prototype将会失效。(因为obj自身是没有constructor属性的,是通过原型链去它的原型上获取constructor属性,所以覆盖该属性时,将不会再去原型链上查找)

      function Person(name) {
        this.name = name
      }
      
      function Temp(name) {
        this.name = name
      }
      
      const person = new Person('clz')
      
      person.constructor = Temp
      
      const proto = Person.prototype    // 原型
      
      console.log(person.__proto__ === proto)     // true: 第一种方法
      console.log(person.constructor.prototype === proto)     // false: 第二种方法
      console.log(Object.getPrototypeOf(person) === proto)     // true: 第三种方法
      

    设置原型

    设置原型对象有 3 种方法

    • obj.__proto__=prototypeObj
    • Object.setPrototypeOf(obj, prototypeObj)
    • Object.create(prototypeObj)
    const proto = {   // 原型对象
      name: 'prototype'
    }
    
    // 第一种方法
    const obj1 = {}
    obj1.__proto__ = proto    // 设置原型
    console.log(obj1.name)          // prototype
    console.log(obj1.__proto__ === proto)   // true
    
    // 第二种方法
    const obj2 = {}
    Object.setPrototypeOf(obj2, proto)    // 设置原型
    console.log(obj2.name)          // prototype
    console.log(obj2.__proto__ === proto)   // true
    
    // 第三种方法
    const obj3 = Object.create(proto)   // 创建对象并设置原型
    console.log(obj3.name)          // prototype
    console.log(obj3.__proto__ === proto)   // true
    

    检测原型

    使用obj1.isPrototypeOf(obj2)方法判断obj1是否为·obj2的原型

    const proto = {   // 原型对象
      name: 'prototype'
    }
    
    const proto1 = {
      name: 'prototype'
    }
    
    const obj = {}
    obj.__proto__ = proto    // 设置原型
    
    console.log(proto.isPrototypeOf(obj))   // true
    console.log(Object.prototype.isPrototypeOf(obj))  // true
    
    console.log(proto1.isPrototypeOf(obj))  // false
    

    prototype、__proto__、constructor之间的关系

    image-20220314170210850

    function Person(name) {
      this.name = name
    }
    
    const person = new Person('clz')
    
    console.log(person.__proto__ === Person.prototype)		// true:因为创建person对象的构造函数是Person,所以person对象的隐式原型(__proto__)指向Person函数的原型(prototype)
    console.log(Person.prototype.constructor === Person)	// true
    

    同一个构造函数创建的多个实例的原型是同一个

    function Person(name) {
       this.name = name
     }
    
     const person1 = new Person('clz')
     const person2 = new Person('clz')
    
     console.log(person1 === person2)    // false: 不是同一个对象
     console.log(person1.__proto__ === person2.__proto__)  // true:同一个构造函数创建的实例对象的原型是同一个
    

    原型链

    由上面的知识可以知道,实例对象具有属性__proto__,会指向原型对象。而原型对象也是对象,所以也会有属性__proto__,也会继续指向它的原型对象。

    实例对象在查找属性时,如果查找不到,就会沿着__proto__去它的原型上查找,还找不到,则继续去原型的原型上查找,直到找到或到最顶层为止。这就是原型链的概念。


    对象本身的方法(第一层:把方法当成属性)

    function Person(name) {
      this.name = name
      this.listenMusic = function () {
        console.log('听音乐')
      }
    }
    const person = new Person('clz')
    console.log(person)
    console.log('实例对象本身是否有listenMusic方法', person.hasOwnProperty('listenMusic'))
    person.listenMusic()
    

    image-20220315094508947


    对象的原型上添加方法(第二层)

    function Person(name) {
      this.name = name
    }
    Person.prototype.listenMusic = function () {
      console.log('听音乐')
    }
    
    const person = new Person('clz')
    console.log(person)
    console.log('实例对象本身是否有listenMusic方法', person.hasOwnProperty('listenMusic'))
    person.listenMusic()
    

    image-20220314183755250


    原型的原型上的方法(第三层)

    function Person(name) {
      this.name = name
    }
    Person.prototype.__proto__.listenMusic = function () {
      console.log('听音乐')
    }
    
    const person = new Person('clz')
    console.log(person)
    person.listenMusic()
    

    image-20220314184300125


    但是呢,没法玩第四层,因为已经到顶了(Object.prototype没有原型(原型为null))

    function Person(name) {
      this.name = name
    }
    Person.prototype.__proto__.__proto__.listenMusic = function () {
      console.log('听音乐')
    }
    
    const person = new Person('clz')
    console.log(person)
    person.listenMusic()
    

    image-20220314184424877


    person -> Person.prototype -> Object.prototype -> null

    那么,这里就来看看第三层是不是真的是Object.prototype

    function Person(name) {
      this.name = name
    }
    Person.prototype.__proto__.listenMusic = function () {
      console.log('听音乐')
    }
    
    const person = new Person('clz')
    console.log(person)
    
    console.log(Person.prototype.__proto__ === person.__proto__.__proto__)
    console.log(person.__proto__.__proto__ === Object.prototype)   // 这里就是判断处
    
    person.listenMusic()
    

    image-20220315095211650

    发现,确实如此。

    下面这张图就是原型链的简单图(找不到是在哪里截的图了,侵删)

    image-20220314233252631


    原型链的作用

    为对象设置默认值

    利用原型为对象设置默认值。当原型属性与私有属性同名时,删除私有属性之后,可以访问原型属性,即可以把原型属性值作为初始化默认值。

    function Person(name) {
      this.name = name
    }
    
    Person.prototype.name = '赤蓝紫'
    
    const person = new Person('clz')
    console.log(person.name)    // clz
    
    delete person.name
    console.log(person.name)    // 赤蓝紫
    

    继承

    继承内容部分之后单独写。


    扩展原型方法

    Array.prototype.test = function () {
      console.log('扩展原型方法: 有风险')
    }
    
    const arr = [1, 2, 3]
    arr.test()    // 扩展原型方法: 有风险
    

    typeof

    typeof是判断类型时大多数人的选择(当然也包括我啦),但是,判断非基本数据类型(function除外)时,只能得到Object。(null也是,但是null这个属于是历史遗留bug了)。

    js 在底层存储变量的时候,会在变量的机器码的低位1-3位存储其类型信息

    • 000:对象
    • 010:浮点数
    • 100:字符串
    • 110:布尔
    • 1:整数

    null:所有机器码均为0
    undefined:用 −2^30 整数来表示


    symbolbigint是后来新增的数据类型

    const num = 123
    const str = 'hello'
    const bool = true
    const n = null
    const u = undefined
    const sym = Symbol(1)
    const big = BigInt(123)
    
    const fun = () => console.log(1)
    
    console.log(typeof num)   // number
    console.log(typeof str)   // string
    console.log(typeof bool)  // boolean
    console.log(typeof n)     // object
    console.log(typeof u)     // undefined
    console.log(typeof sym)   // symbol			
    console.log(typeof big)   //bigint
    
    console.log(typeof fun)   //function
    

    function除外的非基本数据类型

    let arr = []
    let obj = {
      name: 'clz'
    }
    let set = new Set([1, 2, 4])
    
    console.log(typeof arr)
    console.log(typeof obj)
    console.log(typeof set) 
    

    清一色object


    通过Object.prototype.toString.call(obj)来识别对象类型。会返回"[object Type]"来告诉你所指对象的类型

    let arr = []
    let obj = {
      name: 'clz'
    }
    let set = new Set([1, 2, 4])
    
    console.log(Object.prototype.toString.call(arr))  // [object Array]
    console.log(Object.prototype.toString.call(obj))  // [object Object]
    console.log(Object.prototype.toString.call(set))  // [object Set]
    

    instanceof

    instanceof只要右边变量的 prototype 在左边变量的原型链上,就会返回true

    function Person(name) {
      this.name = name
    }
    
    function Test(name) {
      this.name = name
    }
    
    
    const person = new Person('clz')
    
    console.log(person instanceof Person)   // true
    console.log(person instanceof Object)   // true
    
    console.log(person instanceof Test)     // false
    

    普通对象与函数对象

    • 所有的函数都是通过new Function()来创建的,即是函数对象

    • 其他的都是普通对象


    function fn1() { }
    const fn2 = function () { }
    const fn3 = () => { }
    const fn4 = new Function()
    
    console.log(typeof fn1)       //function
    console.log(typeof fn2)       //function
    console.log(typeof fn3)       //function
    console.log(typeof fn4)       //function
    
    
    const obj1 = {}
    const obj2 = new Object()
    const obj3 = new fn1()
    
    console.log(typeof obj1);     //object 
    console.log(typeof obj2);     //object 
    console.log(typeof obj3);     //object
    

    上面的例子中,fn1fn2fn3fn4是函数对象,obj1obj2obj3是普通对象

    • Object是构造函数,即也是函数,所以Object也是函数对象,相当于Function的实例,即Object.__proto__ === Function.prototype
    • Object.prototypeObject构造函数的原型,处于原型链的顶端,Object.prototype.__proto__已经没有可以指向的上层原型,因此其值为null
    console.log(typeof Object)    // function
    console.log(Object.__proto__ === Function.prototype)    // true
    console.log(Object.prototype.__proto__)   // null
    

    • Function.prototypeFunction的原型,是所有函数对象的原型
    • Function.prototype是一个普通对象,所以Function.prototype.__proto__ === Object.prototype
    • Function函数不通过任何东西创建,JS引擎启动时,添加到内存中,所以**Function.__proto__ === Function.prototype**
    console.log(typeof Function)    // function
    console.log(Function.prototype.__proto__ === Object.prototype)    // true
    console.log(Function.__proto__ === Function.prototype)   // true
    

    经典原型链图

    img


    练手福利

    题目来自JavaScript之彻底理解原型与原型链

    加了一道

    function User() { }
    User.prototype.sayHello = function () { }
    var u1 = new User();
    var u2 = new User();
    
    console.log(u1.sayHello === u2.sayHello);   
    console.log(User.prototype.constructor);    
    
    console.log(User.prototype === Function.prototype);  
    console.log(User.prototype.__proto__ === Function.prototype.__proto__);  
    console.log(User.prototype === u1.__proto__);  
    
    console.log(User.__proto__ === Function.prototype);  
    console.log(User.__proto__ === Function.__proto__); 
    
    console.log(u1.__proto__ === u2.__proto__);         
    console.log(u1.__proto__ === User.__proto__);         
    
    console.log(Function.__proto__ === Object.__proto__);  
    console.log(Function.prototype.__proto__ === Object.prototype.__proto__); 
    console.log(Function.prototype.__proto__ === Object.prototype);          
    

    校对答案:(可能有一点点难,细嚼慢咽后再反复看就行)

    image-20220315162828873


    参考链接:JS原型(prototype)和原型链完全攻略

    展开全文
  • 由于 JavaScript 是唯一一个被广泛使用的基于原型继承的语言,所以理解两种继承模式的差异是需要一定时间的,今天我们就来了解一下原型和原型链。 原型 10年前,我刚学习JavaScript的时候,一般都是用如下方式来写...
  • js原型与原型链

    2022-02-04 09:11:24
    一、什么是原型 原型是对象。包括显式原型对象和隐式原型对象。 显式原型对象:只有函数对象才有显式原型对象,如下图所示F

    在这里插入图片描述

    一、什么是原型

    原型是对象。包括显式原型对象和隐式原型对象。

    显式原型对象:只有函数对象才有显式原型对象,如下代码所示,函数的prototype属性就是显式原型对象,默认指向空对象。
    注意:在函数的prototype属性添加属性(一般是方法),该函数对应的实例都会获得该属性的使用权。
    function Fn(){}//函数对象才会有显式原型
    console.log(Fn.prototype)//函数的prototype属性就是显式原型对象
    
    隐式原型对象:只要是对象都会有隐式原型对象,并且它的值与该对象对应的构造函数的显式原型对象相等。如下代码所示:
    function Fn(){}//函数对象才会有显式原型
    console.log(Fn.prototype)
    var fn = new Fn()
    console.log(fn.__proto__)//所有对象都会有隐式原型
    //实例对象隐式原型的值 等于 函数对象显式原型的值
    console.log(fn.__proto__ === Fn.prototype)
    Fn.prototype.test = function(){console.log('test')}
    fn.test()//输出test
    

    ①:js中所有的都是对象,函数是一种特殊的对象

    二、原型链

    原型链实际是隐式原型链 ,具体如下

    访问一个对象的属性时,先在自身属性中查找,找到则返回;如果没有,再沿着__proto__这条链向上查找,在自身对应的构造函数显式原型对象中查找,找到则返回;如果最终没找到,返回undefined;原型链的终点是Object的__proto__,也即返回null(object的__proto__是null)。

    三、instanceof运算原理

    如代码所示,原理就是判断L 的原型链上是否有R.prototype,如果有的话就返回true。

    L instanceof R
    

    四、所有对象都是Object的实例对象

    因此所有的对象沿着隐式原型链向上查找一定能找到Object身上,比如说Funtion.prototype是一个对象,沿着__proto__也能找到Object。

    五、所有函数对象都是Funtion的实例对象

    即所有函数对象的__proto__与Funtion.prototype相等,包括Object也是通过Function构造的,因此Object的__proto__也是与Funtion.prototype相等。同时Funtion本身也是由Funtion构造的,故Funtion.proto也是与Funtion.prototype相等。
    function Fn(){}
    var fn = new Fn()
    console.log(Fn instanceof Object)//true
    console.log(Fn instanceof Function)//true
    console.log(Function instanceof Object)//true
    console.log(fn instanceof Object)//true
    console.log(Object instanceof Function)//true
    console.log(Function instanceof Function)//true
    

    可以仔细分析图中所有的__proto__

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

    2022-01-17 20:23:50
    原型:prototype(显式原型) 函数上的一个属性,默认情况下是一个普通的object对象 注意: function a(){} var b = new a();//a没有prototype属性,因为不是函数 构造函数 constructor 原型上的一个属性,指向该...
  • JS原型及原型链总结

    2022-02-28 20:34:34
    原型链一、为什么要使用原型?怎样去理解原型的出现1、对象字面量创建对象的缺点2、`工厂函数`3、构造函数二、使用原型三、原型概念辨析原型链练习 一、为什么要使用原型?怎样去理解原型的出现 1、对象字面量创建...
  • 原型和原型链作为深入学习JavaScript最重要的概念之一,如果掌握它了后,弄清楚例如:JavaScript的继承,new关键字的原来、封装及优化等概念将变得不在话下,那么下面我们开始关于原型和原型链的介绍。 什么是原型?...
  • 本文给大家介绍javascript原型及原型链相关知识,本文分步骤,介绍的非常详细,对js原型原型链相关知识感兴趣的朋友一起学习吧
  • 对象的隐式原型的值为其对应构造函数的显式原型的值。 function Fn(){} //显式原型--->空的Object对象 console.log(Fn.prototype); //隐式原型---> var fn = new Fn();//this.__proto__ = Fn...
  • 原型和原型链

    千次阅读 2021-08-13 20:58:13
    在js中,原型和原型链是一个很重要的知识点,只有理解了它,我们才能更深刻的理解js,在这里,我们将分成几个部分来逐步讲解。 二、构造函数 构造函数和普通函数本质上没什么区别,只不过使用了new关键字创建对象的...
  • 主要介绍了js中的原型,原型对象,原型链的相关资料,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 主要介绍了JavaScript作用域、闭包、对象与原型链,结合实例形式总结分析了javascript中变量与函数的作用域、闭包、对象、原形链相关概念、用法及注意事项,需要的朋友可以参考下
  • 本文实例分析了Javascript原型链的原理。分享给大家供大家参考,具体如下: 一、JavaScript原型链 ECMAScript中描述了原型链的概念,并将原型链作为实现继承的主要方法。其基本思想是利用原型让一个引用类型继承另一...
  • 主要为大家详细介绍了JS原型对象和原型链,感兴趣的小伙伴们可以参考一下
  • 原型是JavaScript中一个比较难理解的概念,原型相关的属性也比较多,对象有”prototype”属性,函数对象有”prototype”属性,原型对象有”constructor”属性。 一、初识原型 在JavaScript中,原型也是一个对象,...
  • 详解JS原型与原型链

    千次阅读 2022-04-04 14:50:18
    4.原型链 5.原型对象中的this指向 6.扩展内置对象(原型对象的应用) 在ES6之前,我们面向对象是通过构造函数实现的。我们把对象的公共属性和方法放在构造函数里 像这样: function student(uname,age) { ...
  • 本文实例讲述了JS原型和原型链原理与用法。分享给大家供大家参考,具体如下: Javascript语言的继承机制一直很难被人理解。 它没有”子类”和”父类”的概念,也没有”类”(class)和”实例”(instance)的区分,...
  • 原型链原型链的继承 这么宽泛的话题怎么描述? 1:从老大开始讲 表示对老大的尊敬 所有普通的prototype链都指向老大 Object.prototype 其包含了许多通用的功能(toString) 2: 所有的函数都会拥有prototype属性 ...
  • 主要和大家一起深入理解JS原型与原型链,原型是JavaScript中一个比较难理解的概念,本文为大家解决这个难题,感兴趣的小伙伴们可以参考一下
  • 主要介绍了图解JS原型和原型链实现原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 文章目录原型 原型
  • JS原型与原型链(面试题)

    千次阅读 2022-01-14 15:56:27
    原型 原型分为两种 ...原型链 获取对象时,如果这个对象身上本身没有这个属性时,它就会去他的原型__proto__上去找,如果还找不到,就去原型的原型上去找…一直找到最顶层(Object.prototype)为止,Ob

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 241,468
精华内容 96,587
关键字:

原型原型链

友情链接: Rocket-Loader-master.zip