JS原型链和访问对象原型的方法

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

2016/03/01 · JavaScript
· 2 评论 ·
原型对象,
原型链

原文出处: 一像素   

在Javascript中,万物皆对象,但对象也有区别,大致可以分为两类,即:普通对象(Object)和函数对象(Function)。

一般而言,通过new Function产生的对象是函数对象,其他对象都是普通对象。

举例说明:

function f1(){ //todo } var f2 = function(){ //todo }; var f3 = new
Function(‘x’,’console.log(x)’); var o1 = {}; var o2 = new Object(); var
o3 = new f1(); console.log( typeof f1,//function typeof f2,//function
typeof f3,//function typeof o1,//object typeof o2,//object typeof o3
//object ); >> function function function object object object

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function f1(){
    //todo
}
var f2 = function(){
    //todo
};
var f3 = new Function(‘x’,’console.log(x)’);
 
var o1 = {};
var o2 = new Object();
var o3 = new f1();
 
console.log(
    typeof f1,//function
    typeof f2,//function
    typeof f3,//function
    typeof o1,//object
    typeof o2,//object
    typeof o3 //object
);
>> function function function object object object

f1属于函数的声明,最常见的函数定义方式,f2实际上是一个匿名函数,把这个匿名函数赋值给了f2,属于函数表达式,f3不常见,但也是一种函数对象。

Function是JS自带的对象,f1,f2在创建的时候,JS会自动通过new
Function()的方式来构建这些对象,因此,这三个对象都是通过new
Function()创建的。

在Javascript中创建对象有两种方式:对象字面量和使用new表达式,o1和o2的创建恰好对应了这两种方式,重点讲一下o3,
如果用Java和C#的思路来理解的话,o3是f1的实例对象,o3和f1是同一类型,至少我以前这么认为,其实不然…

那么怎么理解呢? 很简单,看o3是不是通过new Function产生的,
显然不是,既然不是函数对象,那就是普通对象 。

通过对函数对象和普通对象的简单理解之后,我们再来了解一下Javascript中的原型和原型链:

在JS中,每当创建一个函数对象f1
时,该对象中都会内置一些属性,其中包括prototype和__proto__,
 prototype即原型对象,它记录着f1的一些属性和方法。

需要注意的是,prototype
对f1是不可见的,也就是说,f1不会查找prototype中的属性和方法。

function f(){} f.prototype.foo = “abc”; console.log(f.foo); //undefined

1
2
3
function f(){}
f.prototype.foo = "abc";
console.log(f.foo); //undefined

那么,prototype有什么用呢? 其实prototype的主要作用就是继承。
通俗一点讲,prototype中定义的属性和方法都是留给自己的“后代”用的,因此,子类完全可以访问prototype中的属性和方法。

想要知道f1是如何把prototype留给“后代”,我们需要了解一下JS中的原型链,此时,JS中的
__proto__
入场了,这哥们长的很奇特,隐藏的也很深,以致于你经常见不到它,但它在普通对象和函数对象中都存在,
它的作用就是保存父类的prototype对象,JS在通过new
表达式创建一个对象的时候,通常会把父类的prototype赋值给新对象的__proto__属性,这样,就形成了一代代传承…

function f(){} f.prototype.foo = “abc”; var obj = new f();
console.log(obj.foo); //abc

1
2
3
4
function f(){}
f.prototype.foo = "abc";
var obj = new f();
console.log(obj.foo); //abc

现在我们知道,obj中__proto__保存的是f的prototype,
那么f的prototype中的__proto__中保存的是什么呢? 看下图:

mgm娱乐场 1

如图所示,f.prototype的__proto__中保存的是Object.prototype,Object.prototype对象中也有__proto__,而从输出结果看,Object.prototype.__proto__
是null,表示obj对象原型链的终结。如下图所示:

mgm娱乐场 2

obj对象拥有这样一个原型链以后,当obj.foo执行时,obj会先查找自身是否有该属性,但不会查找自己的prototype,当找不到foo时,obj就沿着原型链依次去查找…

在上面的例子中,我们在f的prototype上定义了foo属性,这时obj就会在原型链上找到这个属性并执行。

 

最后,用几句话总结一下本文中涉及到的重点:

  1. 原型链的形成真正是靠__proto__
    而非prototype,当JS引擎执行对象的方法时,先查找对象本身是否存在该方法,如果不存在,会在原型链上查找,但不会查找自身的prototype。
  2. 一个对象的__proto__记录着自己的原型链,决定了自身的数据类型,改变__proto__就等于改变对象的数据类型。
  3. 函数的prototype不属于自身的原型链,它是子类创建的核心,决定了子类的数据类型,是连接子类原型链的桥梁。
  4. 在原型对象上定义方法和属性的目的是为了被子类继承和使用。

 

2 赞 17 收藏 2
评论

mgm娱乐场 3

大家好,我是IT修真院深圳分院第01期学员,一枚正直纯洁善良的web程序员。

今天给大家分享一下,修真院官网JS(职业)任务4,深度思考中的知识点——JS原型链和访问对象原型的方法

1.介绍

JavaScript 中,万物皆对象。JavaScript根据”原型链”(prototype
chain)模式,来实现继承。

2.涉及

2.1对象

JavaScript中,对象是有区别的,分为普通对象和函数对象,Object ,Function
是JS自带的函数对象,function定义方式本质上还是new Function方式。

function  f1(){};

var f2 = function(){};

var f3 = new Function(‘str’,’console.log(str)’);

var o3 = new f1();

var o1 = {};

var o2 =new Object();

console.log(typeof  Object);  //function

console.log(typeof  Function);  //function

console.log(typeof o1);   //object

console.log(typeof o2);   //object

console.log(typeof o3);   //object

console.log(typeof  f1);   //function

console.log(typeof  f2);   //function

console.log(typeof  f3);   //function

2.2对象继承

Brendan
Eich参考C++和Java,做了简化设计,将new命令引入JavaScript中,new后面跟对象的构造函数,用来创建对象。这样做有个缺点:无法共享方法和属性。

比如,在DOG对象的构造函数中,设置一个实例对象的共有属性species。

function DOG(name){

this.name = name;

this.species = ‘犬科’;

}

然后,生成两个实例对象:

var dogA = new DOG(‘大毛’);

var dogB = new DOG(‘二毛’);

这两个对象的species属性是独立的,修改其中一个,不会影响到另一个。

dogA.species = ‘猫科’;

alert(dogB.species); // 显示”犬科”,不受dogA的影响

每一个实例对象,都有自己的属性和方法的副本。这不仅无法做到数据共享,也是极大的资源浪费。

Brendan
Eich决定为构造函数设置一个prototype属性。这个属性包含一个对象,所有实例对象需要共享的属性和方法,都放在这个对象里面;那些不需要共享的属性和方法,就放在构造函数里面。实例对象一旦创建,将自动引用prototype对象的属性和方法。也就是说,实例对象的属性和方法,分成两种,一种是本地的,另一种是引用的。

function DOG(name){

this.name = name;

}

DOG.prototype = { species : ‘犬科’ };

var dogA = new DOG(‘大毛’);

mgm娱乐场,var dogB = new DOG(‘二毛’);

alert(dogA.species); // 犬科

alert(dogB.species); // 犬科

species属性放在prototype对象里,是两个实例对象共享的。只要修改了prototype对象,就会同时影响到两个实例对象。

DOG.prototype.species = ‘猫科’;

alert(dogA.species); // 猫科

alert(dogB.species); // 猫科

由于所有的实例对象共享同一个prototype对象,那么从外界看起来,prototype对象就好像是实例对象的原型,而实例对象则好像”继承”了prototype对象一样。

2.3原型prototype

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

示例:

function  f1(){};

console.log(f1. prototype) //f1 {}

console.log(typeof  f1. prototype) //object

console.log(typeof  Function. prototype) // function

console.log(typeof  Object. prototype) // object

console.log(typeof  Function. prototype. prototype) //undefined

2.4 原型链

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

var person = function(name){

this.name = name

};

person.prototype.getName = function(){

return this.name;

}

var zjh = new person(‘zhangjiahao’);

zjh.getName(); //zhangjiahao

以上面的例子为例:

console.log(zjh.__proto__ === person.prototype) //true

同样,person.prototype对象也有__proto__属性,它指向创建它的函数对象(Object)的prototype

console.log(person.prototype.__proto__ === Object.prototype)
//true

继续,Object.prototype对象也有__proto__属性,但它比较特殊,为null

console.log(Object.prototype.__proto__) //null

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

2.5 constructor属性

prototype对象有一个constructor属性,默认指向prototype对象所在的构造函数。

相关文章