s+=a;
s+=b;
s+=c;

s+=a + b + c；

var buf = new Array();
for(var i = 0; i < 100; i++){
	buf.push(i.toString());
}
var all = buf.join("");

var print;
if(typeof document != "undefined" ){
print = function(){
document.write(arguments[0]);
}
}else if(typeof WScript != "undefined" ){
print = function(){
WScript.Echo(arguments[0],arguments[1],arguments[2]);
}
}
function empty(){
}
function benchmark(f){
var i = 0;
var start = (new Date()).getTime();
while(i < pressure){
f(i++);
}
var end = (new Date()).getTime();
WScript.Echo(end-start);
}
/*
i=0
start = (new Date()).getTime();
while(i < 60000){
c = [i,i,i,i,i,i,i,i,i,i];
i++;
}
end = (new Date()).getTime();
WScript.Echo(end-start);
i=0
start = (new Date()).getTime();
while(i < 60000){
c = new Array(i,i,i,i,i,i,i,i,i,i);
i++;
}
var end = (new Date()).getTime();
WScript.Echo(end-start);
*/
function internCast(i){
return "" + i;
}
function StringCast(i){
return String(i)
}
function newStringCast(i){
return new String(i)
}
function toStringCast(i){
return i.toString();
}
function ParseInt(){
return parseInt(j);
}
function MathFloor(){
return Math.floor(j);
}
function Floor(){
return floor(j);
}
var pressure = 50000;
var a  = "";
var floor = Math.floor;
j = 123.123;
print("-------------\nString Conversion Test");
print("The empty:", benchmark(empty));
print("intern:", benchmark(internCast));
print("String:");
benchmark(StringCast);
print("new String:");
benchmark(newStringCast);
print("toString:");
benchmark(toStringCast);
print("-------------\nFloat to Int Conversion Test");
print("parseInt");
benchmark(ParseInt);
print("Math.floor");
benchmark(MathFloor);
print("floor")
benchmark(Floor);
function newObject(){
return new Object();
}
function internObject(){
return {};
}
print("------------\nliteral Test");
print("runtime new object", benchmark(newObject));
print("literal object", benchmark(internObject));

    for(var i=0;i<100;i++){
arr[i]=0;
}

    var i = 0;
while(i < 100){
arr[i++]=0;
}

    var i = 0;
while(i < 100){
arr[i]=0;
i++;
}

    var i = 0;
var a;
while(i < 100){
a = 0;
i++;
}

    var a;
for(var i=0;i<100;i++){
a = 0;
}

    var a;
var i=0;
while(i<100){
a=i;
i++;
}

    var a;
var i=0;
while(i<100){
a=i++;
}

    var a;
for(var i=0;i<100;i++){
a = i;
}

    var a;
for(var i=0;i<100;){
a = i++;
}

    for(var i=0;i<100;i++){   }

    var i;
while(i<100){        i++;    }

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=747880

function getNode(doc, xpath) {
 varretval = "";
 var value = doc.selectSingleNode(xpath);
 if (value) retval = value.text;
 return retval;
}

function getDataNext() {
 i++;
 if (i > items.length - 1) i = 0;
 
 document.forms[0].SKU.value = getNode(orderDoc, "/Order/Item[" + i + "]/SKU");
 document.forms[0].Price.value = getNode(orderDoc, "/Order/Item[" + i + "]/PricePer");
 document.forms[0].Quantity.value = getNode(orderDoc, "/Order/Item[" + i + "]/Quantity");
 document.forms[0].Total.value = getNode(orderDoc,"/Order/Item[" + i + "]/Subtotal");
 document.forms[0].Description.value = getNode(orderDoc, "/Order/Item[" + i + "]/Description");
}

function getDataPrev() {
 i--;
 if (i < 0) i = items.length - 1;
 
 document.forms[0].SKU.value = getNode(orderDoc, "/Order/Item[" + i + "]/SKU");
 document.forms[0].Price.value = getNode(orderDoc,"/Order/Item[" + i + "]/PricePer");
 document.forms[0].Quantity.value = getNode(orderDoc, "/Order/Item[" + i + "]/Quantity");
 document.forms[0].Total.value = getNode(orderDoc,"/Order/Item["+ i + "]/Subtotal");
 document.forms[0].Description.value = getNode(orderDoc, "/Order/Item[" + i + "]/Description");
}  

window.onload = function() {
 getDataNext();
}

好了，运行看看，和IE的数据岛功能一样

　　不管它有多么流行，极少有人了解JavaScript是一个十分动态的通用面向对象编程语言。这怎能成为一个秘密呢？为什么这个语言如此被误解？

关于名字

　　这个Java-前缀暗示了JavaScript和Java的关系，也就是JavaScipt是Java的一个子集也就是不如Java强大。看上去这个名称就故意制造混乱，然后随之而来的是误解。JavaScript并不是解释型的Java语言。Java是解释型的Java，JavaScript是另一种语言。

　　JavaScript和Java的语法很相似，就象Java和C的语法相似一样。但它也不是Java的子集就像Java也不是C的子集一样。在应用上，Java要远比原先设想的好得多（Java原称Oak）。

　　JavaScript并不是由Sun公司──Java的老家──开发的。JavaScript是由Netscape公司开发。它本来叫做LiveScript，这个名字倒并不是那样容易混淆。

　　这个-Script 后缀暗示了它似乎不是一个完整的编程语言──大多数人以为脚本语言就不算真正的编程语言。但其实这是一个专长的问题。相对C而言，JavaScript牺牲了性能但带来更强的表达力和动态性。

披着C外衣的Lisp

　　JavaScript的C风格的语法，包括大括号和复杂的for 语句，让它看起来好象是一个普通的过程式语言。这是一个误导，而事实上JavaScript和函数式语言如Lisp和Scheme有更多的共同之处。它用数组代替了列表，用对象代替了属性列表，而且函数是第一型的，同时还有闭包。你不需要Lisp那些括号就可以用lambda算子。

思维定势

　　JavaScript是原本只是被设计在Netscape Navigator 中运行的。Netscape的成功让JavaScript成为几乎所有浏览器的标准配置。这导致了对JavaScript的思维定势。JavaScript简直就是程序语言中的George Reeves （一位曾扮演超人的演员，但后来死于枪杀，被官方认为自杀，细节不详──译注）。而事实上，JavaScript也适合很多和Web无关的应用程序。

不断改变的目标

　　JavaScript的第一个版本功能十分弱。它缺少异常处理、内部函数和继承。而它的现在的形态，它已经是一套完整的面向对象语言。但很多看法都是认为它的形式还不成熟。

　　管理这个语言的ECMA委员正在开发扩展，原意是很好，而这样做却会加剧这个语言本来就最严重的问题：版本太多了。这也造成了很多混乱。

设计错误

　　没有什么编程语言是完美的，JavaScript当然也有它的设计上的错误，如+的重载同时表示加和带类型自动转换的串连接，和有错误倾向的 with 语句——应该避免使用。Javascript的保留字策略过于严格。引入分号也是一个很大的错误，正则表达式的记号也是。这些错误会很容易导致编程错误，并导致语言的设计的全局层面上的问题。幸运的是，这些问题可以用一个很好的lint程序来避免。

这个语言的设计从整体上看还是十分健全的。但很令人惊讶的是， ECMAScript委员会好象根本不想修正这些错误。也许他们对重新设计一个更感兴趣。

肮脏的实现

JavaScript的早期实现错误百出。这对该语言带来了很恶劣的影响。更糟糕的是，这些实现还被嵌入的更错误百出的浏览器中。

拙劣的书籍

　　几乎所有的书籍都十分恐怖。里面到处是错误、蹩脚的例子还自创一套拙劣的惯例。语言中重要的特性却常常解释不好，或者干脆完全不写。我翻阅了几十本JavaScript的书，我只推荐两本：JavaScript: The Definitive Guide (4th Edition) by David Flanagan and Dynamic HTML (2nd Edition) by Danny Goodman. 都来自于 O'Reilly.

不够标准的标准

　　该语言的官方标准规格说明书由ECMA发布。但该规格书也是质量奇差。它难以阅读也难以理解。它也对拙劣书籍的问题作出了自己的一份“贡献”，因为作者无法使用这个标准文档来增加他们对语言的认识。ECMA和TC39委员会应该为此感到深深的羞愧。

业余爱好者

大部分写JavaScript的人都不是程序员。他们缺乏训练写好程序的修养。JavaScript有如此丰富的表达能力，他们可以任意用它来写代码，以任何形式。这给JavaScript带来了一个名声──它是专门为外行设计的，不适合专业的程序员。这显然不是事实。

面向对象

　　JavaScript是不是面向对象的？它拥有对象，可以包含数据和处理数据的方法。对象可以包含其它对象。它没有类，但它却有构造器可以做类能做的事，包括扮演类变量和方法的容器的角色。它没有基于类的继承，但它有基于原型的继承。

　　两个建立对象系统的方法是通过继承（是一个……）和通过聚合（有一个……）。JavaScript两个都有，但它的动态性质让它可以在聚合上超越。

　　一些批评说JavaScript不是真正面向对象的因为它不能提供信息的隐藏。也就是，对象不能有私有变量和私有方法：所有的成员都是公共的。

　　但又有证明了JavaScript对象可以拥有私有变量和私有方法。当然，极少有人认识到，因为JavaScript是世界是最受误解的程序嘛！

　　另外还有批评说JavaScript不能提供继承，这里证明了JavaScript不仅能支持传统的继承还能应用其它的代码复用模式。

作者：Douglas Crockford

翻译：ShiningRay

//Adapter模式实例
var xhr = new XMLHttpRequest();
xhr.open("GET", "myData.xml");
xhr.onreadystatechange = function(){
  if(xhr.readyState == 4){
    alert(xhr.responseXML);
  }
}
xhr.send(null);

//Observer模式实例
window.onloadListeners=new Array();
  window.addOnLoadListener(listener){
  window.onloadListeners[window.onloadListeners.length]=listener;
}

window.onload=function(){
  for(var i=0;i<window.onloadListeners.length;i++){
    var func=window.onlloadListeners[i];
    func.call();
  }
}

//Singleton模式实例
var SingletonObj = {
  property1: value1,
  property2: value2,
  ...
  method1:function(){
    ...
  }
  method2:function(){
    ...
  }
  ...
}

function getSingletonObj() {
  if(!top.SingletonObj) {
    var top.SingletonObj = {
      ...
    }
    top.SingletonObj.init(...);
  }
  return top.SingletonObj;
}

//Command模式实例
function buttonOnclickHandler(event){
  var data=calculate();
  showData(dataTable,data);
}
function ajaxOnloadHandler(){
  var data=calculate();
  showData(otherDataTable,data);
}
function calculate(){
  var data=new Array();
  data[0]=6;
  data[1]=data[0]/3;
  data[2]=data[0]*data[1]+7;
  return data;
}
function showData(table,data){
  var newRow=createTableRow(table);
  for (var i=0;i<data.length;i++){
    createTableCell(newRow,data[i]);
  }
}
buttonDiv.onclick=buttonOnclickHandler;
poller.onload=ajaxOnloadHandler;

//MVC应用实例
function Button(value,domEl){
  this.domEl=domEl;
  this.value=value;
  this.domEl.buttonObj=this;
  this.domEl.onclick=this.clickHandler;
}

Button.prototype.clickHandler=function(){
  var buttonObj=this.buttonObj;
  var value=(buttonObj && buttonObj.value) ?
    buttonObj.value : "unknown value";
  alert(value);
}

parse(infos, "user.data");

2.绑定多个事件
dojo.event.connect(DOMNode, 'onclick', 'func1');
dojo.event.connect(DOMNode, 'onclick', 'func2');

3.绑定一个obj的两个方法
dojo.event.connect(DOMNode, 'onclick', evtObj, 'func1');
dojo.event.connect(DOMNode, 'onclick', evtObj, 'func2');

4.让绑定的事件顺序执行
var exampleObj = {
  counter: 0,
  foo: function(){
    alert("foo");
    this.counter++;
  },
  bar: function(){
    alert("bar");
    this.counter++;
  }
};
dojo.event.connect(exampleObj, "foo", exampleObj, "bar"); // 调用foo的话bar也会执行
这样也可以
dojo.event.kwConnect({
 type : 'before' // 让bar在foo之前执行
 srcObj : exampleObj,
 srcFunc : 'foo',
 targetObj : exampleObj,
 targetFunc : 'bar',
 delay : 2000 // bar延迟执行2秒
 once : true // 绑定一次
});
exampleObj.foo();

5.先后执行
dojo.event.connect("after", exampleObj, "foo", exampleObj, "bar"); // bar在foo之后执行
dojo.event.connect("before", exampleObj, "foo", exampleObj, "bar"); // bar在foo之前执行

6.传递参数
var evtObj = function() {
 this.func1 = function(a) {
  return(function(e) {
   alert((e||window.event).type);
  })
 };
 this.func2 = function(b) {
  alert(b);      
 };
}

var o = new evtObj();
var btn = dojo.byId("testBtn");
dojo.event.connect(btn, 'onclick', o.func1('hello'));

以前一般这样写：
function init() {
var evtObj = function() {
 this.func1 = function(a) {
  alert(a.type);
 };
 this.func2 = function(b) {
  alert(b);      
 };
}

var o = new evtObj();
var btn = dojo.byId("testBtn");
dojo.event.connect(btn, 'onclick', function(event){o.func1(event)});
这样的话你在第三个参数就要传递event，很麻烦

<script language="JavaScript">
<!--
// 方法A
var obj = {
 flag : null,
 setTime : function(n) {
  this.flag = setTimeout(function(){
   document.getElementById("div1").style.display = "";
  }, n);
 },
 clear  : function() {
  clearTimeout(this.flag);
  document.getElementById("div1").style.display = "none";
 }
}

document.getElementById("btn").onmouseover = function() {obj.setTime(1000);};
document.getElementById("btn").onmouseout = function() {obj.clear();};
//-->
</script>

<script language="JavaScript">
<!--
//方法B
//var flag;
//function setTime(time) {
// return(function(e){
//  flag=setTimeout(function() {
//   document.getElementById("div1").style.display = "";
//  }, time);
// });
//}
//function clear() {
// clearTimeout(flag);
// document.getElementById("div1").style.display = "none";
//}
//
//document.getElementById("btn").onmouseover = setTime(1000);
//document.getElementById("btn").onmouseout = clear;
//-->
</script>

总觉得方法A和方法B都存在泄露隐患。。。