早该知道的7个JavaScript技巧

文章转自：http://www.cnblogs.com/liupeizhi/archive/2012/01/07/2315791.html

 

简洁写法

JavaScript里我最喜欢的一种东西就是生成对象和数组的简写方法。在过去，如果你想创建一个对象，你需要这样：

1. var  car  =  new  Object();   
2. car.colour  =  'red' ;   
3. car.wheels  =  4 ;   
4. car.hubcaps  =  'spinning' ;   
5. car.age  =  4 ;  

下面的写法能够达到同样的效果：

1. var  car  = {   
2. colour:'red',   
3. wheels:4,   
4. hubcaps:'spinning',   
5. age:4   
6. }  

简单多了，你不需要反复使用这个对象的名称。这样car就定义好了，也许你会遇到invalidUserInSession的问题，这只有你在使用 IE时会碰到，只要记住一点，不要右大括号前面写分号，你就不会有麻烦。另外一个十分方便的简写是针对数组的。传统的定义数组的方法是这样：

1. var  moviesThatNeedBetterWriters  
2. =  new  Array(   
3.  'Transformers','Transformers2','Avatar','Indiana  
4. Jones 4'   
5. );  

简写版的是这样：

1. var  moviesThatNeedBetterWriters  
2. = [   
3. 'Transformers','Transformers2','Avatar','Indiana  
4. Jones 4'   
5. ];  

对于数组，这里有个问题，其实没有什么图组功能。但你会经常发现有人这样定义上面的 car ，就像这样

1. var  car  =  new  Array();   
2. car['colour'] = 'red';   
3. car['wheels'] = 4;   
4. car['hubcaps'] = 'spinning';   
5. car['age'] = 4;  

数组不是万能的；这样写不对，会让人困惑。图组实际上是对象的功能，人们混淆了这两个概念。另外一个非常酷的简写方法是使用与三元条件符号。你不必写成下面的样子：

1. …  
2. var direction;   
3. if(x  <   200 ){   
4. direction  =  1 ;   
5. } else {   
6. direction  = -1;   
7. }   
8. … 

你可以使用三元条件符号简化它：

1. var  direction  
2. =  x   <   200  ? 1 : -1;  

当条件为true 时取问号后面的值，否则取冒号后面的值。

用JSON形式存储数据

在我发现JSON之前，我使用各种疯狂的方法把数据存贮在JavaScript固有的数据类型里面，例如：数组，字符串，中间夹杂着容易进行拆分的标志符号以及其它的令人讨厌的东西。Douglas Crockford 发明了JSON 之后，一切全变了。

使用JSON，你可以使用JavaScript自有功能把数据存贮成复杂的格式，而且不需要再做其它的额外转换，直接可以访问使用。JSON是 “JavaScript Object Notation”的缩写，它用到了上面提到的两种简写方法。于是，如果你想描述一个乐队，你可能会像这样写：

1. var  band  = {   
2. "name":"The Red Hot Chili Peppers",   
3. "members":[   
4. {   
5. "name":"Anthony Kiedis",   
6. "role":"lead vocals"   
7. },   
8. {   
9. "name":"Michael 'Flea' Balzary",   
10. "role":"bass guitar, trumpet, backing vocals"   
11. },   
12. {   
13. "name":"Chad Smith",   
14. "role":"drums,percussion"   
15. },   
16. {   
17. "name":"John Frusciante",   
18. "role":"Lead Guitar"   
19. }   
20. ],   
21. "year":"2009"   
22. }  

你可以在JavaScript里直接使用JSON，可以把它封装在函数里，甚至作为一个API的返回值形式。我们把这称作 JSON-P ，很多的API都使用这种形式。你可以调用一个数据提供源，在script代码里直接返回 JSON-P 数据：

1. < div   id = "delicious" > </ div > < script >    
2. function delicious(o){   
3. var  out  =  '<ul>' ;   
4. for(var  i = 0 ;i < o.length ;i++){   
5. out += ' < li > < a  
6. href = "' + o[i].u + '" > ' +   
7. o[i].d + ' </ a > </ li > ';   
8. }   
9. out += ' </ ul > ';   
10. document.getElementById('delicious') .innerHTML  
11. =  out ;   
12. }   
13. </ script >    
14. < script   src = "http://feeds.delicious.com/v2/json/codepo8/javascript?count=15&callback=delicious" > </ script >   

这是调用 Delicious 网站提供的 Web service 功能，获得JSON格式的最近的无序书签列表。基本上，JSON是最轻便的描述复杂数据结构的方法，而且它能在浏览器里运行。你甚至可以在PHP里用 json_decode() 函数来运行它。

JavaScript的自带函数(Math, Array 和 String)

让我感到惊奇的一个事情是，当我研究了JavaScript里的math和String函数后，发现它们能极大的简化我的编程劳动。使用它们，你可 以省去复杂的循环处理和条件判断。例如，当我需要实现一个功能，找出数字数组里最大的一个数时，我过去是这样写出这个循环的，就像下面：

1. var  numbers  =  
2. [3,342,23,22,124];   
3. var  max  =  0 ;   
4. for(var  i = 0 ;i < numbers.length ;i++){   
5. if(numbers[i]  
6. >  max){   
7. max  =  numbers [i];   
8.  
9. }   
10. }   
11. alert(max);  

我们不用循环也能实现：

1. var  numbers  =  
2. [3,342,23,22,124];   
3. numbers.sort(function(a,b){return b -  
4. a});   
5. alert(numbers[0]);  

需要注意的是，你不能对一个数字字符数组进行 sort() ，因为这种情况下它只会按照字母顺序进行排序。如果你想知道更多的用法，可以阅读 这篇不错的关于 sort() 的文章。再有一个有意思的函数就是 Math.max()。这个函数返回参数里的数字里最大的一个数字：

1. Math.max(12,123,3,2,433,4); // returns 433
2.   

因为这个函数能够校验数字，并返回其中最大的一个，所以你可以用它来测试浏览器对某个特性的支持情况：

1. var  scrollTop =  
2. Math .max(   
3. doc.documentElement.scrollTop,   
4. doc.body.scrollTop   
5. );  

这个是用来解决IE问题的。你可以获得当前页面的 scrollTop 值，但是根据页面上 DOCTYPE 的不同，上面这两个属性中只有一个会存放这个值，而另外一个属性会是 undefined，所以你可以通过使用 Math.max() 得到这个数。阅读这篇文章你会得到更多的关于使用数学函数来简化JavaScript的知识。

另外有一对非常有用的操作字符串的函数是 split() 和 join()。我想最有代表性的例子应该是，写一个功能，用来给页面元素附加CSS样式。是这样的，当你给页面元素附加一个CSS class时，要么它是这个元素的第一个CSS class，或者是它已经有了一些class, 需要在已有的class后加上一个空格，然后追加上这个class。而当你要去掉这个class时，你也需要去掉这个class前面的空格(这个在过去非 常重要，因为有些老的浏览器不认识后面跟着空格的class)。于是，原始的写法会是这样：

1. function addclass(elm,newclass){   
2. var  c  =  
3. elm .className;   
4. elm.className  = ( c  === '') ? newclass : c+' '+newclass;   
5. }  

你可以使用 split() 和 join() 函数自动完成这个任务：

1. function addclass(elm,newclass){   
2. var  classes  =  
3. elm .className.split(' ');   
4. classes.push(newclass);   
5. elm.className  =  classes .join(' ');   
6. }  

这会确保所有的class都被空格分隔，而且你要追加的class正好放在最后。

事件委派

Web应用都是由事件驱动运转的。我喜欢事件处理，尤其喜欢自己定义事件。它能使你的产品可扩展，而不用改动核心代码。有一个很大的问题（也可以说是功能强大的表现），是关于页面上事件的移除问题。你可以对某个元素安装一个事件监听器，事件监听器就开始运转工作。

但页面上没有任何指示说明这有个监听器。因为这种不可表现的问题 (这尤其让一些新手头疼) ，以及像IE6这样的”浏览器“在太多的使用事件监听时会出现各种的内存问题，你不得不承认尽量少使用事件编程是个明智的做法，于是事件委托就出现了。

当页面上某个元素上的事件触发时，而在 DOM 继承关系上，这个元素的所有子元素也能接收到这个事件，这时你可以使用一个在父元素上的事件处理器来处理，而不是使用一堆的各个子元素上的事件监听器来处 理。究竟是什么意思？这样说吧，页面上有很多超链接，你不想直接使用这些链接，想通过一个函数来调用这个链接，HTML代码是这样的：

1. < h2 > Great Web resources </ h2 >    
2. < ul   id = "resources" >    
3. < li > < a   href = "http://opera.com/wsc" > Opera Web Standards  
4. Curriculum </ a > </ li >    
5. < li > < a   href = "http://sitepoint.com" > Sitepoint </ a > </ li >    
6. < li > < a   href = "http://alistapart.com" > A List Apart </ a > </ li >    
7. < li > < a   href = "http://yuiblog.com" > YUI Blog </ a > </ li >    
8. < li > < a   href = "http://blameitonthevoices.com" > Blame it on the voices </ a > </ li >    
9. < li > < a   href = "http://oddlyspecific.com" > Oddly specific </ a > </ li >    
10. </ ul >   

常见的做法是通过循环这些链接，将每个链接上附加一个事件处理器：

1. // 典型的事件处理例子   
2. (function(){   
3. var  resources  
4. =  document .getElementById('resources');   
5. var  links  =  
6. resources .getElementsByTagName('a');   
7. var  all  =  
8. links .length;   
9. for(var  i = 0 ;i < all ;i++){   
10. // Attach a listener to each link   
11. links[i].addEventListener('click',handler,false);   
12. };   
13. function handler(e){   
14. var  x  =  
15. e .target; // Get the link that was  
16. clicked   
17. alert(x);   
18. e.preventDefault();   
19. };   
20. })();  

我们用一个事件处理器也能完成这项任务：

1. (function(){   
2. var  resources  
3. =  document .getElementById('resources');   
4. resources.addEventListener('click',handler,false);   
5. function handler(e){   
6. var  x  =  
7. e .target; // get the link tha   
8. if(x.nodeName.toLowerCase()  
9. === 'a'){   
10. alert('Event  
11. delegation:' + x);   
12. e.preventDefault();   
13. }   
14. };   
15. })();  

因为点击事件就发生在这些页面元素里，你要做的就是比较它们的 nodeName，找出应该回应这个事件的那个元素。免责声明：上面说的这两个关于事件的例子，在所有浏览器里都能运行，除了IE6，在IE6上你需要使 用一个事件模型，而不是简单的W3C的标准实现。这也就是我们推荐使用一些工具包的原因。

这种方法的好处并不是仅限于把多个事件处理器缩减为一个。你想想，举个例子，你需要动态的往这个链接表里追加更多的链接。使用事件委托后，你就不需要做其它修改了；否则的话，你需要重新循环这个链接表，重新给每个链接安装事件处理器。

匿名函数和模块化

在JavaScript里最令人懊恼的事情是变量没有使用范围。任何变量，函数，数组，对象，只要不在函数内部，都被认为是全局的，这就是说，这个 页面上的其它脚本也可以访问它，而且可以覆盖重写它。解决办法是，把你的变量放在一个匿名函数内部，定义完之后立即调用它。例如，下面的写法将会产生三个 全局变量和两个全局函数：

1. var  name  =  'Chris' ;   
2. var  age  =  '34' ;   
3. var  status  =  'single' ;   
4. function createMember(){   
5. // [...]   
6. }   
7. function getMemberDetails(){   
8. // [...]   
9. }  

如果这个页面上的其它脚本里也存在一个叫 status 的变量，麻烦就会出现。如果我们把它们封装在一个 myApplication 里，这个问题就迎刃而解了：

1. var  myApplication  
2. =  function (){   
3. var  name  =  'Chris' ;   
4. var  age  =  '34' ;   
5. var  status  =  'single' ;   
6. function createMember(){   
7. // [...]   
8. }   
9. function getMemberDetails(){   
10. // [...]   
11. }   
12. }();  

但是，这样一来，在函数外面就没有什么功能了。如果这是你需要的，那就可以了。你还可以省去函数的名称：

1. (function(){   
2. var  name  =  'Chris' ;   
3. var  age  =  '34' ;   
4. var  status  =  'single' ;   
5. function createMember(){   
6. // [...]   
7. }   
8. function getMemberDetails(){   
9. // [...]   
10. }   
11. })();  

如果你想在函数外面也能使用里面的东西，那就要做些修改。为了能访问 createMember() 或 getMemberDetails()，你需要把它们变成 myApplication的属性，从而把它们暴露于外部的世界:

1. var  myApplication  
2. =  function (){   
3. var  name  =  'Chris' ;   
4. var  age  =  '34' ;   
5. var  status  =  'single' ;   
6. return{   
7. createMember:function(){   
8. // [...]   
9. },   
10. getMemberDetails:function(){   
11. // [...]   
12. }   
13. }   
14. }();   
15. //  
16. myApplication.createMember() 和   
17. //  
18. myApplication.getMemberDetails() 就可以使用了。  

这被称作module模式或singleton。Douglas Crockford 多次谈到过这些，Yahoo User Interface Library YUI 里对此有大量的使用。但这样一来让我感到不便的是，我需要改变句式来使函数和变量能被外界访问。更甚者，调用时我还需要加上myApplication 这个前缀。所以，我不喜欢这样做，我更愿意简单的把需要能被外界访问的元素的指针导出来。这样做后，反倒简化了外界调用的写法：

1. var  myApplication  
2. =  function (){   
3. var  name  =  'Chris' ;   
4. var  age  =  '34' ;   
5. var  status  =  'single' ;   
6. function createMember(){   
7. // [...]   
8. }   
9. function getMemberDetails(){   
10. // [...]   
11. }   
12. return{   
13. create:createMember,   
14. get:getMemberDetails   
15. }   
16. }();   
17. //现在写成 myApplication.get() 

和myApplication.create() 就行了。我把这个称作 “revealingmodule pattern.”

可配置化

一旦我把所写的JavaScript代码发布到这个世界上，就有人想改动它，通常是人们想让它完成一些它本身完成不了的任务—但通常也是我写的程序 不够灵活，没有提供用户可自定义的功能。解决办法是给你的脚本增加一个配置项对象。我曾经写过一篇深入介绍JavaScript配置项对象的文章，下面是 其中的要点：在你的脚本了添加一个叫做 configuration 的对象。这个对象里面，存放所有人们在使用这个脚本时经常要改动的东西：

◆CSS ID 和类名称;
◆按钮的名称，标签字等;
◆诸如”每页显示图片数”的值， “图像的显示的尺寸”的值;
◆地点，位置，以及语言设置。
◆将这个对象作为一个公用属性返回给用户，这样用户可以修改覆盖它。

通常情况下这是你编程过程中的最后一步要做的事情。我把这些集中表现在了一个例子里： “Five things to do to a script before handing it over to the next developer.”。

实际上，你也希望你的代码能够让人们很方面的使用，并且根据他们各自的需要进行一些改动。如果你实现了这个功能，你会少收到一些抱怨你的脚本的人发送给你的让你困惑的邮件，这些信件会告诉你，有人修改了你的脚本，而且很好用。

与后台交互

在这么多年的编程经历中，我所领悟到的一个重要的事情就是，JavaScript是一个很优秀的开发界面交互的语言，但如果用来处理数字或访问数据 源，那就有点使不上劲了。最初，我学习JavaScript，是用来替代Perl的，因为我很讨厌非要把代码拷贝到cgi-bin文件夹下才能使Perl 运行。后来，我明白了应该使用一种后台工作的语言来处理主要的数据，而不能什么事情都让JavaScript去做。更重要的是我们要考虑安全性和语言特 征。

如果我访问一个Web service, 我可以获取到JSON-P 格式的数据，在客户端浏览器里我把它做各种各样的数据转换，但当我有了服务器时，我有了更多的方法来转换数据，我可以在Server端生成JSON或 HTML格式的数据返回给客户端，以及缓存数据等操作。如果你事先了解了并准备了这些，你会长期收益，省去了很多头疼的时间。

编写适用各种浏览器的程序是种浪费时间，使用工具包吧！在我最初开始搞Web开发时，在访问页面时，究竟是使用document.all还是使用 document.layers 的问题上痛苦的挣扎了很久。我选择了document.layers，因为我喜欢任何层都是自己的document的思想 (而且我写了太多的document.write 来生成元素)。层模式最终失败了，于是我开始使用document.all。

当Netscape 6公布只支持W3C DOM模型时，我很高兴，但其实用户并不关心这些。用户只是看见这种浏览器不能显示大多数浏览器都能正常显示的东西—这是我们编码的问题。我们编写了短视 的代码，只能运行在当前的环境下，而不幸的是，我们的运行环境却在不停的改变。我已经浪费了太多的时间来处理对各种浏览器各种版本兼容的问题。善于处理这 类问题提供了我一个好的工作机会。但现在我们不必在忍受这种痛苦了。

一些工具包，例如 YUI, jQuery 以及Dojo都能够帮我们处理这类问题。它们通过抽象各种接口实现来处理浏览器的各种问题，像版本不兼容，设计缺陷等，把我们从痛苦中解救出来。除非你要 测试某个Beta版的浏览器，千万不要在自己的程序里添加修正浏览器的缺陷的代码，因为你很有可能当浏览器已经修改了这个问题时，你却忘了删除你的代码。 另一方面，完全依赖于工具包也是个短视的行为。工具包可以帮你快速的开发，但如果你不深入理解JavaScript，你也会做错事。