耽美漫画

JS的原型、原型链一直是比较难理解的内容,不少初学者甚至有一定经验的老鸟都不一定能完全说清楚,更多的”很可能”是一知半解,而这部分内容又是JS的核心内容,想要技术进阶的话肯定不能对这个概念一知半解,碰到问题靠“猜”,却不理解它的规则!

prototype
只有函数有prototype属性
let a
=

{}

let b
=

function

()

{

}

console
.
log
(
a
.
prototype
)

// undefined

console
.
log
(
b
.
prototype
)

// { constructor: function(){…} }

Object.prototype怎么解释?
其实 Object是一个全局对象,也是一个构造函数,以及其他基本类型的全局对象也都是构造函数:

function
outTypeName
(
data
,
type
)

{

let typeName
=

Object
.
prototype
.
toString
.
call
(
data
)

console
.
log
(
typeName
)

}

outTypeName
(
Object
)

//[object Function]

outTypeName
(
String
)

// [object Function]

outTypeName
(
Number
)

// [object Function]

为什么只有函数有prototype属性
JS通过 new来生成对象,但是仅靠构造函数,每次生成的对象都不一样。

有时候需要在两个对象之间共享属性,由于JS在设计之初没有类的概念,所以JS使用函数的 prototype来处理这部分需要被共享的属性,通过函数的 prototype来模拟类:

当创建一个函数时,JS会自动为函数添加 prototype属性,值是一个有 constructor的对象。

以下是共享属性 prototype的栗子:

function

People
(
name
)

{

this
.
name
=
name

}

People
.
prototype
.
age
=

23

// 岁数

// 创建两个实例

let
People1

=

new

People
(
‘OBKoro1’
)

let
People2

=

new

People
(
‘扣肉’
)

People
.
prototype
.
age
=

24

// 长大了一岁

console
.
log
(
People1
.
age
,

People2
.
age
)

// 24 24

为什么 People1和 People2可以访问到 People.prototype.age?

原因是:People1和 People2的原型是 People.prototype,答案在下方的:构造函数是什么以及它做了什么。

原型链
__proto__和 Object.getPrototypeOf(target):对象的原型
__proto__是对象实例和它的构造函数之间建立的链接,它的值是:构造函数的`prototype。

也就是说:__proto__的值是它所对应的原型对象,是某个函数的 prototype

Object.getPrototypeOf(target)全等于 __proto__。

它是ES6的标准,兼容IE9,主流浏览器也都支持,MDN,本文将以 Object.getPrototypeOf(target)指代 __proto__。

不要再使用 __proto__:
本段摘自阮一峰-ES6入门,具体解析请点击链接查看

1. __proto__属性没有写入 ES6 的正文,而是写入了附录。

2. 原因是它本质上是一个内部属性,而不是一个正式的对外的 API,只是由于浏览器广泛支持,才被加入了 ES6。

3. 标准明确规定,只有浏览器必须部署这个属性,其他运行环境不一定需要部署,而且新的代码最好认为这个属性是不存在的。

4. 所以无论从语义的角度,还是从兼容性的角度,都不要使用这个属性,应该使用:Object.getPrototypeOf(target)(读操作)、 Object.setPrototypeOf(target)(写操作)、 Object.create(target)(生成操作)代替

构造函数是什么、它做了什么
出自《你不知道的在js》:在js中, 实际上并不存在所谓的’构造函数’,只有对于函数的’构造调用’。

上文一直提到构造函数,所谓的构造函数,实际上就是通过关键字 new来调用的函数:

let newObj
=

new
someFn
()

// 构造调用函数

构造/new调用函数的时候做了什么:

创建一个全新的对象。

这个新对象的原型( Object.getPrototypeOf(target))指向构造函数的 prototype对象。

该函数的this会绑定在新创建的对象上。

如果函数没有返回其他对象,那么new表达式中的函数调用会自动返回这个新对象。

我们称这个新对象为构造函数的实例。

原型继承就是利用构造调用函数的特性:

SubType
.
prototype
=

new

SuperType
();

// 原型继承:SubType继承SuperType

// 挂载SuperType的this和prototype的属性和方法到SubType.prototype上

构造调用的第二点:将新对象的 Object.getPrototypeOf(target)指向函数的 prototype

构造调用的第三点:该函数的this会绑定在新创建的对象上。

新对象赋值给 SubType.prototype

原型类型还有缺点:多个实例对引用类型的操作会被篡改,这里就不扩展了。

原型链是什么
来看个例子:

function
foo
()

{

}

const
newObj
=

new
foo
()

// 构造调用foo 返回一个新对象

const
newObj__proto__
=

Object
.
getPrototypeOf
(
newObj
)

// 获取newObj的原型对象

newObj__proto__
===
foo
.
prototype
// true 验证newObj的原型指向foo

const
foo__proto__
=

Object
.
getPrototypeOf
(
foo
.
prototype
)

// 获取foo.prototype的原型

foo__proto__
===

Object
.
prototype
// true foo.prototype的原型是Object.prototype

如果用以前的语法,从 newObj查找 foo的原型,是这样的:

newObj
.
__proto__
.
__proto__
// 这种关系就是原型链

可以用以下三句话来理解原型链:

每个对象都拥有一个原型对象: newObj的原型是 foo.prototype。

对象的原型可能也是继承其他原型对象的: foo.prototype也有它的原型 Object.prototype。

一层一层的,以此类推,这种关系就是原型链。

一个对象是否在另一个对象的原型链上
如果一个对象存在另一个对象的原型链上,我们可以说:它们是继承关系。

判断方式有两种,但都是根据构造函数的 prototype是否在原型链上来判断的:

1. instanceof: 用于测试构造函数的prototype属性是否出现在对象的原型链中的任何位置

语法:objectinstanceofconstructor

let test
=

function

()

{

}

let testObject
=

new
test
();

testObject
instanceof
test
// true test.prototype在testObject的原型链上

testObject
instanceof

Function

// false Function.prototype 不在testObject的原型链上

testObject
instanceof

Object

// true Object.prototype在testObject的原型链上

2. isPrototypeOf:测试一个对象是否存在于另一个对象的原型链上

语法:prototypeObj.isPrototypeOf(object)

let test
=

function

()

{

}

let testObject
=

new
test
();

test
.
prototype
.
isPrototypeOf
(
testObject
)

// true test.prototype在testObject的原型链上

Object
.
prototype
.
isPrototypeOf
(
testObject
)

// true Object.prototype在testObject的原型链上

原型链的终点: Object.prototype
Object.prototype是原型链的终点,所有对象都是从它继承了方法和属性。

Object.prototype没有原型对象:

const
proto
=

Object
.
getPrototypeOf
(
Object
.
prototype
)

// null

下面是两个验证例子,有疑虑的同学多写几个测试用例印证一下。

字符串原型链的终点:Object.prototype

let test
=

‘由String函数构造出来的’

let stringPrototype
=

Object
.
getPrototypeOf
(
test
)

// 字符串的原型

stringPrototype
===

String
.
prototype
// true 字符串的原型是String对象

Object
.
getPrototypeOf
(
stringPrototype
)

===

Object
.
prototype
// true String对象的原型是Object对象

函数原型链的终点: Object.prototype

let test
=

function

()

{

}

let fnPrototype
=

Object
.
getPrototypeOf
(
test
)

stringPrototype
===

Function
.
prototype
// true test的原型是Function.prototype

Object
.
getPrototypeOf
(
Function
.
prototype
)

===

Object
.
prototype
// true

原型链用来做什么?
属性查找:
如果试图访问对象(实例instance)的某个属性,会首先在对象内部寻找该属性,直至找不到,然后才在该对象的原型(instance.prototype)里去找这个属性,以此类推

我们用一个例子来形象说明一下:

let test
=

‘由String函数构造出来的’

let stringPrototype
=

Object
.
getPrototypeOf
(
test
)

// 字符串的原型

stringPrototype
===

String
.
prototype
// true 字符串的原型是String对象

Object
.
getPrototypeOf
(
stringPrototype
)

===

Object
.
prototype
// true String对象的原型是Object对象

当你访问 test的某个属性时,浏览器会进行以下查找:

浏览器首先查找 test 本身

接着查找它的原型对象: String.prototype

最后查找 String.prototype的原型对象: Object.prototype

一旦在原型链上找到该属性,就会立即返回该属性,停止查找。

原型链上的原型都没有找到的话,返回 undefiend

这种查找机制还解释了字符串为何会有自带的方法: slice/ split/ indexOf等。

准确的说:

这些属性和方法是定义在 String这个全局对象/函数上的。

字符串的原型指向了 String函数的 prototype。

之后通过查找原型链,在String函数的 prototype中找到这些属性和方法。

拒绝查找原型链:
hasOwnProperty: 指示对象自身属性中是否具有指定的属性

语法:obj.hasOwnProperty(prop)

参数: prop 要查找的属性

返回值: 用来判断某个对象是否含有指定的属性的 Boolean。

let test
={

‘OBKoro1’
:

‘扣肉’

}

test
.
hasOwnProperty
(
‘OBKoro1’
);

// true

test
.
hasOwnProperty
(
‘toString’
);

// false test本身没查找到toString

这个 API是挂载在 object.prototype上,所有对象都可以使用,API会忽略掉那些从原型链上继承到的属性。

扩展:
实例的属性
你知道构造函数的实例对象上有哪些属性吗?这些属性分别挂载在哪个地方?原因是什么?

function
foo
()

{

this
.
some
=

‘222’

let ccc
=

‘ccc’

foo
.
obkoro1
=

‘obkoro1’

foo
.
prototype
.
a
=

‘aaa’

}

foo
.
koro
=

‘扣肉’

foo
.
prototype
.
test
=

‘test’

let foo1
=

new
foo
()

// `foo1`上有哪些属性,这些属性分别挂载在哪个地方

foo
.
prototype
.
test
=

‘test2’

// 重新赋值

上面这道是考察 JS基础的题,很多人都没说对,原因是没有彻底掌握 this、 原型链、 函数。

想一下再看解析:
想一下再看解析:
想一下再看解析:
想一下再看解析:
想一下再看解析:
1. this.some: foo1对象的属性

通过构造调用 foo的 this指向 foo1,所以 this.some挂载在 foo1对象下。

属性查找: foo1.some

foo1.some直接读取 foo1的属性。

2. foo1.test、 foo1.a: foo1对象的原型

根据上文提到的:构造/new调用函数的时候会创建一个新对象( foo1),自动将 foo1的原型( Object.getPrototypeOf(foo1))指向构造函数的prototype对象。

构造调用会执行函数,所以 foo.prototype.a=’aaaaa’也会执行,单就赋值这个层面来说写在 foo外面和写在 foo里面是一样的。

属性查找:foo1.test、 foo1.a

foo1本身没有找到,继续查找

foo1的原型 Object.getPrototypeOf(foo1)上找到了 a和 test,返回它们,停止查找。

3. foo1.obkoro1和 foo1.koro:返回undefined

静态属性: foo.obkoro1、 foo.koro
函数在JS中是一等公民,它也是一个对象, 用来模拟类。

这两个属性跟 foo1没有关系,它是对象 foo上的两个属性(类似函数的: arguments/ prototype/ length等属性),称为静态属性。

它们只能通过 foo.obkoro1和 foo.koro来访问。

原型对象改变,原型链下游获取的值也会改变
上面那个例子中的 foo1.test的值是什么?

foo
.
prototype
.
test
=

‘test’

let foo1
=

new
foo
()

// `foo1`上有哪些属性,这些属性分别挂载在哪个地方

foo
.
prototype
.
test
=

‘test2’

// 重新赋值

foo1.test的值是 test2,原因是:foo1的原型对象是 Object.getPrototypeOf(foo1)存的指针,指向 foo.prototype的内存地址,不是拷贝,每次读取的值都是当前 foo.prototype的最新值。

打印 foo1:

小结
写了好几天,之前网上很多图文博客,那些线指来指去,就我个人看来还是比较难以理解的,所以本文纯文字的形式来描述这些概念,相信认真看完的同学肯定都有所收获,如果没看懂的话,建议多看几遍,这部分概念真的很重要!

前端高级进阶小技巧知识推荐:

编程是什么意思
jq获取同级元素
javascript怎么读
px单位
和怎么读
css超出隐藏显示省略号
jq同级元素
是什么意思
边框虚线
什么叫编程
是怎么读
html三角形
与怎么读
怎样去除图片上的文字
js添加class
css超出隐藏
css实现垂直水平居中
ps去除图片文字
ps去除文字
html下拉框样式
前端ps切图
图片去除文字
jq获取父级元素
去除图片上的文字
jquery获取同级元素
小程序获取页面高度
搜索排名提升
section和div的区别
小程序名称查询
小程序获取元素高度
怎么去除图片上的文字
jq懒加载
jq查找父元素
css超出省略
html下拉
jq获取父元素
ps消除文字
css超出省略号显示
ps怎么去除图片上的文字
css超出显示省略号
ps去除复杂图片文字
ps去掉图片上的字
什么是编程
图片去文字
css超出省略号
ps如何去除图片上的文字
懒加载插件
js动态添加class
获取父级元素
获取div的值
css超出部分隐藏
jq子元素
alert样式
ps如何去除图片文字
jq查找子元素
前端是什么意思
获取div的宽度
ps去掉图片上的文字
分辨率单位
js获取div的宽度
jq获取div高度
cssborder
jq获取子元素
js什么意思
js获取当前页面的url
封装是什么意思
js增加class
js跳转页面方法