搜索
您的当前位置:首页正文

js原型对象和原型链的分析介绍(附代码)

2023-11-29 来源:学路情感网

本篇文章给大家带来的内容是关于js原型和原型链的知识介绍(附代码),有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。

先声明一个构造函数

function People(name,age){ this.name = name; this.age = age; }

把类的方法写在构造函数原型对象中,子类就不能再通过调用父类构造函数来继承方法(属性还是可以继承)

// 给People的原型添加方法People.prototype.speak = function(){ console.log("我是"+this.name); }// 创建子类继承Peoplefunction Man(name,age,huzi){ People.call(this,name,age); this.huzi = huzi; }

(People和Man的属性和方法都可以输出和调用查看,代码里就不展示测试代码了)

这时候怎么让Man去继承People的方法?

Man.prototype = People.prototype; Man.prototype.smoke = function(){ console.log("抽烟"); }

然而这样并不对!不能直接把子类的prototype指向父类的prototype,这样会导致两个构造函数共用一个prototype,其中的方法父类子类的对象都可访问,而正确的情况应该是子类可以访问父类的方法,而父类不能访问子类的方法

js对象的原型也是对象,所以js原型也有原型.

当访问一个对象的方法时,如果对象中存在则直接访问,如果不存在则在对象的原型中寻找,有则访问,没有则在原型的原型中寻找,如果还没有则继续网上寻找,直到找到Object位置

Object是一个类(构造函数),这个类的对象的原型没有原型

js对象的原型,与js原型的原型组成的链式结构叫做js原型链

子类要继承父类的方法,则需要把子类的构造函数的prototype对象的原型(__proto__)设置为父类构造函数的prototype

那么就是这么写:

Man.prototype.__proto__ = People.prototype;

这样写可以,但官方给的有个更好标准的写法(这样写并没错)

// Object.create用于指定原型创建一个对象(空对象) Man.prototype = Object.create(People.prototype); Man.prototype.smoke = function(){ console.log("抽烟"); }

子类继承父类时,除了可以扩展新的方法,还可以重写父类已有的方法,当使用子类对象调用重写的方法时,会执行子类自己的方法

Man.prototype.speak = function(){ console.log("我是男性"); }

相关推荐:

JS核心系列:浅谈原型对象和原型链

js中的作用域链和原型链以及原型继承

js的原型及原型链详解

学习javascript面向对象 理解javascript原型和原型链_javascript技巧

小编还为您整理了以下内容,可能对您也有帮助:

js原型链是什么

原型链是一种机制,指的是JavaScript每个对象包括原型对象都有一个内置的[[proto]]属性指向创建它的函数对象的原型对象,即prototype属性。

作用:原型链的存在,主要是为了实现对象的继承。

关于原型链的几个概念:

1、函数对象

在JavaScript中,函数即对象。

2、原型对象

当定义一个函数对象的时候,会包含一个预定义的属性,叫prototype,这就属性称之为原型对象。

//函数对象

function F(){};

console.log(F.prototype)

3、__proto__

JavaScript在创建对象的时候,都会有一个[[proto]]的内置属性,用于指向创建它的函数对象的prototype。原型对象也有[[proto]]属性。因此在不断的指向中,形成了原型链。

举个例子来说,我们将对象F的原型对象修改一下,就可以清楚看到上述的关系

//函数对象

function F(){};

F.prototype = {

hello : function(){}

};

var f = new F();

console.log(f.__proto__)

4、new

当使用new去调用构造函数时,相当于执行了

var o = {};

o.__proto__ = F.prototype;

F.call(o);因此,在原型链的实现上,new起到了很关键的作用。

5、constructor

原型对象prototype上都有个预定义的constructor属性,用来引用它的函数对象。这是一种循环引用。

function F(){};

F.prototype.constructor === F;在实际运用中,经常会有下列的写法

function F(){};

F.prototype = {

constructor : F,

doSomething : function(){}

}这里要加constructor是因为重写了原型对象,constructor属性就消失了,需要自己手动补上。

6、原型链的内存结构

function F(){

this.name = 'zhang';

};

var f1 = new F();

var f2 = new F();

javascript原型,原型链 有什么特点

javascript原型,原型链特点:原型链实现了继承。

JS中每个函数都存在有一个原型对象属性prototype。并且所有函数的默认原型都是Object的实例。每个继承父函数的子函数的对象都包含一个内部属性proto。该属性包含一个指针,指向父函数的prototype。若父函数的原型对象的_proto_属性为再上一层函数。在此过程中就形成了原型链。

原型链的作用是用来实现继承,比如我们新建一个数组,数组的方法就是从数组的原型上继承而来的。

var arr = [];

arr.map === Array.prototype.map //arr.map

是从arr.__proto__上继承下来的,arr.__proto__也就是Array.prototype。

扩展资料:

1.JS中每个函数都存在有一个原型对象属性prototype。并且所有函数的默认原型都是Object的实例。

2.每个继承父函数的子函数的对象都包含一个内部属性_proto_。该属性包含一个指针,指向父函数的prototype。若父函数的原型对象的_proto_属性为再上一层函数。在此过程中就形成了原型链。

3.原型链实现了继承。原型链存在两个问题:a 包含引用类型值的原型属性会被所有实例共享。b 在创建子类型时,无法向超类型的构造函数中传递参数。

参考资料:百度百科-javascript

js中什么是原型对象和原型链

每个 JavaScript 对象内部都有一个指向其它对象的“指针”或者 “引用“, 并通过这种方式在对象之间建立了一种联系,形成了一种链式结构,我的理解这就是所谓的原型链。

function F() {} // F 是一个函数,函数也是对象,而且每个函数都有一个属性叫:"prototype"
var o = new F(); // F.prototype 就是 o 的原型对象

console.log(o.name);
// 输出: undefined

F.prototype.name = "foo";
console.log(o.name);
// 输出: foo


// 上面这个例子是想说明:通过 new 在对象 o 与对象 F.prototype 之间建立了联系, 这个建立联系
// 的方式有人叫 "原型继承" 。 当访问的对象属性不存在时,就会沿着原型链去查找。

js中什么是原型对象和原型链

每个 JavaScript 对象内部都有一个指向其它对象的“指针”或者 “引用“, 并通过这种方式在对象之间建立了一种联系,形成了一种链式结构,我的理解这就是所谓的原型链。

function F() {} // F 是一个函数,函数也是对象,而且每个函数都有一个属性叫:"prototype"
var o = new F(); // F.prototype 就是 o 的原型对象

console.log(o.name);
// 输出: undefined

F.prototype.name = "foo";
console.log(o.name);
// 输出: foo


// 上面这个例子是想说明:通过 new 在对象 o 与对象 F.prototype 之间建立了联系, 这个建立联系
// 的方式有人叫 "原型继承" 。 当访问的对象属性不存在时,就会沿着原型链去查找。

JavaScript原型,原型链 有什么特点

1.1 一切皆为对象

JavaScript里所有的东西都是对象. 对象是属性的集合. 数字, 字符串, 布尔值等原始值是"伪对象", 它们同样拥有属性, 但是是在栈上分配并按值传递. 而其他的对象是堆上分配并按引用传递.

一个很重要的概念是, 函数也是对象, 能够作为变量的值, 返回值, 参数或者属性的值. 函数对象特殊的地方是能通过"xxx()"语法执行包含在xxx函数对象内的代码. 因为这一特殊性, typeof xxx 将会返回function, 但这只是一种便利设施.

1.2 对象的属性可以动态添加和删除

var foo = new Object();

// 为foo对象添加bar属性

foo.bar = "foobar";

alert(foo.bar); //foobar

// 删除foo对象的bar属性

delete foo.bar;

alert(foo.bar); //undefined

1.3 除了宿主对象, 其它对象皆由构造函数创建

要有对象, 就先要有创建对象的方法. 

在C++/Java等语言, 这个方法就是实例化XXX类的一个实例xxx.

而在JavaScript的世界里实际没有类的东西, 当然仍然可以用"类"和"实例"等惯用语来描述JavaScript中类似的行为, 但其机制是完全不同的. JavaScript的对象是由构造函数创建的, 每个对象都有constructor属性表示创建该对象的构造函数:

function Test() { this.a = "hello"; }

var test = new Test(); // 由Test构造函数创建

alert(test.constructor);

var o = { a: "hello" };

//实际相当于

var o_ = new Object();

o_.a = "hello"; // 由Object构造函数创建

alert(o.constructor);

构造函数也是对象, 那构造函数是由什么创建? 内建的Function函数:

function Test(a, b)

{

alert(a+b);

}

// 相当于:

Test = new Function(["a", "b"], "alert(a+b);");

Function函数又是由什么创建? 实际上Function是本机代码实现的固有对象. 不过为了一致性, Function也有constructor属性, 该属性指向它自己. 接上面的代码:

/* 输出 function Function(){

[native code]

}

*/

alert(Test.constructor);

alert(Test.constructor.constructor === Test.constructor); // true

alert(Test.constructor === Object.constructor); // true

2 原型prototype

2.1 prototype的概念

prototype是构造函数的一个属性, 该属性指向一个对象. 而这个对象将作为该构造函数所创建的所有实例的基引用(base reference), 可以把对象的基引用想像成一个自动创建的隐藏属性. 当访问对象的一个属性时, 首先查找对象本身, 找到则返回; 若不, 则查找基引用指向的对象的属性(如果还找不到实际上还会沿着原型链向上查找,  直至到根). 只要没有被覆盖的话, 对象原型的属性就能在所有的实例中找到.

原型默认为Object的新实例, 由于仍是对象, 故可以给该对象添加新的属性:

// prototype默认为new Object(); 为了方便, 记为p_obj

function Person(name) {

this.name = name;

}

// 为 p_obj 增加 sayName 属性

Person.prototype.sayName = function(){

alert(this.name);

}

var john = new Person("John"); // john 的 base reference指向p_obj

var eric = new Person("Eric");  // eric 的 base reference也是指向p_obj

// 注意sayName代码中的this将指向实例化后的对象(this绑定)

john.sayName(); // john对象本身没有sayName属性, 于是访问原型对象p_obj的sayName属性

eric.sayName(); // 访问同一个原型对象p_obj的sayName属性

var tmp = Person.prototype;

tmp.boss = "David";

// 于这个运行点, p_obj已经被修改

// 根据上述属性访问流程, 新的修改(boss属性)能反映到所有的实例, 包括已经创建和即将创建的

alert("John's boss is " + john.boss);

alert("Eric's boss is " + eric.boss);

// hisCar和sayCar属性将增加到john对象而不是p_obj对象..

john.hisCar = "Audi";

john.sayCar = function(){

alert(this.name + " has a car of " + this.hisCar);

}

john.sayCar();

// ..因此下一句将错误, 因为eric对象本身和原型p_obj都没有sayName属性

/* eric.sayCar(); */

2.2 原型链

除了能修改prototype指向的对象, 还能修改prototype指向哪一个对象, 即为prototype赋予一个不同的对象. 这可以实现一种简单的继承:

function Superman() {}

Superman.prototype.sayHello = function(){

alert("I'm a superman.");

}

function SupermanCan(skill){

this.skill = skill;

}

// 为prototype赋予Superman的实例..

SupermanCan.prototype = new Superman();

// ..再动态添加新的属性

SupermanCan.prototype.sayMore = function(){

this.sayHello(); // 调用"父类"的方法

alert("I can " + this.skill);

}

var david = new SupermanCan("fly");

// output: I'm a superman. I can fly

david.sayMore();

如果先实例化出一个对象, 再为构造函数prototype赋予一个不同的对象, 将会: 已经创建的对象的基引用不变, 将来创建的对象的基引用为新的原型对象:

var f1 = {echo: function() { alert("sound"); } };

function Foo() {};

var foo = new Foo(); // foo的基引用指向Object实例

Foo.prototype = f1;

/* 未定义, 因为这是"foo对象自己或者基引用指向的对象有echo属性吗?"

而不是"foo对象自己或者Foo.prototype指向的对象有echo属性吗?" */

alert(foo.echo);

var foo2 = new Foo(); // foo2的基引用指f1对象

foo2.echo(); // output: sound

所有的构造函数的prototype都不能为空, 就是说Superman.prototype = null 会被解释引擎无视;  另一方面, Object构造函数也有prototype属性(该属性是只读的, 可以为原型增加属性,但不能赋予不同的对象), 故因此可以有多层的原型链, 但原型链的根必定会是Object.prototype . 这意味着给Object.prototype增加属性影响到所有对象:

Object.prototype.echo = function() {

alert("hello");

}

// echo属性将增加到所有对象固有对象和自定义对象

var arr = new Array();

arr.echo();

Array.echo();

function ObjCons()    {

this.mmy = "d";

}

var obj = new ObjCons();

obj.echo();

ObjCons.echo();

3. 构造函数和new的实质

构造函数是一个地地道道的函数, 一个函数之所以能成为构造函数, 是因为new运算符:

this.msg = "window";

function Test()

{

alert(this.msg);

}

Test(); // window

var test = new Test(); // undefined. 因为test对象没有定义msg属性

二者区别在于如何切入对象: Test() 在某个对象(例子中为window)的上下文上执行代码, 即this指向这个对象; new Test()创建一个新对象, 并以这个新的对象为上下文(this指向新对象)执行代码, 然后返回这个新对象. 

假如有个函数:

function Test() {

var mmy = "have money";

this.wish = mmy;

doSomeThing();

}

结合以上的所有论述, 可以推测new Test()行为的伪代码表示为:

创建一个新对象temp;

temp.constructor = Test;

temp.(base reference) = Test.prototype; // 这一句先于代码体执行, 意味着构造函数里的this.xxx能访问原型对象的属性xxx

bind: this = temp; // 将this绑定到temp对象

// 开始执行函数代码

var mmy = "have money";

this.wish = mmy; // 为temp对象添加wish属性

doSomeThing();

....

// 结束执行函数代码

return temp;

这个未必会符合内部的二进制实现, 但却能很好地解释了JavaScript的特性.

js原型和原型链的理解是什么?


这里prototype表示系统自带的属性,第一句话表示设置了Person的祖先有一个属性Lastname,后面创建person和person1

属性的时候就会继承这个属性值


一个小的例子表示继承的关系

prototype可以将一些对象共有的东西致只写一遍,不同每次都创建一遍


此外,还可以把原型封装起来,这样会更好


上个例子中的constructor是一个系统自带的属性(叫做构造器),他是从prototype继承过来的,并且这个属性是可以更改的,它的内容是构造函数我们可以看一下


浅紫色的代表系统自带的


而另一个属性__proto__的内容是prototype的内容(两个__是隐式命名规则)

一般在开发中如果你不想让同事访问或者改变一个参数,那么就会想这样命名一个参数,js中没有绝对的private


这里是一个修改__proto__的例子,这样ff就可以访问person.prototype里面的值了



这里访问Person.name依然会是sunny,因为这个例子就好像


虽然改变了整个prototype的结构,但是在第二次改变为cherry之前,已经

也就是在被new的时候this{}里面的值就会返回给person,然后再改变成cherry的时候就不会被影响了,所以这压力要考虑执行顺序。

但是如果改变函数语句顺序:


那么person.name就会变成cherry,因为执行顺序变了

但是如果是这样来修改,就能修改成功了

原型链


这是一个原型链,通过prototype这个结点链接,这样的话,son就能访问到lastname,然后其实Grand上面还有一个原型,有一个Grand.prototype=object object是所有原型链的终端





因为new是person的,所以this{}返回给person,

person.__proto__链接的是Person.prototype,所以不变(也就是说Person.prototype除了直接修改,都变不了)



Person不能直接访问sayName

Object.create(原型):


这样的话就能访问到Person中的prototype,但是不能访问到age这个内部数据


这样是能都访问到的:


之前有一句话叫:绝大多数对象最终都谁继承自Object.prototype

但是并不是所有对象都是继承自它的,因为存在以下例外:


这样的的话:


obj里面就没有__proto__了

如果手动给他加上__proto__:


但是这样的话


就找不到obj.name了,要访问这个数据只能:


/*************************************************************************************************************/

拓展:

toString()方法:

toString()方法是Object.prototype里面自带的,所以绝大数对象都会有这个方法(除了undefined和null)


这两个不能通过包装类来继承Object的原型,所以访问不了。


数字只能这样访问,而不能:


因为数字里面的‘.’优先级很高,系统会把它认为是小数点(浮点类型),所以会报错

而布尔类型就能直接这样


我们再来详细解析一下:


num.toString()就会出现包装类:


而其实Number的原型里面有一个重写的toString()方法:


而根据原型链,Number的原型里面的__proto__会继承Object的原型:


所以当调用num.toString()方法时会一级一级往上,先调用Number里的这个函数原型

再来实战:



这里调用的肯定是:


这里从object.prototype继承过来的toString方法,如果我想要截断它:


只需要重写这个方法就行了

结果:


下面是一些已经自动重写过的:


最后讲一个小bug:


这是因为js的精度不准的原因,

本文讲解了原型、原型链 的相关内容,更多相关知识请关注Gxl网。

js原型和原型链的理解是什么?


这里prototype表示系统自带的属性,第一句话表示设置了Person的祖先有一个属性Lastname,后面创建person和person1

属性的时候就会继承这个属性值


一个小的例子表示继承的关系

prototype可以将一些对象共有的东西致只写一遍,不同每次都创建一遍


此外,还可以把原型封装起来,这样会更好


上个例子中的constructor是一个系统自带的属性(叫做构造器),他是从prototype继承过来的,并且这个属性是可以更改的,它的内容是构造函数我们可以看一下


浅紫色的代表系统自带的


而另一个属性__proto__的内容是prototype的内容(两个__是隐式命名规则)

一般在开发中如果你不想让同事访问或者改变一个参数,那么就会想这样命名一个参数,js中没有绝对的private


这里是一个修改__proto__的例子,这样ff就可以访问person.prototype里面的值了



这里访问Person.name依然会是sunny,因为这个例子就好像


虽然改变了整个prototype的结构,但是在第二次改变为cherry之前,已经

也就是在被new的时候this{}里面的值就会返回给person,然后再改变成cherry的时候就不会被影响了,所以这压力要考虑执行顺序。

但是如果改变函数语句顺序:


那么person.name就会变成cherry,因为执行顺序变了

但是如果是这样来修改,就能修改成功了

原型链


这是一个原型链,通过prototype这个结点链接,这样的话,son就能访问到lastname,然后其实Grand上面还有一个原型,有一个Grand.prototype=object object是所有原型链的终端





因为new是person的,所以this{}返回给person,

person.__proto__链接的是Person.prototype,所以不变(也就是说Person.prototype除了直接修改,都变不了)



Person不能直接访问sayName

Object.create(原型):


这样的话就能访问到Person中的prototype,但是不能访问到age这个内部数据


这样是能都访问到的:


之前有一句话叫:绝大多数对象最终都谁继承自Object.prototype

但是并不是所有对象都是继承自它的,因为存在以下例外:


这样的的话:


obj里面就没有__proto__了

如果手动给他加上__proto__:


但是这样的话


就找不到obj.name了,要访问这个数据只能:


/*************************************************************************************************************/

拓展:

toString()方法:

toString()方法是Object.prototype里面自带的,所以绝大数对象都会有这个方法(除了undefined和null)


这两个不能通过包装类来继承Object的原型,所以访问不了。


数字只能这样访问,而不能:


因为数字里面的‘.’优先级很高,系统会把它认为是小数点(浮点类型),所以会报错

而布尔类型就能直接这样


我们再来详细解析一下:


num.toString()就会出现包装类:


而其实Number的原型里面有一个重写的toString()方法:


而根据原型链,Number的原型里面的__proto__会继承Object的原型:


所以当调用num.toString()方法时会一级一级往上,先调用Number里的这个函数原型

再来实战:



这里调用的肯定是:


这里从object.prototype继承过来的toString方法,如果我想要截断它:


只需要重写这个方法就行了

结果:


下面是一些已经自动重写过的:


最后讲一个小bug:


这是因为js的精度不准的原因,

本文讲解了原型、原型链 的相关内容,更多相关知识请关注Gxl网。

简述js原型链

1.、js的对象可以分为函数对象和普通对象,每个对象都有 proto 属性,但是只有函数对象才有prototype属性(prototype=原型对象)

2、Object是最高级的函数对象,Function、Array、RegExp、Date、Boolean、Number、String等等是第二高级的函数对象,我们自己手写的function是再低一级的函数对象

3、 proto 是一个对象,它指向某一个prototype,并且有2个属性:constructor和 proto

先来看第一种写法

我们声明了一个构造函数Person,并为它的2个实例都定义了sayName方法

如果我们希望所有的实例都有sayName方法,减少重复的定义

可以像下面这么写:(第二种写法)

我们在构造函数Person中定义了一个数据成员和一个函数成员

每当我们创造一个新的Person实例时,都会在内存中单独为它分配私有的空间

也就是说,p1和p2都有自己的name属性和sayName方法

这个name属性和sayName方法是实例自己私有的

在控制台直接打印p1得到如下结果:(第一、第二种写法是等价的)

再来看第三种写法:

这样的话,每个Person实例依然都会有name属性和sayName方法

不同的地方在哪呢?

在控制台直接打印p1得到如下结果:

不难发现,当前这种写法是将sayName定义在Person的原型对象上的

也就是说,sayName方法不再是每个Person实例私有的,而是所有Person实例共享的

这样做 既不影响每个实例打印/输出自己的name值,又可以节省内存

还是相同的例子

当我们在程序中调用 p1.sayName方法时,编译器会 沿着原型链(自底向上) 地寻找原型对象上是否有这个方法

如上图所示,编译器会先从p1自身(最外层)开始找

然后去 p1. proto (即Person的原型对象 = 外层红色方框)里面找

最后再到 p1. proto . proto (即Object的原型对象 = 内层红色方框)里面找

彻底理解js的原型链

本文主要参考了 MDN文档 和 知乎讨论 。

在js中,大部分东西都是对象,数组是对象,函数也是对象,对象更加是对象。 不管我们给数组和函数定义什么内容,它们总是有一些相同的方法和属性 。比如说hasOwnProperty(),toString()等:

这说明一个对象所拥有的属性不仅仅是它本身拥有的属性,它还会从其他对象中继承一些属性。当js在一个对象中找不到需要的属性时,它会到这个对象的父对象上去找,以此类推,这就构成了对象的原型链 。理解js的原型链对使用js的对象非常有帮助。

让我们通过一个例子由浅到深地理解原型链:

这是我们经常使用的创建对象的方式,将共同的方法放到Foo.prototype中,所有实例都共有这个方法了。

这是怎么实现的呢?我们看下面这张图的第一行:

我们定义的show函数在Foo.prototype中,当我们执行f1.show()时,js发现f1本身没有show这个属性,所以它就到f1的原型(也就是__proto__指向的对象)去找,找到了就可以调用。

图片第一行告诉了我们4点:

我们先看看Foo的原型吧!Foo是一个函数,它的构造函数是js内部的function Function(),Function的prototype指向了一个对象Function.prototype,因此Foo的__proto__就指向了Function.prototype,如图。

我们继续深入下去,Function.prototype这个对象,它就是一个普通的对象,它的构造函数是js内置的function Object(),function Object()的prototype指向Object.prototype,因此Function.prototype.__proto__就指向Object.prototype,这个对象中定义了所有对象共有的属性,比如我们之前说的hasOwnProperty()和toString()等。

Object.prototype就是原型链的终点了,它的__proto__是null,js查找属性时,如果到这里还没有找到,那就是undefined了。

到这里就不难理解为什么我们说在js中,函数也是对象了,它就是继承自对象的!

如果如有疑问,欢迎指出!

学路情感网还为您提供以下相关内容希望对您有帮助:

js中什么是原型对象和原型链

每个 JavaScript 对象内部都有一个指向其它对象的“指针”或者 “引用“, 并通过这种方式在对象之间建立了一种联系,形成了一种链式结构,我的理解这就是所谓的原型链。function F() {} // F 是一个函数,函数也是对象...

简述js原型链

1.、js的对象可以分为函数对象和普通对象,每个对象都有 proto 属性,但是只有函数对象才有prototype属性(prototype=原型对象)2、Object是最高级的函数对象,Function、Array、RegExp、Date、Boolean、Number、String等等是第二...

彻底理解js的原型链

这个对象中定义了所有对象共有的属性,比如我们之前说的hasOwnProperty()和toString()等。Object.prototype就是原型链的终点了,它的__proto__是null,js查找属性时,如果到这里还没有找到,那就是undefined了。到这里就不难...

JavaScript原型,原型链 有什么特点

1.1 一切皆为对象JavaScript里所有的东西都是对象. 对象是属性的集合. 数字, 字符串, 布尔值等原始值是"伪对象", 它们同样拥有属性, 但是是在栈上分配并按值传递. 而其他的对象是堆上分配并按引用传递.一个很重要的...

对原型链、原型对象的理解总结

找不到再去指向的prototype 4.原型链         每个对象都有__proto__属性,原型对象也不意外,它的__proto__属性指向Object构造函数的prototype原型对象

原型对象和对象原型以及原型链

有__proto__ 原型,指向 原型对象 ② 实例 的原型对象里面的 __proto__ 原型指向的是 Object.prototype ③ Object.prototype 里面的 __proto__ 原型指向的是 null ④由__proto__原型连接而成的'链子'就是原型链 ...

js对象,原型与原型链,属性特征

所以才会有 方括号([])表达符。prototype是函数才有的属性 proto 是每个对象都有的属性,但是 proto 不是一个规范属性,只是部分浏览器实现此属性,对应标准属性是[[Prototype]]在js中所有对象都是可扩展的 ...

javascript 原型,原型链是什么?有什么特点

原型是JS的一个引用对象,就是说prototype本身就是一个对象,和OBJECT没什么不同 所有的属性中都会包含一个属性__proto__来指向你的原型对象 例如 function ROOT(){}ROOT.A = 1ROOT.prototype.B = 2;//object对象是...

原型跟原型链区别是什么?有大神可以解释一下吗?请不要百度复制粘贴过来...

图形化原型链 虽然我们都说原型链,但实际上,在不考虑网页中frame的情况,js引擎在执行期间的某一时刻,所有存在的对象组成的是一棵原型树.默认情况下,只有一棵树.根节点可以说是Object.prototype,也可以说是null.但我们可以...

js原型链和继承的理解

1.原型继承链顶端为Object 。Js函数是对象 2.当读取对象中的属性时,先去实例本身中搜索,如搜索不到则去指向的原型中搜索 1.原型的存在意义在于实现继承共享,是在构造函数中定义的一个成员对象,在下次实例化时不需要在...

本文如未解决您的问题请添加抖音号:51dongshi(抖音搜索懂视),直接咨询即可。

热门图文

  • 次韵钱申伯山堂之咏的朝代是什么

    《次韵钱申伯山堂之咏》李弥逊朝代:宋代。《次韵钱申伯山堂之咏》年代:宋代。作者:李弥逊。别称:西翁、筠溪居士、普现居士。字号:字似之号筠西翁、筠溪居士、普现居士等。出生地:吴县(今江苏苏州)。出生时间:1085年。去世时间:1153年。主要作品:《沁园春》《永遇乐》《永遇乐》《念奴娇》《念奴娇》等。我们为您从以下几个方面提供次韵钱申伯山堂之咏的详细介绍。一、《次韵钱申伯山堂之咏》的全文 点此查看《次韵钱申伯山堂之咏》的详细内容。净坊秋色老苍官,檐额飞云细可攀。客梦偶随疏雨断,僧游长带暮钟还。似闻遗锡藏银地,亲见高人住骨山。愁绝寒江归去路,乱峰青处望双鬟。二、《次韵钱申伯山堂之咏》李弥逊其他诗词《菩萨蛮》、《水调歌头》、《念奴娇》、《水调歌头》、《永遇乐》。相同朝代的诗歌;

  • 次韵钱申伯山堂之咏的朝代

    《次韵钱申伯山堂之咏》李弥逊朝代:宋代。《次韵钱申伯山堂之咏》年代:宋代。作者:李弥逊。别称:西翁、筠溪居士、普现居士。字号:字似之号筠西翁、筠溪居士、普现居士等。出生地:吴县(今江苏苏州)。出生时间:1085年。去世时间:1153年。主要作品:《沁园春》《永遇乐》《永遇乐》《念奴娇》《念奴娇》等。我们为您从以下几个方面提供次韵钱申伯山堂之咏的详细介绍。一、《次韵钱申伯山堂之咏》的全文 点此查看《次韵钱申伯山堂之咏》的详细内容。净坊秋色老苍官,檐额飞云细可攀。客梦偶随疏雨断,僧游长带暮钟还。似闻遗锡藏银地,亲见高人住骨山。愁绝寒江归去路,乱峰青处望双鬟。二、《次韵钱申伯山堂之咏》李弥逊其他诗词《菩萨蛮》、《水调歌头》、《念奴娇》、《水调歌头》、《永遇乐》。相同朝代的诗歌;

  • 次韵钱申伯山堂之咏朝代

    《次韵钱申伯山堂之咏》李弥逊朝代:宋代。《次韵钱申伯山堂之咏》年代:宋代。作者:李弥逊。别称:西翁、筠溪居士、普现居士。字号:字似之号筠西翁、筠溪居士、普现居士等。出生地:吴县(今江苏苏州)。出生时间:1085年。去世时间:1153年。主要作品:《沁园春》《永遇乐》《永遇乐》《念奴娇》《念奴娇》等。我们为您从以下几个方面提供次韵钱申伯山堂之咏的详细介绍。一、《次韵钱申伯山堂之咏》的全文 点此查看《次韵钱申伯山堂之咏》的详细内容。净坊秋色老苍官,檐额飞云细可攀。客梦偶随疏雨断,僧游长带暮钟还。似闻遗锡藏银地,亲见高人住骨山。愁绝寒江归去路,乱峰青处望双鬟。二、《次韵钱申伯山堂之咏》李弥逊其他诗词《菩萨蛮》、《水调歌头》、《念奴娇》、《水调歌头》、《永遇乐》。相同朝代的诗歌;

  • 次韵钱申伯山堂之咏的作者 次韵钱申伯山堂之咏的作者是什么]

    《次韵钱申伯山堂之咏》李弥逊作者:李弥逊。《次韵钱申伯山堂之咏》作者:李弥逊。年代:宋代。别称:西翁、筠溪居士、普现居士。字号:字似之号筠西翁、筠溪居士、普现居士等。出生地:吴县(今江苏苏州)。出生时间:1085年。去世时间:1153年。主要作品:《沁园春》《永遇乐》《永遇乐》《念奴娇》《念奴娇》等。我们为您从以下几个方面提供次韵钱申伯山堂之咏的详细介绍。一、《次韵钱申伯山堂之咏》的全文 点此查看《次韵钱申伯山堂之咏》的详细内容。净坊秋色老苍官,檐额飞云细可攀。客梦偶随疏雨断,僧游长带暮钟还。似闻遗锡藏银地,亲见高人住骨山。愁绝寒江归去路,乱峰青处望双鬟。二、《次韵钱申伯山堂之咏》李弥逊其他诗词《菩萨蛮》、《水调歌头》、《念奴娇》、《水调歌头》、《永遇乐》。相同朝代的诗歌;

  • 次韵钱申伯山堂之咏的作者是什么

    《次韵钱申伯山堂之咏》李弥逊作者:李弥逊。《次韵钱申伯山堂之咏》作者:李弥逊。年代:宋代。别称:西翁、筠溪居士、普现居士。字号:字似之号筠西翁、筠溪居士、普现居士等。出生地:吴县(今江苏苏州)。出生时间:1085年。去世时间:1153年。主要作品:《沁园春》《永遇乐》《永遇乐》《念奴娇》《念奴娇》等。我们为您从以下几个方面提供次韵钱申伯山堂之咏的详细介绍。一、《次韵钱申伯山堂之咏》的全文 点此查看《次韵钱申伯山堂之咏》的详细内容。净坊秋色老苍官,檐额飞云细可攀。客梦偶随疏雨断,僧游长带暮钟还。似闻遗锡藏银地,亲见高人住骨山。愁绝寒江归去路,乱峰青处望双鬟。二、《次韵钱申伯山堂之咏》李弥逊其他诗词《菩萨蛮》、《水调歌头》、《念奴娇》、《水调歌头》、《永遇乐》。相同朝代的诗歌;

Top