您的位置:时时app平台注册网站 > web前端 > JS 的 new 到底是怎么的?

JS 的 new 到底是怎么的?

2019-09-12 22:40

JS 的 new 到底是干什么的?

2017/04/10 · JavaScript · 4 评论 · new

原文出处: 方应杭   

大部分讲 new 的文章会从面向对象的思路讲起,但是我始终认为,在解释一个事物的时候,不应该引入另一个更复杂的事物。

今天我从「省代码」的角度来讲 new。

—————————

想象我们在制作一个策略类战争游戏,玩家可以操作一堆士兵攻击敌方。

我们着重来研究一下这个游戏里面的「制造士兵」环节。

一个士兵的在计算机里就是一堆属性,如下图:

图片 1

我们只需要这样就可以制造一个士兵:

JavaScript

var 士兵 = { ID: 1, // 用于区分每个士兵 兵种:"美国大兵", 攻击力:5, 生命值:42, 行走:function(){ /*走俩步的代码*/}, 奔跑:function(){ /*狂奔的代码*/ }, 死亡:function(){ /*Go die*/ }, 攻击:function(){ /*糊他熊脸*/ }, 防御:function(){ /*护脸*/ } } 兵营.制造(士兵)

1
2
3
4
5
6
7
8
9
10
11
12
13
var 士兵 = {
  ID: 1, // 用于区分每个士兵
  兵种:"美国大兵",
  攻击力:5,
  生命值:42,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}
 
兵营.制造(士兵)

函数调用

JS里面有三种函数调用形式:

func;obj.child.method;func.call(context, p1, p2); // 先不讲 apply

一般,初学者都知道前两种形式,而且认为前两种形式「优于」第三种形式。我们方方老师大姥说了,你一定要记住,第三种调用形式,才是正常调用形式:

func.call(context, p1, p2);

其他两种都是语法糖,可以等价地变为 call 形式:

func等价于 func.call(undefined, p1, p2);

obj.child.method 等价于 obj.child.method.call(obj.child, p1, p2);

至此我们的函数调用只有一种形式:

func.call(context, p1, p2);

这样,this 就好解释了this 就是上面 context。

this 是你 call 一个函数时传的 context,由于你从来不用 call 形式的函数调用,所以你一直不知道。

先看 func 中的 this 如何确定:

当你写下面代码时;function func() { console.log;}func();等价于;function func() { console.log;}func.call(undefined); // 可以简写为 func.call()

按理说打印出来的 this 应该就是 undefined 了吧,但是浏览器里有一条规则:

如果你传的 context 就 null 或者 undefined,那么 window 对象就是默认的 context(严格模式下默认 context 是 undefined)

因此上面的打印结果是 window。如果你希望这里的 this 不是 window,很简单:

func.call; // 那么里面的 this 就是 obj 对象了

var obj = { foo: function() { console.log; }};var bar = obj.foo;obj.foo(); // 转换为 obj.foo.call,this 就是 objbar();// 转换为 bar.call()// 由于没有传 context// 所以 this 就是 undefined// 最后浏览器给你一个默认的 this —— window 对象

例子:

质疑

上面的代码存在一个问题:浪费了很多内存。

  1. 行走、奔跑、死亡、攻击、防御这五个动作对于每个士兵其实是一样的,只需要各自引用同一个函数就可以了,没必要重复创建 100 个行走、100个奔跑……
  2. 这些士兵的兵种和攻击力都是一样的,没必要创建 100 次。
  3. 只有 ID 和生命值需要创建 100 次,因为每个士兵有自己的 ID 和生命值。

复制代码 代码如下:

注意 constructor 属性

new 操作为了记录「临时对象是由哪个函数创建的」,所以预先给「士兵.prototype」加了一个 constructor 属性:

JavaScript

士兵.prototype = { constructor: 士兵 }

1
2
3
士兵.prototype = {
  constructor: 士兵
}

如果你重新对「士兵.prototype」赋值,那么这个 constructor 属性就没了,所以你应该这么写:

JavaScript

士兵.prototype.兵种 = "美国大兵" 士兵.prototype.攻击力 = 5 士兵.prototype.行走 = function(){ /*走俩步的代码*/} 士兵.prototype.奔跑 = function(){ /*狂奔的代码*/ } 士兵.prototype.死亡 = function(){ /*Go die*/ } 士兵.prototype.攻击 = function(){ /*糊他熊脸*/ } 士兵.prototype.防御 = function(){ /*护脸*/ }

1
2
3
4
5
6
7
士兵.prototype.兵种 = "美国大兵"
士兵.prototype.攻击力 = 5
士兵.prototype.行走 = function(){ /*走俩步的代码*/}
士兵.prototype.奔跑 = function(){ /*狂奔的代码*/  }
士兵.prototype.死亡 = function(){ /*Go die*/    }
士兵.prototype.攻击 = function(){ /*糊他熊脸*/   }
士兵.prototype.防御 = function(){ /*护脸*/       }

或者你也可以自己给 constructor 重新赋值:

JavaScript

士兵.prototype = { constructor: 士兵, 兵种:"美国大兵", 攻击力:5, 行走:function(){ /*走俩步的代码*/}, 奔跑:function(){ /*狂奔的代码*/ }, 死亡:function(){ /*Go die*/ }, 攻击:function(){ /*糊他熊脸*/ }, 防御:function(){ /*护脸*/ } }

1
2
3
4
5
6
7
8
9
10
士兵.prototype = {
  constructor: 士兵,
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

完。

2 赞 6 收藏 4 评论

图片 2

差异化

如果我们想让 obj.toString 和 obj2.toString 的行为不同怎么做呢?直接赋值就好了:

obj.toString = function() { return "新的 toString 方法";};

图片 3

  • [读]属性时会沿着原型链搜索

  • [新增]属性时不会去看原型链

复制代码 代码如下:

优雅?

有人指出创建一个士兵的代码分散在两个地方很不优雅,于是我们用一个函数把这两部分联系起来:

JavaScript

function 士兵(ID){ var 临时对象 = {} 临时对象.__proto__ = 士兵.原型 临时对象.ID = ID 临时对象.生命值 = 42 return 临时对象 } 士兵.原型 = { 兵种:"美国大兵", 攻击力:5, 行走:function(){ /*走俩步的代码*/}, 奔跑:function(){ /*狂奔的代码*/ }, 死亡:function(){ /*Go die*/ }, 攻击:function(){ /*糊他熊脸*/ }, 防御:function(){ /*护脸*/ } } // 保存为文件:士兵.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
function 士兵(ID){
  var 临时对象 = {}
 
  临时对象.__proto__ = 士兵.原型
 
  临时对象.ID = ID
  临时对象.生命值 = 42
  
  return 临时对象
}
 
士兵.原型 = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}
 
// 保存为文件:士兵.js

然后就可以愉快地引用「士兵」来创建士兵了:

JavaScript

var 士兵们 = [] for(var i=0; i<100; i ){ 士兵们.push(士兵(i)) } 兵营.批量制造(士兵们)

1
2
3
4
5
6
var 士兵们 = []
for(var i=0; i<100; i ){
  士兵们.push(士兵(i))
}
 
兵营.批量制造(士兵们)

在理解继承之前,需要知道 js 的三个东西:

此外原型继承没有提供调用父类的方法
然而我们基于原型继承,通过静态变量记录父类来弥补这一缺陷

改进

看过我们的专栏以前文章(JS 原型链)的同学肯定知道,用原型链可以解决重复创建的问题:我们先创建一个「士兵原型」,然后让「士兵」的 __proto__ 指向「士兵原型」

JavaScript

var 士兵原型 = { 兵种:"美国大兵", 攻击力:5, 行走:function(){ /*走俩步的代码*/}, 奔跑:function(){ /*狂奔的代码*/ }, 死亡:function(){ /*Go die*/ }, 攻击:function(){ /*糊他熊脸*/ }, 防御:function(){ /*护脸*/ } } var 士兵们 = [] var 士兵 for(var i=0; i<100; i ){ 士兵 = { ID: i, // ID 不能重复 生命值:42 } /*实际工作中不要这样写,因为 __proto__ 不是标准属性*/ 士兵.__proto__ = 士兵原型 士兵们.push(士兵) } 兵营.批量制造(士兵们)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
var 士兵原型 = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}
var 士兵们 = []
var 士兵
for(var i=0; i<100; i ){
  士兵 = {
    ID: i, // ID 不能重复
    生命值:42
  }
 
  /*实际工作中不要这样写,因为 __proto__ 不是标准属性*/
  士兵.__proto__ = 士兵原型
 
  士兵们.push(士兵)
}
 
兵营.批量制造(士兵们)

2. this 的值到底是什么

你可能遇到过这样的 JS 面试题:

var obj = { foo: function() { console.log; }};var bar = obj.foo;obj.foo(); // 打印出的 this 是 objbar(); // 打印出的 this 是 window

请解释最后两行函数的值为什么不一样。

复制代码 代码如下:

JS 之父的关怀

JS 之父创建了 new 关键字,可以让我们少写几行代码:

图片 4

只要你在士兵前面使用 new 关键字,那么可以少做四件事情:

  1. 不用创建临时对象,因为 new 会帮你做(你使用「this」就可以访问到临时对象);
  2. 不用绑定原型,因为 new 会帮你做(new 为了知道原型在哪,所以指定原型的名字为 prototype);
  3. 不用 return 临时对象,因为 new 会帮你做;
  4. 不要给原型想名字了,因为 new 指定名字为 prototype。

2)借助原型链实现继承

/** * 借助原型链实现继承 */function Parent2() { this.name = "parent2"; this.play = [1, 2, 3];}function Child2() { this.type = "child2";}Child2.prototype = new Parent2();console.log(new Child2;var s1 = new Child2();var s2 = new Child2();

图片 5

通过一讲的,我们知道要共享莫些属性,需要 对象.proto= 父亲对象的.prototype,但实际上我们是不能直接 操作proto,这时我们可以借用 new 来做,所以Child2.prototype = new Parent2(); <=> Child2.prototype.proto= Parent2.prototype; 这样我们借助 new 这个语法糖,就可以实现原型链继承。但这里有个总是,如打印结果,我们给 s1.play 新增一个值 ,s2 也跟着改了。所以这个是原型链继承的缺点,原因是 s1.pro和 s2.pro指向同一个地址即 父类的 prototype。

var Class={
create:function()
{
var _class=function()
{
this.init.apply(this,arguments);
}
_class.prototype.init=Function.prototype.init;
try{
return _class;
}finally{
_class=null;
}
}
};
//默认构造函数
Function.prototype.init=function(){}
//方法扩展
Function.prototype.extend=function(list)
{
for(var i in list)this.prototype[i]=list[i];
return this;
}
//多级继承
Function.prototype.inherits=function(parent)
{
//继承的深度级别
var _depth=0;
//方法属性移植
this.extend(new parent());
//初始化构造函数 类的继承通常不继承构造函数
this.prototype.init=Function.prototype.init;
//类的静态父类
this.parent=parent;
//执行父类函数
this.prototype.parent=function(name)
{
//若没有参数则执行构造函数
if(!name)name='init';
//即将执行的父类
var _parent=parent;
//若当前已经在父类中执行则继续向上寻找超类
if(_depth)
{
for(var i=0;i<_depth;i )
{
_parent=_parent.parent;
}
}
//设置好级别
_depth ;
try{
//执行函数并返回值
return _parent.prototype[name].apply(this,Array.prototype.slice.apply(arguments,[1]));
}catch(e){
throw(e);
}finally{
//恢复级别
_depth--;
}
}
return this;
}

制造一百个士兵

如果需要制造 100 个士兵怎么办呢?

循环 100 次吧:

JavaScript

var 士兵们 = [] var 士兵 for(var i=0; i<100; i ){ 士兵 = { ID: i, // ID 不能重复 兵种:"美国大兵", 攻击力:5, 生命值:42, 行走:function(){ /*走俩步的代码*/}, 奔跑:function(){ /*狂奔的代码*/ }, 死亡:function(){ /*Go die*/ }, 攻击:function(){ /*糊他熊脸*/ }, 防御:function(){ /*护脸*/ } } 士兵们.push(士兵) } 兵营.批量制造(士兵们)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var 士兵们 = []
var 士兵
for(var i=0; i<100; i ){
  士兵 = {
    ID: i, // ID 不能重复
    兵种:"美国大兵",
    攻击力:5,
    生命值:42,
    行走:function(){ /*走俩步的代码*/},
    奔跑:function(){ /*狂奔的代码*/  },
    死亡:function(){ /*Go die*/    },
    攻击:function(){ /*糊他熊脸*/   },
    防御:function(){ /*护脸*/       }
  }
  士兵们.push(士兵)
}
 
兵营.批量制造(士兵们)

哎呀好简单。

3)组合方式实现继承

/** * 组合方式 */function Parent3() { this.name = "parent3"; this.play = [1, 2, 3];}Parent3.prototype.say = function() {};function Child3() { Parent3.call; this.type = "child3";}Child3.prototype = new Parent3();var s3 = new Child3();var s4 = new Child3();s3.play.push;console.log(new Child3;console.log(s3.play, s4.play);

图片 6

将 1 和 2 两种方式组合起来,就可以解决 1 和 2 存在问题,这种方式为组合继承。这种方式有点缺点就是我实例一个对象的时, 父类 new 了两次,一次是 var s3 = new Child3()对应 Child3.prototype = new Parent3()还要 new 一次。

/*申明2个构造器*/
var flower=function(){
this.name="nokia";
}
var flower2=function(){
this.age=22;
}
/*原型链*/
flower2.prototype=new flower();
/*根据刚才原型的定义,实例obj必然复制自new flower();*/
obj=new flowe2();
/*从父类继承的属性*/
alert(obj.name); //==>"nokia"
alert(obj.age); //==>22

这一次我们用 new 来写

JavaScript

function 士兵(ID){ this.ID = ID this.生命值 = 42 } 士兵.prototype = { 兵种:"美国大兵", 攻击力:5, 行走:function(){ /*走俩步的代码*/}, 奔跑:function(){ /*狂奔的代码*/ }, 死亡:function(){ /*Go die*/ }, 攻击:function(){ /*糊他熊脸*/ }, 防御:function(){ /*护脸*/ } } // 保存为文件:士兵.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function 士兵(ID){
  this.ID = ID
  this.生命值 = 42
}
 
士兵.prototype = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}
 
// 保存为文件:士兵.js

然后是创建士兵(加了一个 new 关键字):

JavaScript

var 士兵们 = [] for(var i=0; i<100; i ){ 士兵们.push(new 士兵(i)) } 兵营.批量制造(士兵们)

1
2
3
4
5
6
var 士兵们 = []
for(var i=0; i<100; i ){
  士兵们.push(new 士兵(i))
}
 
兵营.批量制造(士兵们)

new 的作用,就是省那么几行代码。(也就是所谓的语法糖)

Fundebug经授权转载,版权归原作者所有。

复制代码 代码如下:

摘要:理解 JS 继承。

function flower(){}
function flower2(){}
flower2.prototype=new flower();
var obj1=new flower();
var obj2=new flower2();
/*问题出现了,2个实例的constructor属性都指向flower*/
alert(obj1.constructor==obj2.constructor);
/*obj1和obj2是不同的构造器产生的实例,缺指向相同的构造器,显然出了问题*/

优雅?

有人指出创建一个士兵的代码分散在两个地方很不优雅,于是我们用一个函数把这两部分联系起来:

function 士兵{ var 临时对象 = {}; 临时对象.__proto__ = 士兵.原型; 临时对象.ID = ID; 临时对象.生命值 = 42; return 临时对象;}士兵.原型 = { 兵种:"美国大兵", 攻击力:5, 行走:function(){ /*走俩步的代码*/}, 奔跑:function(){ /*狂奔的代码*/ }, 死亡:function(){ /*Go die*/ }, 攻击:function(){ /*糊他熊脸*/ }, 防御:function(){ /*护脸*/ }}// 保存为文件:士兵.js 然后就可以愉快地引用「士兵」来创建士兵了:var 士兵们 = []for(var i=0; i<100; i ){ 士兵们.push}兵营.批量制造

JS 之父看到大家都这么搞,觉得何必呢,我给你们个糖吃,于是 JS 之父创建了 new 关键字,可以让我们少写几行代码:

图片 7

只要你在士兵前面使用 new 关键字,那么可以少做四件事情:

  1. 不用创建临时对象,因为 new 会帮你做(你使用「this」就可以访问到临时对象);

  2. 不用绑定原型,因为 new 会帮你做(new 为了知道原型在哪,所以指定原型的名字 prototype);

  3. 不用 return 临时对象,因为 new 会帮你做;

  4. 不要给原型想名字了,因为 new 指定名字为 prototype。

var test=Class.create().inherits(class1).extend({
b:function()
{
alert('test');
this.parent('b')
},
c:110
});

质疑

上面的代码存在一个问题:浪费了很多内存

  • 行走、奔跑、死亡、攻击、防御这五个动作对于每个士兵其实是一样的,只需要各自引用同一个函数就可以了,没必要重复创建 100 个行走、100 个奔跑……

  • 这些士兵的兵种和攻击力都是一样的,没必要创建 100 次。

  • 只有 ID 和生命值需要创建 100 次,因为每个士兵有自己的 ID 和生命值。

flower2.prototype=new flower();
/*重置原型后,修改原型的constructor属性*/
flower2.prototype.constructor=flower2
或每次构造实例时都重写constructor属性
function flower2(){
this.constructor=arguments.callee;
}
flower2.prototype=new flower();

共享原型链

现在我们还有另一个对象

var obj2 = { name: "obj2" };

图片 8

那么 obj.toString 和 obj2.toString 其实是同一东西, 也就是 obj2.proto.toString。

说白了,我们改其中的一个proto.toString ,那么另外一个其实也会变!

解决的方法

4)组合继承的优化 1

function Parent4() { this.name = "parent4"; this.play = [1, 2, 3];}Parent4.prototype.say = function() {};function Child4() { Parent4.call; this.type = "child4";}Child4.prototype = Parent4.prototype;var s5 = new Child4();var s6 = new Child4();

这边主要为 Child4.prototype = Parent4.prototype, 因为我们通过构造函数就可以拿到所有属性和实例的方法,那么现在我想继承父类的原型对象,所以你直接赋值给我就行,不用在去 new 一次父类。其实这种方法还是有问题的,如果我在控制台打印以下两句:

图片 9

从打印可以看出,此时我是没有办法区分一个对象 是直接 由它的子类实例化还是父类呢?我们还有一个方法判断来判断对象是否是类的实例,那就是用 constructor,我在控制台打印以下内容:

图片 10

咦,你会发现它指向的是父类 ,这显然不是我们想要的结果, 上面讲过我们 prototype 里面有一个 constructor, 而我们此时子类的 prototype 指向是 父类的 prototye ,而父类 prototype 里面的 contructor 当然是父类自己的,这个就是产生该问题的原因。

//创建名为class1的构造器
var class1=Class.create().extend({
b:function()
{
alert('clas');
alert(this.c);
},
c:100
});
//创建"对象"(构造器)的实例
var s=new class1();
s.b();// ==>"clas",100

  1. JS 的 new 到底是干什么的

一个构造器产生的实例,其constructor属性默认总是指向该构造器
alert(obj.constructor);//==>flower
构造器原型的constructor属性 指向构造器本身
alert(flower.prototype.constructor==flower);//==>true
constructor会与原型继承发生的冲突

  • 原文:搞懂 JavaScript 继承原理

继承父类,并调用父类的方法:

1)借助构造函数实现继承

function Parent1() { this.name = "parent1";}Parent1.prototype.say = function() {};function Child1() { Parent1.call; this.type = "child";}console.log(new Child1;

图片 11

这个主要是借用 call 来改变 this 的指向,通过 call 调用 Parent ,此时 Parent 中的 this 是指 Child1。有个缺点,从打印结果看出 Child1 并没有 say 方法,所以这种只能继承父类的实例属性和方法,不能继承原型属性/方法。

您可能感兴趣的文章:

  • js对象继承之原型链继承实例
  • js对象的复制继承实例
  • javascript 面向对象封装与继承
  • JavaScript中创建对象和继承示例解读
  • 使用apply方法实现javascript中的对象继承
  • javascript的函数、创建对象、封装、属性和方法、继承
  • js对象的构造和继承实现代码
  • JavaScript中的对象继承关系

复制代码 代码如下:

1. 什么是 JS 原型链?

我们知道 JS 有对象,比如

var obj = { name: "obj" };

我们通过控制台把 obj 打印出来:

图片 12

我们会发现 obj 已经有几个属性了。那么问题来了:valueOf / toString / constructor 是怎么来?我们并没有给 obj.valueOf 赋值呀。

上面这个图有点难懂,我手画一个示意图:

图片 13

我们发现控制台打出来的结果是:

  • obj 本身有一个属性 name

  • obj 还有一个属性叫做proto

  • obj 还有一个属性,包括 valueOf, toString, constructor 等

  • obj.proto其实也有一个叫做proto的属性(console.log 没有显示),值为 null

现在回到我们的问题:obj 为什么会拥有 valueOf / toString / constructor 这几个属性?

答案: 这跟proto有关 。

当我们「读取」 obj.toString 时,JS 引擎会做下面的事情:

  • 看看 obj 对象本身有没有 toString 属性。没有就走到下一步。

  • 看看 obj.proto对象有没有 toString 属性, 发现 obj.proto有 toString 属性, 于是找到了,所以 obj.toString 实际就是第 2 步中找到的 obj.proto.toString。

  • 如果 obj.proto没有,那么浏览器会继续查看 obj.proto.proto

  • 如果 obj.proto.proto也没有,那么浏览器会继续查看 obj.proto.proto.proto

  • 直到找到 toString 或者proto为 null。

上面的过程,就是「读」属性的「搜索过程」。而这个「搜索过程」,是连着由proto组成的链子一直走的。这个链子,就叫做「原型链」。

javascript中,对象没有原型,而构造器有原型
原型的含义:如果构造器有一个原型对象 A,则由该构造器创建的实例都必然复制自A

复制代码 代码如下:

关于Fundebug

Fundebug专注于JavaScript、微信小程序、微信小游戏、支付宝小程序、React Native、Node.js和Java线上应用实时BUG监控。 自从2016年双十一正式上线,Fundebug累计处理了10亿 错误事件,付费客户有Google、360、金山软件、百姓网等众多品牌企业。欢迎大家免费试用!

图片 14

组合继承的优化 2

/** * 组合继承的优化2 */function Parent5() { this.name = "parent4"; this.play = [1, 2, 3];}Parent5.prototype.say = function() {};function Child5() { Parent5.call; this.type = "child4";}Child5.prototype = Object.create(Parent5.prototype);

这里主要使用Object.create(),它的作用是将对象继承到proto属性上。举个例子:

var test = Object.create({ x: 123, y: 345 });console.log; //{}console.log; //123console.log(test.__proto__.x); //3console.log(test.__proto__.x === test.x); //true

那大家可能说这样解决了吗,其实没有解决,因为这时 Child5.prototype 还是没有自己的 constructor,它要找的话还是向自己的原型对象上找最后还是找到 Parent5.prototype, constructor 还是 Parent5 ,所以要给 Child5.prototype 写自己的 constructor:

Child5.prototype = Object.create(Parent5.prototype);Child5.prototype.constructor = Child5;

参考

  • 什么是 JS 原型链?

  • this 的值到底是什么?一次说清楚

  • JS 的 new 到底是干什么的?

这一次用 new 来写

function 士兵{ this.ID = ID this.生命值 = 42}士兵.prototype = { 兵种:"美国大兵", 攻击力:5, 行走:function(){ /*走俩步的代码*/}, 奔跑:function(){ /*狂奔的代码*/ }, 死亡:function(){ /*Go die*/ }, 攻击:function(){ /*糊他熊脸*/ }, 防御:function(){ /*护脸*/ }}// 保存为文件:士兵.js然后是创建士兵(加了一个 new 关键字):var 士兵们 = []for(var i=0; i<100; i ){ 士兵们.push)}兵营.批量制造

new 的作用,就是省那么几行代码。(也就是所谓的语法糖)

3. JS 的 new 到底是干什么的?

我们声明一个士兵,具有如下属性:

var 士兵 = { ID: 1, // 用于区分每个士兵 兵种: "美国大兵", 攻击力: 5, 生命值: 42, 行走: function() { /*走俩步的代码*/ }, 奔跑: function() { /*狂奔的代码*/ }, 死亡: function() { /*Go die*/ }, 攻击: function() { /*糊他熊脸*/ }, 防御: function() { /*护脸*/ }};

我们制造一个士兵, 只需要这样:

兵营.制造;

如果需要制造 100 个士兵怎么办呢?

循环 100 次吧:var 士兵们 = []var 士兵for(var i=0; i<100; i ){ 士兵 = { ID: i, // ID 不能重复 兵种:"美国大兵", 攻击力:5, 生命值:42, 行走:function(){ /*走俩步的代码*/}, 奔跑:function(){ /*狂奔的代码*/ }, 死亡:function(){ /*Go die*/ }, 攻击:function(){ /*糊他熊脸*/ }, 防御:function(){ /*护脸*/ } } 士兵们.push}兵营.批量制造

[ ] 语法

function fn() { console.log;}var arr = [fn, fn2];arr[0](); // 这里面的 this 又是什么呢?

我们可以把 arr0想象为 arr.0,虽然后者的语法错了,但是形式与转换代码里的 obj.child.method 对应上了,于是就可以愉快的转换了:

arr[0]();

假想为 arr.0()然后转换为 arr.0.call那么里面的 this 就是 arr 了 :)

  • this 就是你 call 一个函数时,传入的第一个参数。

  • 如果你的函数调用不是 call 形式, 请将其转换为 call 形式

码部署后可能存在的 BUG 没法实时知道,事后为了解决这些 BUG,花了大量的时间进行 log 调试,这边顺便给大家推荐一个好用的 BUG 监控工具Fundebug。

四、继承

继承的本质就是上面的讲的原型链

注意 constructor 属性

new 操作为了记录「临时对象是由哪个函数创建的」,所以预先给「士兵.prototype」加了一个 constructor 属性:

士兵.prototype = { constructor: 士兵};

如果你重新对「士兵.prototype」赋值,那么这个 constructor 属性就没了,所以你应该这么写:

士兵.prototype.兵种 = "美国大兵";士兵.prototype.攻击力 = 5;士兵.prototype.行走 = function() { /*走俩步的代码*/};士兵.prototype.奔跑 = function() { /*狂奔的代码*/};士兵.prototype.死亡 = function() { /*Go die*/};士兵.prototype.攻击 = function() { /*糊他熊脸*/};士兵.prototype.防御 = function() { /*护脸*/};

或者你也可以自己给 constructor 重新赋值:

士兵.prototype = { constructor: 士兵, 兵种: "美国大兵", 攻击力: 5, 行走: function() { /*走俩步的代码*/ }, 奔跑: function() { /*狂奔的代码*/ }, 死亡: function() { /*Go die*/ }, 攻击: function() { /*糊他熊脸*/ }, 防御: function() { /*护脸*/ }};

  1. this 的值到底是什么

改进

通过第一节可以知道 ,我们可以通过原型链来解决重复创建的问题:我们先创建一个「士兵原型」,然后让「士兵」的proto指向「士兵原型」。

var 士兵原型 = { 兵种:"美国大兵", 攻击力:5, 行走:function(){ /*走俩步的代码*/}, 奔跑:function(){ /*狂奔的代码*/ }, 死亡:function(){ /*Go die*/ }, 攻击:function(){ /*糊他熊脸*/ }, 防御:function(){ /*护脸*/ }}var 士兵们 = []var 士兵for(var i=0; i<100; i ){ 士兵 = { ID: i, // ID 不能重复 生命值:42 } /*实际工作中不要这样写,因为 __proto__ 不是标准属性*/ 士兵.__proto__ = 士兵原型 士兵们.push}兵营.批量制造

本文由时时app平台注册网站发布于web前端,转载请注明出处:JS 的 new 到底是怎么的?

关键词: