评论

#hotplum 发表于2008-07-23 09:38:30  IP: 221.221.144.*

呵呵!
我感觉JavaScript就没有一般意义上的"声明"~
比如Delphi的声明在语法分析和编译阶段都是有意义的!
而JavaScript对var 或function 处理的很简单:
比如var a;
其实相当于 var a = undifined;
在执行对象的上下文中初始化了一个变量a,类型是undifined,值也是undifined
而 function b() {};
也是在执行对象的上下文中初始化了一个变量b,只是变量b的类型是function,值就是function b() {}
比如上面的:
var X = (function X() {});
在JScript中 相当于:
先初始化了一个变量X是一个function 然后就是
var X= X; 了
这样 var a=(function X() {}); //括号可以忽略
就是 var a = X; 了

至于var a = (var b = 100); //括号可以忽略
var a = var b = 100; 语法解析器认为你是想
var a = b =100; 显然 第二个var是多于的!
上面 a 和 b 都是number
如果a和b是function呢?
就是这样
var a = b = function (){};
是不是可以得出这样的结论
var 关键字是在运行上下文初始化一个变量(六种类型)
而function x (){};
等价于
var x = function x(){};
初始化一个function类型的变量,值为function x(){};
这样看下面的例子
var a = b = function c(){alert("do")};
alert(typeof a);
alert(typeof b);
alert(typeof c);
在IE中,先是按照 var c = function c(){}; 理解
然后是var a = b =c;

而mozilla中认为 是这样的 var b = function c(){alert("do")};
在b作为一个function类型效果上 b到底是"function c(){alert("do")}"
还是"function (){alert("do")}" 没什么区别的(只是toString不同)!
IE和Firefox谁的理解对,好像也没有什么影响!

正在拜读爱民的大作,胡乱瞎扯几句....

#hotplum 发表于2008-07-23 10:01:07  IP: 221.221.144.*

另外请教个问题:
在书中P31页的例子中(关于引用还是值传递)
var str = 'abcde';
var obj = new String(str);

function newToString() {
return 'hello,world!';
}

function func(val){
val.toString = newToString;
}

func(str);
alert(str);
func(obj);
alert(obj);

如果改成alert(obj+"") ;
如何理解,是不是在
alert(obj);
相当于alert(obj.toString());
alert(obj+"");
相对于 alert(obj.valueOf() +"");

#aimingoo 发表于2008-07-23 13:08:19  IP: 221.220.187.*

先说后面这个问题。对于“+”这个运算符，JS有些特殊的地方。这条规则在“5.3.7.1 运算导致的类型转换”中有讲：
－－－－
仅对两个运算元的“+”运算符来说，JavaScript设定的规则是：当运算元中有任意一个是字符串时，运算符视为“字符串连接”。
－－－－

由于上一规则的存在，而你的示例的第二个远算元是字符串直接量，所以它变成了“字符串连接”。由此，JS
实际调用的代码是这样：

if (isStrType(v1) || isStrType(v2)) {
return getTypePrototype(v1).toString.apply(v1) + getTypePrototype(v2).toString.apply(v2)
}

上面的getTypePrototype(X).toString.apply()是表
明用系统对指定运算元类型的、原型上的toString()方法来转换。

#aimingoo 发表于2008-07-23 13:10:55  IP: 221.220.187.*

对于第一个问题，涉及到你对VAR这个语法关键词的理解。这个问题，在“2.4.1.2 赋值语句与变量声明语句”有详细地讲述，是分语法分析期和执行期两个部分来实现的。

#ljlsunny 发表于2008-07-23 15:08:46  IP: 219.142.61.*

eval()函数还有一个功能就是将一个xml文档，转换为一个对象

#trarck 发表于2008-07-24 11:20:16  IP: 116.228.27.*

var temp=function mytemp(){
alert("temp");
}
temp.prototype.vv=123;
mytemp.prototype.vv=100;

alert(typeof(temp));
alert(typeof(mytemp));

var oo=new temp();
var myo=new mytemp();

alert(oo.vv);
alert(myo.vv);

temp();
mytemp();

#trarck 发表于2008-07-24 11:22:03  IP: 116.228.27.*

对与这个
// 示例5：语法声明阶段重写
// 重写
(function Object(){
}).prototype.value = 100;

// 显示值undefined
var obj = new Object();
alert(obj.value);

我是这么理解的
var temp=function mytemp(){
alert("temp");
}
temp.prototype.vv=123;
mytemp.prototype.vv=100;

alert(typeof(temp));
alert(typeof(mytemp));

var oo=new temp();
var myo=new mytemp();

alert(oo.vv);
alert(myo.vv);

temp();
mytemp();

#tantaiyizu 发表于2008-07-25 14:21:29  IP: 125.34.41.*

你们都在说些什么呢？

#hax 发表于2008-08-19 14:01:04  IP: 207.179.28.*

这个eval中function的问题，归根到底，是JScript如何识别一个function表达式。按照规范，单独的(function(){})就是一个表达式，但是遗憾的是对于JScript来说，括号还不够，一定得在语法分析期望一个表达式时，比如简单的逗号运算符，才会被认为是表达式。

尤其值得注意一点，JScript 5.0到5.5的时候，对function声明和function表达式的行为做了很大的修订，这可能是上述奇怪表现的源头。我手头没有JScript 5.0，所以无法做进一步的确认。

不过可以试着执行 javascript:alert(eval('0,function f1(){}')==f1) ，你会发现返回 false。。。也就是说function表达式产生了一个不同于function声明的结果，换言之这里产生了两个不同的函数（在JScript 5.5之前则应该是一个函数）。

另一个例子是：javascript:alert(eval('(function f1(){return arguments.callee==f1})()'));alert(f1())
返回结果false和true。

注意这里并不是同一个函数绑定到两个symbol，而真的是两个函数，其实际执行效果其实也是不同的（虽然这里这个例子无法表现出来，但是如果加上with语句就会有差别了）。

产生这个用于函数表达式的函数，和函数声明所产生的函数一样，需要不少资源。对此，我写了一个测试：

var MAX = 1000000

function timer(f) {
var start = new Date().getTime()
for (var i = 0; i < MAX; i++) {
f()
}
var end = new Date().getTime()
WScript.Echo(end - start)
}

timer(test0)
timer(test1)
timer(test2)
timer(test3)
timer(test4)
timer(test5)
timer(test6)
timer(test7)

function test0 () {
// do nothing
}

function test1 () {
// func decl
function f() {}
}

function test2 () {
// func decl or exp?
(function f() {})
}

function test3 () {
// two functions
function f1() {}
(function f2() {})
}

function test4 () {
// two references point to one function

#hax 发表于2008-08-19 14:02:10  IP: 207.179.28.*

function test4 () {
// two references point to one function
var f1, f2
f1 = f2 = function () {}
}

function test5 () {
// still one function
var f1 = f2
function f2() {}
}

function test6 () {
// actually two different functions!
var f2 = function f1() {}
}

function test7 () {
// two functions
var f1 = function () {}
function f2() {}
}

执行结果大体如下：
D:\>cscript test-func-benchmark.js
Microsoft (R) Windows Script Host Version 5.7
Copyright (C) Microsoft Corporation. All rights reserved.

2704
7593
7563
10047
7828
7735
10079
10078

这个测试从侧面再一次证明了诸如var x=function f(){}这样的语句，实际会产生两个不同的函数。

因此可以大胆猜想，在JScript 5.5做出这一改动的时候，JScript团队可能认为，从性能优化的角度考虑，应该避免在无必要的时候产生这一额外的用于函数表达式的函数。所以，对于没有任何变量来接收函数表达式的时候，函数表达式的结果就被抛弃了，不幸的是，这也包括仅仅有括号的时候。

#hax 发表于2008-08-19 14:30:57  IP: 207.179.28.*

从另一个方面说，这也解释了你对于何时才是声明语句的疑惑。因为对于function的解析JScript其实并不是遵循标准来的，所以不能按照标准对于函数声明/函数表达式的划分来解释JScript的问题。
JScript现在的表现实际上是最初不符合标准的设计加上JScript 5.5所打的patch的结合体。
按照我的猜测，最初的JScript可能是这样处理的：任何函数结构一律按照函数声明提前处理（所以总是产生变量绑定），函数表达式则被替换为函数对象的引用。
后来JScript 5.5为了改善对于with的处理而加入了真正的函数表达式实现，本来它可以完全fix这个问题。但是估计是为了向前兼容，而保留了原先一律产生变量绑定的做法。结果就是一个语句产生两份函数对象这样微妙的结果。

#hax 发表于2008-08-19 14:48:37  IP: 207.179.28.*

进一步，“那么到底为什么第一种情况下，JScript就一定是理解为“声明语句”而不是表达式呢？”

其实第一种情况（“(function (){})”）既不是声明语句也不是表达式（严格的说是既没有函数声明的效果，也没有函数表达式的效果），实际上这里什么也没执行，这个代码被JScript抛弃掉了（或者说这里是一个被优化掉了的函数表达式）。这一点可以通过类似我上面的性能测试证明（即包含这个语句的函数其执行时间与一个空函数是一样的）。

#aimingoo 发表于2008-08-19 18:15:05  IP: 125.33.149.*

很努力地了解你的想法。但最后一个，你的性能测试并不能表明这个函数声明被抛弃掉。因为函数声明是语法解析期处理的，正好不占用执行时间。

#hax 发表于2008-08-20 16:15:09  IP: 207.179.28.*

可能我表达有问题。我重新总结了一篇：http://hax.javaeye.com/blog/230182

函数声明虽然是语法解析期处理，但是函数对象的生成却是在运行时的。即使是一个函数声明，函数对象也是在进入execution context时产生的，与函数表达式的差别是，它仅在execution context的一开始时生成一次。性能测试当然无法验证非运行时的问题，但是可以表明(function (){...})语句并没有产生对应的函数对象。相反的，如果是 void function () {...} ，就会产生函数对象，(function f(){...})也会，而且两者花费的时间是差不多的。这个时间也就是实例化一个函数对象的时间吧。