JS 的 new 到底是干什么的?

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(){ /*护脸*/       }
}
 
兵营.制造(士兵)

在其他语言中,new操作符都是用来实例化创建一个对象的,JavaScript
中同样如此,但是它又有一些不同。为了说清楚这个问题我们先来看一下JavaScript
中的类、原型、原型链、继承这些概念吧。

制造一百个士兵

如果需要制造 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(士兵)
}
 
兵营.批量制造(士兵们)

哎呀好简单。

 

质疑

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

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

JavaScript 中没有传统类的概念,它的类就是一个方法,也就是说JavaScript
中是通过function来定义类的。比如我们可以这样子来定义一个类。

改进

看过我们的专栏以前文章(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(士兵)
}
 
兵营.批量制造(士兵们)

function Person(name, age) { 

优雅?

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

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))
}
 
兵营.批量制造(士兵们)

     this.name = name; 

JS 之父的关怀

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

图片 2

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

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

     this.age = age; 

这一次我们用 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
的作用,就是省那么几行代码。(也就是所谓的语法糖)

     this.sing = function() { alert(this.name) } 

注意 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
评论

图片 3

}

 

 

那么,有类了就一定存在着继承,而js的继承跟传统的类继承模型不同,它是使用
prototype 原型模型。这经常被当作是 JavaScript
的缺点被提及,其实基于原型的继承模型比传统的类继承还要强大。
实现传统的类继承模型是很简单,但是实现
js中的原型继承则要困难的多。JavaScript
使用原型链的继承方式。我们来看下这个例子。

复制代码

function Foo() {

    this.value = 42;

}

Foo.prototype = {

    method: function() {}

};

 

function Bar() {}

 

// 设置Bar的prototype属性为Foo的实例对象

Bar.prototype = new Foo();

Bar.prototype.foo = ‘Hello World’;

 

// 修正Bar.prototype.constructor为Bar本身

Bar.prototype.constructor = Bar;

 

var bar= new Bar() // 创建Bar的一个新实例

 

// 原型链

test [Bar的实例]

    Bar.prototype [Foo的实例] 

        { foo: ‘Hello World’ }

        Foo.prototype

            {method: …};

            Object.prototype

                {toString: … /* etc. */};

复制代码

  上面的例子中,test 对象从 Bar.prototype 和 Foo.prototype
继承下来;因此, 它能访问 Foo 的原型方法
method。同时,它也能够访问那个定义在原型上的 Foo 实例属性 value。
需要注意的是 new Bar() 不会创造出一个新的 Foo 实例,而是
重复使用它原型上的那个实例;因此,所有的 Bar 实例都会共享相同的 value
属性。

 

  这里我觉得有必要来说一下原型、原型链和实例之间的关系。JavaScript中,每个函数都有一个prototype属性,这是一个指针,指向了这个函数的原型对象。这个对象包含这个函数创建的实例的共享属性和方法。也就是说原型对象中的属性和方法是所有实例共享。而这个原型对象有一个constructor属性,指向了该构造函数。每个通过该构造函数创建的对象都包含一个指向原型对象的内部指针__proto__。
原型链作为实现继承的主要方法,其基本思想是:让原型对象等于另一个类型的实例,这样原型对象将包含一个指向另一个原型的指针,相应的,另一个原型中也包含着一个指向另一个构造函数的指针,假如另一个原型又是另一个类型的实例,如此层层递进,就构成了实例与原型的链条,这个链条就称之为原型链.

         回到主题上,但我们使用new
Foo()创造出一个示例这过程中它做了写什么事呢?

     1、创建一个空对象,并且 this
变量引用该对象,同时还继承了该函数的原型。

     2、属性和方法被加入到 this 引用的对象中。

     3、新创建的对象由 this 所引用,并且最后隐式的返回 this 。

相关文章