深入聊一聊JS中new的原理与实现

kangel2

目录

; Q/ O, ]7 J8 f1 z3 ^& i1 g1 F

• 定义
  $ J% n( F3 ^. C  s' k
• 构造函数体不同
  
  
  
  • 无返回值
    ! h3 i2 a( m6 g& o; N2 M/ n
  • 返回对象
      Y5 ^. a8 q8 M* Q4 A# c
  • 返回非对象
    
  • 没有属性绑定+返回非对象
    $ I* e& r& [0 ~5 \6 U
  
  . u( ?7 y0 j: g! o5 K1 }2 X
• 构造函数类型不同
  , W4 @" \7 W  [6 s
  
  
  • 构造函数为普通函数
    
  • 构造函数为箭头函数
    
  
  + {& M9 S+ T' D+ ]$ z1 l. l- g
• 手写new
  # y: W! E6 Y( ~- T4 y4 `# P3 n: g% B
• 总结
  

5 b" j. a: J/ m+ B定义
6 G) |* W) S9 X
; V- I: [% c( X- n, A2 G/ ^& [' v: Dnew 运算符创建一个用户定义的对象类型的实例或具有构造函数的内置对象的实例。
2 u; Y! o+ [% k, L- r0 Y, z使用new [constructor]的方式来创建一个对象实例，但构造函数的差异会导致创建的实例不同。

/ I& M) |! v4 V; c/ X+ E构造函数体不同
& a# L' G! H. I/ {  n

0 ~0 \- Q) T5 T( z构造函数也是函数，其唯一的区别就是调用方式不同，任何函数只要使用 new 操作符调用就是构造函数，而不使用 new 操作符调用的函数就是普通函数。
; W0 `  a! `' Y  J因此构造函数也可以带有返回值，但是这会导致new的结果不同。

) Q9 y4 s$ f3 r! i无返回值
8 ?+ N; j+ ~; o4 `" l
; p" D5 ^1 T2 O+ P' w( {6 o

1. function Person(name) {  this.name = name;}let obj = new Person("Jalenl");console.log(obj);

复制代码

显然，打印的是{name:'Jalenl'}
' `! [4 H3 i% n8 Q6 G! i9 S
返回对象

6 O" ?- l- v5 K6 B0 }$ H

1. function Person(age) {  this.age = age;  return { name: "Jalenl" };}let obj = new Person(18);console.log(obj);

复制代码

打印的是{name:'Jalenl'}，也就是说return之前的定义都被覆盖了。这里return的是一个对象，那返回的是个基本类型呢？
5 n; L& ^: j. ^, O. ?) g
返回非对象

1. function Person(age) {  this.age = age;  return 1;}let obj = new Person(18);console.log(obj);

复制代码

返回{age:21},这么说return失效了，跟没有return一样的结果，那如果没有this绑定内部属性，再返回基本数据类型呢？
3 A; c5 ]# ^2 s- V
2 ?& r( h8 J" h6 O1 f$ O没有属性绑定+返回非对象
0 S3 Q9 l- Z% S% u/ {' [- ^2 G( q

1. function Person(){    return 1}new Person()

复制代码

返回的是一个空对象{}，意料之中。
综上，只有构造函数return返回的是一个对象类型时，才能改变初始结果。
& ?& L; t  T5 t; D  y# r' }* Y
构造函数类型不同

% l6 h# }9 ^, z" E/ C& Z
; c' u. M2 B) }* A" b( n
构造函数为普通函数


ECMA-262 3rd. Edition Specification中的说明了对象实例的创建过程：

13.2.2 [[Construct]]
When the [[Construct]] property for a Function object F is called, the following steps are taken:
- |8 f% q) p# ^% S

   
' I9 |: |" C& d$ ~
• Create a new native ECMAScript object.   
  
• Set the [[Class]] property of Result(1) to "Object".   
  : P9 N( h# X' z0 S
• Get the value of the prototype property of F.   
  
• If Result(3) is an object, set the [[Prototype]] property of Result(1) to Result(3).   
  ! N6 p9 \( N% X  ?4 ]
• If Result(3) is not an object, set the [[Prototype]] property of Result(1) to the original Object prototype object as described in 15.2.3.1.   
  6 H+ ?1 I# [9 Y7 U9 p# p# |: V: {
• Invoke the [[Call]] property of F, providing Result(1) as the this value and providing the argument list passed into [[Construct]] as the argument values.   
  ( b; e1 x3 i6 w9 y
• If Type(Result(6)) is Object then return Result(6).   
  + t9 o# f8 m! t+ z, e
• Return Result(1).
  6 p' {) V, |; B& V' V( m# V8 @

总结下来就是：

   
7 x5 R+ x( A9 S/ P! Y) N# \, x
• 在内存中创建一个新对象。   
  4 S/ b$ ~( O2 Y6 ~" C! G" P
• 这个新对象内部的[[Prototype]]特性被赋值为构造函数的 prototype 属性。   
  
• 构造函数内部的 this 被赋值为这个新对象（即 this 指向新对象）。   
  % p3 o4 J- x1 l/ A. T' c' M7 B2 b
• 执行构造函数内部的代码（给新对象添加属性）。   
  + }# p6 W6 f' F$ b
• 如果构造函数返回对象，则返回该对象；否则，返回刚创建的新对象(空对象)。
  5 `$ W, `# _: s

第五步就已经说明了构造函数不同导致new结果不同的原因。
1 y! z$ s* R. c; \5 w以下摘自MDN的解释：
  x. `; o& j- M9 i: t' t) V

当代码 new Foo(…) 执行时，会发生以下事情：
- y! W3 k$ P& @

   
* D) Y, ^5 m/ v, C
• 一个继承自 Foo.prototype 的新对象被创建。   
  $ H% }+ B/ H) b, a" d
• 使用指定的参数调用构造函数 Foo，并将 this 绑定到新创建的对象。new Foo 等同于 new Foo()，也就是没有指定参数列表，Foo 不带任何参数调用的情况。   
  , _& U; p: P  J
• 由构造函数返回的对象就是 new 表达式的结果。如果构造函数没有显式返回一个对象，则使用步骤1创建的对象。（一般情况下，构造函数不返回值，但是用户可以选择主动返回对象，来覆盖正常的对象创建步骤）
  ( S! z  G  l4 v6 F( _& R' b$ g

构造函数为箭头函数
  l) ^; k$ y- W: R0 ^( k6 @

" R5 }# e9 X# U  h2 f9 f: ^普通函数创建时，引擎会按照特定的规则为这个函数创建一个prototype属性（指向原型对象）。默认情况下，所有原型对象自动获得一个名为 constructor 的属性，指回与之关联的构造函数。

1. function Person(){    this.age = 18;}Person.prototype/**{    constructor: ƒ Foo()    __proto__: Object}**/

复制代码

创建箭头函数时，引擎不会为其创建prototype属性，箭头函数没有constructor供new调用，因此使用new调用箭头函数会报错！

1. const Person = ()=>{}new Person()//TypeError: Foo is not a constructor

复制代码

手写new
+ E0 J) H  g+ G' x$ f; p1 T
% T  G( c0 V6 O% A
5 `8 U7 i  d% x综上，熟悉了new的工作原理后，我们可以自己实现一个低配版的new，实现的关键是：

   

• 让实例可以访问到私有属性；   
  
• 让实例可以访问构造函数原型（constructor.prototype）所在原型链上的属性；   
  
• 构造函数返回的最后结果是引用数据类型。
  

1. function _new(constructor, ...args) {    // 构造函数类型合法判断    if(typeof constructor !== 'function') {      throw new Error('constructor must be a function');    }    // 新建空对象实例    let obj = new Object();    // 将构造函数的原型绑定到新创的对象实例上    obj.__proto__ = Object.create(constructor.prototype);    // 调用构造函数并判断返回值    let res = constructor.apply(obj,  args);    let isObject = typeof res === 'object' && res !== null;    let isFunction = typeof res === 'function';    // 如果有返回值且返回值是对象类型，那么就将它作为返回值，否则就返回之前新建的对象    return isObject || isFunction ? res : obj;};

复制代码

这个低配版new实现可以用来创建自定义类的实例，但不支持内置对象，毕竟new属于操作符，底层实现更加复杂。
0 o6 X1 M. T2 q
总结
2 ]# n. m3 w" T, M% Z% v; `
  v) l; y7 r8 |- x8 b到此这篇关于JS中new的原理与实现的文章就介绍到这了,更多相关JS中new原理与实现内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
9 ]$ e0 f" s1 M2 u' M
$ u) {8 G( h4 y3 Z; Q2 J! \来源：http://www.jb51.net/article/227135.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！