(新增官方回复)对【无类语言的OOP（JavaScript描述） 】一贴中第一个代码段的不同意见

网站：JavaEye 作者：keshin 发表时间: 2007-07-16 10:28 此文章来自于 http://www.iteye.com
声明：本文系JavaEye网站原创文章，未经JavaEye网站或者作者本人书面许可，任何其他网站严禁擅自发表本文，否则必将追究法律责任！
原文链接： http://www.iteye.com/topic/101506

几天前一个同事把这篇文章发给我看，当时我看到第一个代码的时候就有不同意见，实在不吐不快，不过由于论坛要注册三天后才能发帖，所以只有等到今天才能发贴。

原文地址：http://www.iteye.com/topic/89554

代码

function Light (light) {
    //填充对象属性
    this.light = light ? light : 0
    this.state = false

    //对象方法。
    //放心，JavaScript 没傻到给每个对象都真去分配一个函数的地步
    this.turnOn = function () {
        this.state = true
    }
}

回帖中也有网友提出不同意见，不过Lich_Ray给出的回复是这样的：

dennis_zane 写道

第一个例子中在构造函数中创建的函数，很多javascript的书都说这样创建的每个对象都有自己的函数版本，比如这里的Light的每个对象都有自己的turnOn，楼主说“JavaScript 没傻到给每个对象都真去分配一个函数的地步“，这一点如何证明？

没好好学编译原理或者没好好看 ECMA-262 吧？

看看下面这一段，摘自 ECMA-262 13 章的一段：

引用

Two uses of the FunctionBody grammar production are defined to be equated when one of the following is true:

* Both uses obtained their FunctionBody from the same location in the source text of the same ECMAScript program. This source text consists of global code and any contained function codes according to the definitions in 10.1.2.

* Both uses obtained their FunctionBody from the same location in the source text of the same call to eval (15.1.2.1). This source text consists of eval code and any contained function codes according to the definitions in 10.1.2

这一段确定符合这些条件的函数，必须被认为是同一个函数。下一段中的注释说明了这有什么用（前文在讲解创建函数的算法步骤）：

引用

Step 1 allows an implementation to optimise the common case of a function A that has a nested function B where B is not dependent on A. In this case the implementation is allowed to reuse the same object for B instead of creating a new one every time A is called. Step 13 makes this optimisation optional; an implementation that chooses not to implement it will go to step 2.

两个字：优化。既然两个函数“相同”，那就保留一个呗！

PS: 多态对于 JavaScript 来说自动存在。看标准理解点运算符和访问运算符 [] 的行为（自动查找继承链）；附件中也有一点浅显的介绍。从我写的 Mixin 代码中也能看出来：PhilipLight 不就是多个 price 属性吗？本来跟 Product 类要求的 price 并不相关，但照用不误。

事实是否如此？我们来看一段代码：

js 代码

function Light() {
  this.turnOn = function () {
    alert("bingo");
  }
}

var lightA = new Light();
var lightB = new Light();

alert(lightA.turnOn === lightB.turnOn);

function Dark() {

}

Dark.prototype.turnOn = function () {
  alert("bingo");
}

var darkA = new Dark();
var darkB = new Dark();
alert(darkA.turnOn === darkB.turnOn);

 

在第一个alert处（第十行），返回的false，而在第二个alert处（22行），返回的是true。

也就是说，第一个类定义的方式，在实例化的时候js会为每个对象分配一个内存空间。而使用prototype则不会有这样的问题。

以上代码在ie和ff上面的运行结果的是一样的。

从规范看，Lich_Ray说的似乎没有问题，我没有仔细看过规范，也不是很懂什么编译原理，但是我知道对于我们实际开发中还是得以客户端的实际实现为依据

昨天我就这个问题向ecma写了封求助信，这是他们的答复（仅修改本人的email地址）：

This all depends somewhat on the implementation, but in a typical and

reasonable implementation the representation of a function has two

parts, the (compiled) code and the environment.  The code is compiled

once and is constant; the environment is variable, and therefore the

function object, which references both code and environment, is

created anew for every function, and therefore occupies separate

memory for every function.



Consider your original program, but changed so that the constructor

takes an argument:



  function Light(v) { this.turnOn = function () {alert(v)} }

  var a = new Light("a");

  var b = new Light("b");



Now a.turnOn() prints "a" and b.turnOn() prints "b".  The environment

for the function that is created for "new Light("a")" contains a

variable v whose value is "a", and the environment for the function

that is created for "new Light("b")" contains a different variable v

whose value is "b", ie, it's a different environment.  But the code

for the two functions is the same, they just reference different

environments, and those environments are available as parts of the

function objects created.



There are no "stacks" here, environments in ECMAScript do not obey

stack discipline, they must (in general) be allocated on the heap and

garbage-collected.  In practice, implementations optimize this when

they can, but in your example they can't, because the two environments

that are created for the calls to "Light" live longer than the calls

do (because they are captured when the function objects are created).



(This is pretty standard stuff, so I'm guessing you haven't had much

experience with these kinds of functions before.  You may want to look

at this:

http://en.wikipedia.org/wiki/Closure_(computer_science); some of the

early examples are in ECMAScript.)



--lars



On 7/16/07, wangmiaomiao  wrote:

> Thanks a lot!

>

> But I still have a question, you say that "a.turnOn and b.turnOn do not

> contain the same function.", dose it means the two function is different in

> Memory(stack)?

>

> Looking forward to your reply! Thanks

>

> ----- Original Message -----

> From: "Lars T Hansen" <[e-mail]>

> To:

> Cc: "TC39" <[e-mail]>

> Sent: Monday, July 16, 2007 11:34 PM

> Subject: Re: FW: Can somebody take this and reply?

>

> >> Excuse me for the bothering you. But I hope somebody could help me with

> >> the

> >> following question. My code is like this: function Light() { this.turnOn

> >> =

> >> function () {alert("bingo");} } var a = new Light(); var b = new Light();

> >> alert(a.turnOn === b.turnOn); according to ur Standard ECMA-262, the two

> >> variables should use the same function, but why the compare operation

> >> will

> >> return false? Looking forward to your reply! Thanks

> >>

> >>  mio wang

> >>

> >>  Reply to:

> >

> > a.turnOn and b.turnOn do not contain the same function.  They contain

> > functions created from the same function body, but in different

> > environments (the environments in this case being created by the calls

> > to the Light constructor).

> >

> > The mechanics of this are described in section 13 of ECMA-262, where

> > you will see that the first step in evaluating an expression of the

> > form "function () { ... }" is to create a fresh function object.

> > Since === compares objects by their identities in general, two

> > function objects created by two evaluations of such a function

> > expression compares differently.

> >

> > --lars

> >

>

>

我的理解是，编译的代码确实只有一份，但是

the environment is variable, and therefore the

function object, which references both code and environment, is

created anew for every function, and therefore occupies separate

memory for every function

也就是说每个function是不同的，因为，call（调用）和实例化却是不同的，实例化是一个带有一定持久性的概念。规范关于此的陈述也仅仅是call，注意，全部是call。

不知Lich_Ray的理解如何？

《 (新增官方回复)对【无类语言的OOP（JavaScript描述） 】一贴中第一个代码段的不同意见 》 的评论也很精彩，欢迎您也添加评论。查看详细 >>

推荐相关文章：
  函数式编程语言曲高和寡？
  如何把erlang应用在项目中？




JavaEye推荐
上海乐福狗信息技术有限公司:诚聘技术经理和开发工程师
免费下载IBM社区版软件--它基于开放的标准，支持广泛的开发类型，让您的开发高效自主！
京沪穗蓉四地免费注册，SOA技术高手汇聚交锋.
上海：优秀公司德比：高薪诚聘 资深Java工程师
广州：优易公司：诚聘Java工程师，开发经理
上海：尤恩斯国际集团：诚聘开发工程师
北京：优秀公司NHNChina招聘:WEB开发,系统管理,JAVA开发, DBA