在使用浏览器浏览网页的时候，当页面刷新很慢的时候，你的浏览器在干什么？你的屏幕内容是什么？是的，你的浏览器在等待刷新，而你的屏幕内容是一片空白， 而你在屏幕前苦苦的等待浏览器的响应。开发人员为了克服这种尴尬的局面，不得不在每一个可能需要长时间等待响应的页面上增加一个div，告诉用户“系统正 在处理您的请求，请稍候……”。
现在，有一种越来越流行越热的“老”技术，可以彻底改变这种窘迫的局面。那就是ajax。如今，随着gmail、google-maps的应用和各种浏览器的支持，ajax正逐渐吸引全世界的眼球。
一、ajax定义
ajax（asynchronous javascript and xml）其实是多种技术的综合，包括javascript、xhtml和css、dom、xml和xstl、xmlhttprequest。其中：
使用xhtml和css标准化呈现，使用dom实现动态显示和交互，使用xml和xstl进行数据交换与处理，使用xmlhttprequest对象进行异步数据读取，使用javascript绑定和处理所有数据。
在ajax提出之前，业界对于上述技术都只是单独的使用，没有综合使用，也是由于之前的技术需求所决定的。随着应用的广泛，ajax也成为香饽饽了。
二、现状与需要解决的问题
传统的web应用采用同步交互过程，这种情况下，用户首先向 http服务器触发一个行为或请求的呼求。反过来，服务器执行某些任务，再向发出请求的用户返回一个html页面。这是一种不连贯的用户体验，服务器在处 理请求的时候，用户多数时间处于等待的状态，屏幕内容也是一片空白。如下图：
自从采用超文本作为web传输和呈现之后，我们都是采用这么一套传输方式。当负载比较小的时候，这并不会体现出有什么不妥。可是当负载比较大， 响应时间要很长，1分钟、2分钟……数分钟的时候，这种等待就不可忍受了。严重的，超过响应时间，服务器干脆告诉你页面不可用。另外，某些时候，我只是想 改变页面一小部分的数据，那为什么我必须重新加载整个页面呢？！当软件设计越来越讲究人性化的时候，这么糟糕的用户体验简直与这种原则背道而驰。为什么老 是要让用户等待服务器取数据呢？至少，我们应该减少用户等待的时间。现在，除了程序设计、编码优化和服务器调优之外，还可以采用ajax。
三、为什么使用ajax
与传统的web应用不同，ajax采用异步交互过程。ajax在用 户与服务器之间引入一个中间媒介，从而消除了网络交互过程中的处理—等待—处理—等待缺点。用户的浏览器在执行任务时即装载了ajax引擎。ajax引擎 用javascript语言编写，通常藏在一个隐藏的框架中。它负责编译用户界面及与服务器之间的交互。ajax引擎允许用户与应用软件之间的交互过程异 步进行，独立于用户与网络服务器间的交流。现在，可以用javascript调用ajax引擎来代替产生一个http的用户动作，内存中的数据编辑、页面 导航、数据校验这些不需要重新载入整个页面的需求可以交给ajax来执行。
使用ajax，可以为isp、开发人员、终端用户带来可见的便捷：
- 减轻服务器的负担。ajax的原则是“按需取数据”，可以最大程度的减少冗余请求，和响应对服务器造成的负担。
- 无 刷新更新页面，减少用户心理和实际的等待时间。特别的，当要读取大量的数据的时候，不用像reload那样出现白屏的情况，ajax使用xmlhttp对 象发送请求并得到服务器响应，在不重新载入整个页面的情况下用javascript操作dom最终更新页面。所以在读取数据的过程中，用户所面对的不是白 屏，是原来的页面内容（也可以加一个loading的提示框让用户知道处于读取数据过程），只有当数据接收完毕之后才更新相应部分的内容。这种更新是瞬间 的，用户几乎感觉不到。
- 带来更好的用户体验。
- 可以把以前一些服务器负担的工作转嫁到客户端，利用客户端闲置的能力来处理，减轻服务器和带宽的负担，节约空间和宽带租用成本。
- 可以调用外部数据。
- 基于标准化的并被广泛支持的技术，不需要下载插件或者小程序。
- 进一步促进页面呈现和数据的分离。
四、谁在使用ajax
在应用ajax开发上面，google当仁不让是表率。orkut、gmail、google groups、google maps、google suggest都应用了这项技术。amazon的a9.com搜索引擎也采用了类似的技术。
微软也在积极开发更为完善的ajax应用：它即将推出代号为atlas的ajax工具。atlas的功能超越了ajax本身，包括整合 visual studio的调试功能。另外，新的asp.net控件将使客户端控件与服务器端代码的捆绑更为简便。atlas客户脚本框架（atlas clent script framework）也使与网页及相关项目的交互更为便利。但visual studio 2005中并不包含此项功能。
微软最近宣布atlas客户脚本框架将包含如下内容（详细资料请访问atlas计划网站）：
- 一个可扩展的核心框架，它添加了javascript功能：如生命同时期管理、继承管理、多点传送处理器和界面管理。
- 一个常见功能的基本类库，有丰富的字符串处理、计时器和运行任务。
- 为html附加动态行为的用户界面框架。
- 一组用来简化服务器连通和网络访问的网络堆栈。
- 一组丰富的用户界面开发控件，如：自动完成的文本框、动画和拖放。
- 处理浏览器脚本行为差异的浏览器兼容层面。
典型的，微软将ajax技术应用在msn space上面。很多人一直都对ms space服务感到很奇怪，当提交回复评论以后，浏览器会暂时停顿一下，然后在无刷新的情况下把我提交的评论显示出来。这个就是应用了ajax的效果。试 想，如果添加一个评论就要重新刷新整个页面，那可真费事。
目前，ajax应用最普遍的领域是gis-map方面。gis的区域搜索强调快速响应，ajax的特点正好符合这种需求。
五、用ajax改进你的设计
ajax虽然可以实现无刷新更新页面内容，但是也不是什么地方都可以用，主要应用在交互较多、频繁读数据、数据分类良好的web应用中。现在，让我们举两个例子，看看如何用ajax改进你的设计。
例子1：数据校验
在输入form表单内容的时候，我们通常需要确保数据的唯一性。因此，常常在页面上提供“唯一性校验”按钮，让用户点击，打开一个校验小窗口；或者等 form提交到服务器端，由服务器判断后在返回相应的校验信息。前者，window.open操作本来就是比较耗费资源的，通常由window. showmodaldialog代替，即使这样也要弹出一个对话框；后者，需要把整个页面提交到服务器并由服务器判断校验，这个过程不仅时间长而且加重了 服务器负担。而使用ajax，这个校验请求可以由xmlhttprequest对象发出，整个过程不需要弹出新窗口，也不需要将整个页面提交到服务器，快
速又不加重服务器负担。例子2：按需取数据—级联菜单
以前，为了避免每次对菜单的操作引起的重载页面，不采用每次调用后台的方 式，而是一次性将级联菜单的所有数据全部读取出来并写入数组，然后根据用户的操作用javascript来控制它的子集项目的呈现，这样虽然解决了操作响 应速度、不重载页面以及避免向服务器频繁发送请求的问题，但是如果用户不对菜单进行操作或只对菜单中的一部分进行操作的话，那读取的数据中的一部分就会成 为冗余数据而浪费用户的资源，特别是在菜单结构复杂、数据量大的情况下（比如菜单有很多级、每一级菜又有上百个项目），这种弊端就更为突出。
现在应用ajax，在初始化页面时我们只读出它的第一级的所有数据并显示，在用户操作一级菜单其中一项时，会通过ajax向后台请求当前一级 项目所属的二级子菜单的所有数据，如果再继续请求已经呈现的二级菜单中的一项时，再向后面请求所操作二级菜单项对应的所有三级菜单的所有数据，以此类 推……这样，用什么就取什么、用多少就取多少，就不会有数据的冗余和浪费，减少了数据下载总量，而且更新页面时不用重载全部内容，只更新需要更新的那部分 即可，相对于后台处理并重载的方式缩短了用户等待时间，也把对资源的浪费降到最低。
例子3：读取外部数据
ajax可以调用外部数据，因此，可以对一些开发的数据比如xml文档、rss文档进行二次加工，实现数据整合或者开发应用程序。六、ajax的缺陷
ajax不是完美的技术。使用ajax，它的一些缺陷不得不权衡一下：
- ajax大量使用了javascript和ajax引擎，而这个取决于浏览器的支持。ie5.0及以上、 mozilla1.0、netscape7及以上版本才支持，mozilla虽然也支持ajax，但是提供xmlhttprequest的方式不一样。所 以，使用ajax的程序必须测试针对各个浏览器的兼容性。
- ajax更新页面内容的时候并没有刷新整个页面，因此，网页的后退功能是失效的；有的用户还经常搞不清楚现在的数据是旧的还是已经更新过的。这个就需要在明显位置提醒用户“数据已更新”。
- 对流媒体的支持没有flash、java applet好。
- 一些手持设备（如手机、pda等）现在还不能很好的支持ajax。
七、ajax开发
到这里，已经可以清楚的知道ajax是什么，ajax能做什么，ajax什么地方不好。如果你觉得ajax真的能给你的开发工作带来改进的话，那么继续看看怎么使用ajax吧。
7.1、ajax应用到的技术
ajax涉及到的7项技术中，个人认为javascript、xmlhttprequest、dom、xml比较有用。
a、xmlhttprequest对象
xmlhttprequest是xmlhttp组件的对象，通过这个对象，ajax可以像桌面应用程序一样只同服务器进行数据层面的交换，而不用每次都 刷新界面，也不用每次将数据处理的工作都交给服务器来做；这样既减轻了服务器负担又加快了响应速度、缩短了用户等待的时间。
ie5.0开始，开发人员可以在web页面内部使用xmlhttp activex组件扩展自身的功能，不用从当前的web页面导航就可以直接传输数据到服务器或者从服务器接收数据。,mozilla1.0以及 netscape7则是创建继承xml的代理类xmlhttprequest；对于大多数情况，xmlhttprequest对象和xmlhttp组件很 相似，方法和属性类似，只是部分属性不同。
xmlhttprequest对象初始化：
<script language=”javascript”>
var http_request = false;
//ie浏览器
http_request = new activexobject("msxml2.xmlhttp");
http_request = new activexobject("microsoft.xmlhttp");
//mozilla浏览器
http_request = new xmlhttprequest();
</script>
xmlhttprequest对象的方法：
| 方法 | 描述 |
| abort() |
停止当前请求 |
| getallresponseheaders() |
作为字符串返回完整的headers |
| getresponseheader("headerlabel") |
作为字符串返回单个的header标签 |
| open("method","url"[,asyncflag[,"username"[, "password"]]]) | 设置未决的请求的目标 url，方法，和其他参数 |
| send(content) | 发送请求 |
| setrequestheader("label", "value") | 设置header并和请求一起发送 |
xmlhttprequest对象的属性：
| 属性 | 描述 |
| onreadystatechange | 状态改变的事件触发器 |
| readystate | 对象状态(integer): 0 = 未初始化 1 = 读取中 2 = 已读取 3 = 交互中 4 = 完成 |
| responsetext | 服务器进程返回数据的文本版本 |
| responsexml | 服务器进程返回数据的兼容dom的xml文档对象 |
| status | 服务器返回的状态码, 如：404 = "文件未找到" 、200 ="成功" |
| statustext | 服务器返回的状态文本信息 |
b、javascript
javascript一直被定位为客户端的脚本语言，应用最多的地方是表单数据的校验。现在，可以通过javascript操作xmlhttprequest，来跟数据库打交道。
c、dom
dom（document object model）是提供给html和xml使用的一组api，提供了文件的表述结构，并可以利用它改变其中的内容和可见物。脚本语言通过dom才可以跟页面进 行交互。web开发人员可操作及建立文件的属性、方法以及事件都以对象来展现。比如，document就代表页面对象本身。
d、xml
通过xml（extensible markup language），可以规范的定义结构化数据，是网上传输的数据和文档符合统一的标准。用xml表述的数据和文档，可以很容易的让所有程序共享。
7.2、ajax开发框架
这里，我们通过一步步的解析，来形成一个发送和接收xmlhttprequest请求的程序框架。ajax实质上也是遵循request/server 模式，所以这个框架基本的流程也是：对象初始化à发送请求à服务器接收à服务器返回à客户端接收à修改客户端页面内容。只不过这个过程是异步的。
a、初始化对象并发出xmlhttprequest请求
为了让javascript可以向服务器发送http请求，必须使用xmlhttprequest对象。使用之前，要先将xmlhttprequest 对象实例化。之前说过，各个浏览器对这个实例化过程实现不同。ie以activex控件的形式提供，而mozilla等浏览器则直接以 xmlhttprequest类的形式提供。为了让编写的程序能够跨浏览器运行，要这样写：
if (window.xmlhttprequest) { // mozilla, safari, ...
http_request = new xmlhttprequest();
}
else if (window.activexobject) { // ie
http_request = new activexobject("microsoft.xmlhttp");
}
有些版本的mozilla浏览器处理服务器返回的未包含xml mime-type头部信息的内容时会出错。因此，要确保返回的内容包含text/xml信息。
http_request = new xmlhttprequest();
http_request.overridemimetype('text/xml');
b、指定响应处理函数
接下来要指定当服务器返回信息时客户端的处理方式。只要将相应的处理函数名称赋给xmlhttprequest对象的onreadystatechange属性就可以了。比如：
http_request.onreadystatechange = processrequest;
需要指出的时，这个函数名称不加括号，不指定参数。也可以用javascript即时定义函数的方式定义响应函数。比如：
http_request.onreadystatechange = function() { };
c、发出http请求
指定响应处理函数之后，就可以向服务器发出http请求了。这一步调用xmlhttprequest对象的open和send方法。
http_request.open('get', 'http://www.example.org/some.file', true);
http_request.send(null);
open的第一个参数是http请求的方法，为get、post或者head。
open的第二个参数是目标url。基于安全考虑，这个url只能是同网域的，否则会提示“没有权限”的错误。这个url可以是任何的url， 包括需要服务器解释执行的页面，不仅仅是静态页面。目标url处理请求xmlhttprequest请求则跟处理普通的http请求一样，比如jsp可以 用request.getparameter(“”)或者request.getattribute(“”)来取得url参数值。
open的第三个参数只是指定在等待服务器返回信息的时间内是否继续执行下面的代码。如果为true，则不会继续执行，直到服务器返回信息。默认为true。
按照顺序，open调用完毕之后要调用send方法。send的参数如果是以post方式发出的话，可以是任何想传给服务器的内容。不过，跟 form一样，如果要传文件或者post内容给服务器，必须先调用setrequestheader方法，修改mime类别。如下：
http_request.setrequestheader(“content-type”,”application/x-www-form-urlencoded”);
这时资料则以查询字符串的形式列出，作为sned的参数，例如：
name=value&anothername=othervalue&so=on
d、处理服务器返回的信息
在第二步我们已经指定了响应处理函数，这一步，来看看这个响应处理函数都应该做什么。
首先，它要检查xmlhttprequest对象的readystate值，判断请求目前的状态。参照前文的属性表可以知道，readystate值为4的时候，代表服务器已经传回所有的信息，可以开始处理信息并更新页面内容了。如下：
if (http_request.readystate == 4) {
// 信息已经返回，可以开始处理
} else {
// 信息还没有返回，等待
}
服务器返回信息后，还需要判断返回的http状态码，确定返回的页面没有错误。所有的状态码都可以在w3c的官方网站上查到。其中，200代表页面正常。
if (http_request.status == 200) {
// 页面正常，可以开始处理信息
} else {
// 页面有问题
}
xmlhttprequest对成功返回的信息有两种处理方式：
responsetext：将传回的信息当字符串使用；
responsexml：将传回的信息当xml文档使用，可以用dom处理。
e、一个初步的开发框架
总结上面的步骤，我们整理出一个初步的可用的开发框架，供以后调用；这里，将服务器返回的信息用window.alert以字符串的形式显示出来：
<script language="javascript">
var http_request = false;
function send_request(url) {//初始化、指定处理函数、发送请求的函数
http_request = false;
//开始初始化xmlhttprequest对象
if(window.xmlhttprequest) { //mozilla 浏览器
http_request = new xmlhttprequest();
if (http_request.overridemimetype) {//设置mime类别
http_request.overridemimetype("text/xml");
}
}
else if (window.activexobject) { // ie浏览器
try {
http_request = new activexobject("msxml2.xmlhttp");
} catch (e) {
try {
http_request = new activexobject("microsoft.xmlhttp");
} catch (e) {}
}
}
if (!http_request) { // 异常，创建对象实例失败
window.alert("不能创建xmlhttprequest对象实例.");
return false;
}
http_request.onreadystatechange = processrequest;
// 确定发送请求的方式和url以及是否同步执行下段代码
http_request.open("get", url, true);
http_request.send(null);
}
// 处理返回信息的函数
function processrequest() {
if (http_request.readystate == 4) { // 判断对象状态
if (http_request.status == 200) { // 信息已经成功返回，开始处理信息
alert(http_request.responsetext);
} else { //页面不正常
alert("您所请求的页面有异常。");
}
}
}
</script>
7.3、简单的示例
接下来，我们利用上面的开发框架来做两个简单的应用。
a、数据校验
在用户注册的表单中，经常碰到要检验待注册的用户名是否唯一。传统的做法是采用window.open的弹出窗口，或者window. showmodaldialog的对话框。不过，这两个都需要打开窗口。采用ajax后，采用异步方式直接将参数提交到服务器，用 window.alert将服务器返回的校验信息显示出来。代码如下：
在<body></body>之间增加一段form表单代码：
<form name="form1" action="" method="post">
用户名：<input type="text" name="username" value="">
<input type="button" name="check" value="唯一性检查" οnclick="usercheck()">
<input type="submit" name="submit" value="提交">
</form>
在开发框架的基础上再增加一个调用函数：
function usercheck() {
var f = document.form1;
var username = f.username.value;
if(username=="") {
window.alert("用户名不能为空。");
f.username.focus();
return false;
}
else {
send_request('sample1_2.jsp?username='+username);
}
}
看看sample1_2.jsp做了什么：
<%@ page contenttype="text/html; charset=gb2312" errorpage="" %>
<%
string username = request.getparameter("username");
if("educhina".equals(username)) out.print("用户名已经被注册，请更换一个用户名。");
else out.print("用户名尚未被使用，您可以继续。");
%>
运行一下，嗯，没有弹出窗口，没有页面刷新，跟预想的效果一样。如果需要的话，可以在sample1_2.jsp中实现更复杂的功能。最后，只要将反馈信息打印出来就可以了。
b、级联菜单
我们在第五部分提到利用ajax改进级联菜单的设计。接下来，我们就演示一下如何“按需取数据”。
首先，在<body></body>中间增加如下html代码：
<table width="200" border="0" cellspacing="0" cellpadding="0">
<tr>
<td height="20">
<a href="javascript:void(0)" οnclick="showroles('pos_1')">经理室</a>
</td>
</tr>
<tr style="display:none">
<td height="20" id="pos_1"> </td>
</tr>
<tr>
<td height="20">
<a href="javascript:void(0)" οnclick="showroles('pos_2')">开发部</a>
</td>
</tr>
<tr style="display:none ">
<td id="pos_2" height="20"> </td>
</tr>
</table>
在框架的基础上增加一个响应函数showroles(obj)：
//显示部门下的岗位
function showroles(obj) {
document.getelementbyid(obj).parentnode.style.display = "";
document.getelementbyid(obj).innerhtml = "正在读取数据..."
currentpos = obj;
send_request("sample2_2.jsp?playpos="+obj);
}
修改框架的processrequest函数：
// 处理返回信息的函数
function processrequest() {
if (http_request.readystate == 4) { // 判断对象状态
if (http_request.status == 200) { // 信息已经成功返回，开始处理信息
document.getelementbyid(currentpos).innerhtml = http_request.responsetext;
} else { //页面不正常
alert("您所请求的页面有异常。");
}
}
}
最后就是smaple2_2.jsp了：
<%@ page contenttype="text/html; charset=gb2312" errorpage="" %>
<%
string playpos = request.getparameter("playpos");
if("pos_1".equals(playpos))
out.print(" 总经理<br> 副总经理");
else if("pos_2".equals(playpos))
out.println(" 总工程师<br> 软件工程师");
%>
运行一下看看效果：
7.4、文档对象模型（dom）
文档对象模型（dom）是表示文档（比如html和 xml）和访问、操作构成文档的各种元素的应用程序接口（api）。一般的，支持javascript的所有浏览器都支持dom。本文所涉及的dom，是 指w3c定义的标准的文档对象模型，它以树形结构表示html和xml文档，定义了遍历这个树和检查、修改树的节点的方法和属性。
7.4.1、dom眼中的html文档：树
在dom眼中，html跟xml一样是一种树形结构的文档，<html>是根（root）节点，<head>、< title>、<body>是<html>的子（children）节点，互相之间是兄弟（sibling）节点； <body>下面才是子节点<table>、<span>、<p>等等。如下图：
这个是不是跟xml的结构有点相似呢。不同的是，html文档的树形主要包含表示元素、标记的节点和表示文本串的节点。
7.4.2、html文档的节点
dom下，html文档各个节点被视为各种类型的node对象。每个node对象都有自己的属性和方法，利用这些属性和方法可以遍历整个文档树。由于html文档的复杂性，dom定义了nodetype来表示节点的类型。这里列出node常用的几种节点类型：
| 接口 | nodetype常量 | nodetype值 | 备注 |
| element | node.element_node | 1 | 元素节点 |
| text | node.text_node | 3 | 文本节点 |
| document | node.document_node | 9 | document |
| comment | node.comment_node | 8 | 注释的文本 |
| documentfragment | node.document_fragment_node | 11 | document片断 |
| attr | node.attribute_node | 2 | 节点属性 |
dom树的根节点是个document对象，该对象的documentelement属性引用表示文档根元素的element对象（对于 html文档，这个就是<html>标记）。javascript操作html文档的时候，document即指向整个文档，< body>、<table>等节点类型即为element。comment类型的节点则是指文档的注释。具体节点类型的含义，请参考 《javascript权威指南》，在此不赘述。
document定义的方法大多数是生产型方法，主要用于创建可以插入文档中的各种类型的节点。常用的document方法有：
| 方法 | 描述 |
| createattribute() | 用指定的名字创建新的attr节点。 |
| createcomment() | 用指定的字符串创建新的comment节点。 |
| createelement() | 用指定的标记名创建新的element节点。 |
| createtextnode() | 用指定的文本创建新的textnode节点。 |
| getelementbyid() | 返回文档中具有指定id属性的element节点。 |
| getelementsbytagname() | 返回文档中具有指定标记名的所有element节点。 |
对于element节点，可以通过调用getattribute()、setattribute()、removeattribute()方法 来查询、设置或者删除一个element节点的性质，比如<table>标记的border属性。下面列出element常用的属性：
| 属性 | 描述 |
| tagname | 元素的标记名称，比如<p>元素为p。html文档返回的tabname均为大写。 |
element常用的方法：
| 方法 | 描述 |
| getattribute() | 以字符串形式返回指定属性的值。 |
| getattributenode() | 以attr节点的形式返回指定属性的值。 |
| getelementsbytabname() | 返回一个node数组，包含具有指定标记名的所有element节点的子孙节点，其顺序为在文档中出现的顺序。 |
| hasattribute() | 如果该元素具有指定名字的属性，则返回true。 |
| removeattribute() | 从元素中删除指定的属性。 |
| removeattributenode() | 从元素的属性列表中删除指定的attr节点。 |
| setattribute() | 把指定的属性设置为指定的字符串值，如果该属性不存在则添加一个新属性。 |
| setattributenode() | 把指定的attr节点添加到该元素的属性列表中。 |
attr对象代表文档元素的属性，有name、value等属性，可以通过node接口的attributes属性或者调用element接口 的getattributenode()方法来获取。不过，在大多数情况下，使用element元素属性的最简单方法是getattribute()和 setattribute()两个方法，而不是attr对象。
7.4.3、使用dom操作html文档
node对象定义了一系列属性和方法，来方便遍历整个文档。用parentnode属性和 childnodes[]数组可以在文档树中上下移动；通过遍历childnodes[]数组或者使用firstchild和nextsibling属性 进行循环操作，也可以使用lastchild和previoussibling进行逆向循环操作，也可以枚举指定节点的子节点。而调用 appendchild()、insertbefore()、removechild()、replacechild()方法可以改变一个节点的子节点从 而改变文档树。
需要指出的是，childnodes[]的值实际上是一个nodelist对象。因此，可以通过遍历childnodes[]数组的每个元素，来枚举一个给定节点的所有子节点；通过递归，可以枚举树中的所有节点。下表列出了node对象的一些常用属性和方法：
node对象常用属性：
| 属性 | 描述 |
| attributes | 如果该节点是一个element，则以namednodemap形式返回该元素的属性。 |
| childnodes | 以node[]的形式存放当前节点的子节点。如果没有子节点，则返回空数组。 |
| firstchild | 以node的形式返回当前节点的第一个子节点。如果没有子节点，则为null。 |
| lastchild | 以node的形式返回当前节点的最后一个子节点。如果没有子节点，则为null。 |
| nextsibling | 以node的形式返回当前节点的兄弟下一个节点。如果没有这样的节点，则返回null。 |
| nodename | 节点的名字，element节点则代表element的标记名称。 |
| nodetype | 代表节点的类型。 |
| parentnode | 以node的形式返回当前节点的父节点。如果没有父节点，则为null。 |
| previoussibling | 以node的形式返回紧挨当前节点、位于它之前的兄弟节点。如果没有这样的节点，则返回null。 |
node对象常用方法：
| 方法 | 描述 |
| appendchild() | 通过把一个节点增加到当前节点的childnodes[]组，给文档树增加节点。 |
| clonenode() | 复制当前节点，或者复制当前节点以及它的所有子孙节点。 |
| haschildnodes() | 如果当前节点拥有子节点，则将返回true。 |
| insertbefore() | 给文档树插入一个节点，位置在当前节点的指定子节点之前。如果该节点已经存在，则删除之再插入到它的位置。 |
| removechild() | 从文档树中删除并返回指定的子节点。 |
| replacechild() | 从文档树中删除并返回指定的子节点，用另一个节点替换它。 |
接下来，让我们使用上述的dom应用编程接口，来试着操作html文档。
a、遍历文档的节点
dom把一个html文档视为树，因此，遍历整个树是应该是家常便饭。跟之前说过的一样，这里我们提供两个遍历树的例子。通过它，我们能够学会 如何使用childnodes[]和firstchile、lastchild、nextsibling、previoussibling遍历整棵树。
例子1-- sample3_1.htm：
这个例子使用了childnodes[]和递归方式 来遍历整个文档，统计文档中出现的element元素总数，并把element标记名全部打印出来。需要特别注意的是，在使用dom时，必须等文档被装载 完毕再执行遍历等行为操作文档。sample3_1.htm具体代码如下：
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=gb2312">
<title>无标题文档</title>
<script language="javascript">
var elementname = ""; //全局变量，保存element标记名，使用完毕要清空
function counttotalelement(node) { //参数node是一个node对象
var total = 0;
if(node.nodetype == 1) { //检查node是否为element对象
total++; //如果是，计数器加1
elementname = elementname + node.tagname + "/r/n"; //保存标记名
}
var childrens = node.childnodes; //获取node的全部子节点
for(var i=0;i<childrens.length;i++) {
total += counttotalelement(childrens[i]); //在每个子节点上进行递归操作
}
return total;
}
</script>
</head>
<body>
<a href="javascript:void(0)"
οnclick="alert('标记总数：' + counttotalelement(document) + '/r/n
全部标记如下：/r/n' + elementname);elementname='';">开始统计</a>
</body>
</html>
例子2 – sample3_2.htm：
接下来使用firstchile、lastchild、nextsibling、previoussibling遍历整个文档树。修改一下counttotalelement函数，其他跟sample3_1.htm一样：
function counttotalelement(node) { //参数node是一个node对象
var total = 0;
if(node.nodetype == 1) { //检查node是否为element对象
total++; //如果是，计数器加1
elementname = elementname + node.tagname + "/r/n"; //保存标记名
}
var childrens = node.childnodes; //获取node的全部子节点
for(var m=node.firstchild; m!=null;m=m.nextsibling) {
total += counttotalelement(m); //在每个子节点上进行递归操作
}
return total;
}
b、搜索文档中特定的元素
在使用dom的过程中，有时候需要定位到文档中的某个特定节点，或者具有特定类型的节点列表。这种情况下，可以调用document对象的getelementsbytagname()和getelementbyid()方法来实现。
document.getelementsbytagname()返回文档中具有指定标记名的全部element节点数组（也是 nodelist类型）。element出现在数组中的顺序就是他们在文档中出现的顺序。传递给getelementsbytagname()的参数忽略 大小写。比如，想定位到第一个<table>标记，可以这样写：document.getelementsbytagname (“table”)[0]。例外的，可以使用document.body定位到<body>标记，因为它是唯一的。
getelementsbytagname()返回的数组取决于文档。一旦文档改变，返回结果也立即改变。相比，getelementbyid ()则比较灵活，可以随时定位到目标，只是要实现给目标元素一个唯一的id属性值。这个我们在《ajax开发简略》的“级联菜单”例子中已经使用过了。
element对象也支持getelementsbytagname()和getelementbyid()。不同的是，搜索领域只针对调用者的子节点。
c、修改文档内容
遍历整棵文档树、搜索特定的节点，我们最终目的之一是要修改文档内容。接下来的三个例子将使用node的几个常用方法，来演示如何修改文档内容。
例子3 -- sample4_1.htm：
这个例子包含三个文本节点和一个按钮。点击按钮后，三个文本节点和按钮的顺序将被颠倒。程序使用了node的appendchild()和removechild()方法。
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=gb2312">
<title>无标题文档</title>
<script language="javascript">
function reversenode(node) { // 颠倒节点node的顺序
var kids = node.childnodes; //获取子节点列表
var kidsnum = kids.length; //统计子节点总数
for(var i=kidsnum-1;i>=0;i--) { //逆向遍历子节点列表
var c = node.removechild(kids[i]); //删除指定子节点，保存在c中
node.appendchild(c); //将c放在新位置上
}
}
</script>
</head>
<body>
<p>第一行</p>
<p>第二行</p>
<p>第三行</p>
<p><input type="button" name="reversego" value="颠倒"
οnclick="reversenode(document.body)"></p>
</body>
</html>
例子4-- sample4_2.htm：
例子1通过直接操作body的子节点来修改文档。在 html文档中，布局和定位常常通过表格<table>来实现。因此，例子4将演示操作表格内容，将表格的四个单元行顺序颠倒。如果没有使用 <tbody>标签，则<table>把全部的<tr>当做是属于一个子节点<tbody>，所以我们 采用数组缓存的方式，把行数据颠倒一下。这个例子同时也演示了如何使用dom创建表格单元行。
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=gb2312">
<title>无标题文档</title>
<script language="javascript">
function reversetable() {
var node = document.getelementsbytagname("table")[0]; //第一个表格
var child = node.getelementsbytagname("tr"); //取得表格内的所有行
var newchild = new array(); //定义缓存数组，保存行内容
for(var i=0;i<child.length;i++) {
newchild[i] = child[i].firstchild.innerhtml;
}
node.removechild(node.childnodes[0]); //删除全部单元行
var header = node.createthead(); //新建表格行头
for(var i=0;i<newchild.length;i++) {
var headerrow = header.insertrow(i); //插入一个单元行
var cell = headerrow.insertcell(0); //在单元行中插入一个单元格
//在单元格中创建textnode节点
cell.appendchild(document.createtextnode(newchild[newchild.length-i-1]));
}
}
</script>
</head>
<body>
<table width="200" border="1" cellpadding="4" cellspacing="0">
<tr>
<td height="25">第一行</td>
</tr>
<tr>
<td height="25">第二行</td>
</tr>
<tr>
<td height="25">第三行</td>
</tr>
<tr>
<td height="25">第四行</td>
</tr>
</table>
<br>
<input type="button" name="reverse" value="开始颠倒" οnclick="reversetable()">
</body>
</html>
例子5 -- sample4_3.htm：
正如我们在node节点介绍部分所指出的那样，appendchild()、replacechild()、removechild()、insertbefore()方法会立即改变文档的结构。下面的例子包含两个表格，我们试着把表格二的内容替换表格一的内容。
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=gb2312">
<title>无标题文档</title>
<script language="javascript">
function replacecontent() {
var table1 = document.getelementsbytagname("table")[0];
var table2 = document.getelementsbytagname("table")[1];
var kid1 = table1.firstchild.firstchild.firstchild; //定位到<td>节点
var kid2 = table2.firstchild.firstchild.firstchild; //定位到<td>节点
var repkid = kid2.firstchild; //定位到表格二<td>内含的textnode节点
try {
//用表格二的单元格内容替换表格一的单元格内容，表格二变成没有单元格内容
kid1.replacechild(repkid,kid1.firstchild);
//下面注释如果开放，将出现object error，因为表格二已经被改变
//kid2.replacechild(kid1.firstchild,kid2.firstchild);
}catch(e){
alert(e);
}
}
</script>
</head>
<body>
<table width="200" border="1" cellspacing="0" cellpadding="0">
<tbody>
<tr>
<td>表格一</td>
</tr>
</tbody>
</table>
<br>
<table width="200" border="1" cellspacing="0" cellpadding="0">
<tbody>
<tr>
<td>表格二</td>
</tr>
</tbody>
</table>
<br>
<input type="button" name="replacenode" value="替换" οnclick="replacecontent()">
</body>
</html>
注意，当执行kid1.replacechild(repkid,kid1.firstchild);的时候，table2的子节点已经被转移 到table1了，table2已经没有子节点，不能再调用table2的子节点。看看代码的注释，试着运行一下，应该就知道文档是怎么改变的了。
d、往文档添加新内容
在学会遍历、搜索、修改文档之后，我们现在试着网文档添加新的内容。其实 没有什么新意，只是利用我们上述提到的node的属性和方法而已，还是操作<table>标记的内容。有新意的是，我们要实现一个留言簿。是 的，留言簿，你可以往里面留言，只是不能刷新噢。
例子6 – sample5_1.htm：
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=gb2312">
<title>无标题文档</title>
<script language="javascript">
function insertstr() {
var f = document.form1;
var value = f.str.value;
if(value!="") {
// 从最终的textnode节点开始，慢慢形成<tbody>结构
var text = document.createtextnode(value); //新建一个textnode节点
var td = document.createelement("td"); //新建一个td类型的element节点
var tr = document.createelement("tr"); //新建一个tr类型的element节点
var tbody = document.createelement("tbody"); //新建一个tbody类型的element节点
td.appendchild(text); //将节点text加入td中
tr.appendchild(td); //将节点td加入tr中
tbody.appendchild(tr); //将节点tr加入tbody中
var parnode = document.getelementbyid("table1"); //定位到table上
parnode.insertbefore(tbody,parnode.firstchild); //将节点tbody插入到节点顶部
//parnode.appendchild(tbody); //将节点tbody加入节点尾部
}
}
</script>
</head>
<body>
<form name="form1" method="post" action="">
<input name="str" type="text" id="str" value="">
<input name="insert" type="button" id="insert" value="留言" οnclick="insertstr()">
</form>
<table width="400" border="1" cellspacing="0" cellpadding="0" id="table1">
<tbody>
<tr>
<td height="25">网友留言列表：</td>
</tr>
</tbody>
</table>
</body>
</html>
我们之前说过，<table>的子节点是<tbody>，<tbody>的子节点才是< tr>，<tr>是<td>的父节点，最后<td>内部的textnode节点。所以，往< table>增加单元格行要逐级形成，就像往树里面添加一个枝桠一样，要有叶子有径。看看，这个留言簿是不是很简单啊。这个例子同时也演示了往 <table>表格标记里面增加内容的另一种方法。
e、使用dom操作xml文档
在数据表示方面，xml文档更加结构化。dom在支持html的 基础上提供了一系列的api，支持针对xml的访问和操作。利用这些api，我们可以从xml中提取信息，动态的创建这些信息的html呈现文档。处理 xml文档，通常遵循“加载xml文档à提取信息à加工信息à创建html文档”的过程。下面的例子演示了如何加载并处理xml文档。
这个例子包含两个js函数。loadxml()负责加载xml文档，其中既包含加载xml文档的2级dom代码，又有实现同样操作的 microsoft专有api代码。需要提醒注意的是，文档加载过程不是瞬间完成的，所以对loadxml()的调用将在加载文档完成之前返回。因此，需 要传递给loadxml()一个引用，以便文档加载完成后调用。
例子中的另外一个函数maketable()，则在xml文档加载完毕之后，使用最后前介绍过的dom应用编程接口读取xml文档信息，并利用这些信息形成一个新的table表格。
例子7 -- sample6_1.htm：
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=gb2312">
<title>无标题文档</title>
<script language="javascript">
function loadxml(handler) {
var url = "employees.xml";
if(document.implementation&&document.implementation.createdocument) {
var xmldoc = document.implementation.createdocument("", "", null);
xmldoc.onload = handler(xmldoc, url);
xmldoc.load(url);
}
else if(window.activexobject) {
var xmldoc = new activexobject("microsoft.xmldom");
xmldoc.onreadystatechange = function() {
if(xmldoc.readystate == 4) handler(xmldoc, url);
}
xmldoc.load(url);
}
}
function maketable(xmldoc, url) {
var table = document.createelement("table");
table.setattribute("border","1");
table.setattribute("width","600");
table.setattribute("class","tab-content");
document.body.appendchild(table);
var caption = "employee data from " + url;
table.createcaption().appendchild(document.createtextnode(caption));
var header = table.createthead();
var headerrow = header.insertrow(0);
headerrow.insertcell(0).appendchild(document.createtextnode("姓名"));
headerrow.insertcell(1).appendchild(document.createtextnode("职业"));
headerrow.insertcell(2).appendchild(document.createtextnode("工资"));
var employees = xmldoc.getelementsbytagname("employee");
for(var i=0;i<employees.length;i++) {
var e = employees[i];
var name = e.getattribute("name");
var job = e.getelementsbytagname("job")[0].firstchild.data;
var salary = e.getelementsbytagname("salary")[0].firstchild.data;
var row = table.insertrow(i+1);
row.insertcell(0).appendchild(document.createtextnode(name));
row.insertcell(1).appendchild(document.createtextnode(job));
row.insertcell(2).appendchild(document.createtextnode(salary));
}
}
</script>
<link href="css/style.css" rel="stylesheet" type="text/css">
</head>
<body οnlοad="loadxml(maketable)">
</body>
</html>
供读取调用的xml文档 – employees.xml：
<?xml version="1.0" encoding="gb2312"?>
<employees>
<employee name="j.doe">
<job>programmer</job>
<salary>32768</salary>
</employee>
<employee name="a.baker">
<job>sales</job>
<salary>70000</salary>
</employee>
<employee name="big cheese">
<job>ceo</job>
<salary>100000</salary>
</employee>
</employees>
7.5、处理xml文档
脱离xml文档的ajax是不完整 的。在本部分未完成之前，有读者说ajax改名叫ajah（h应该代表html吧）比较合适。应该承认，xml文档在数据的结构化表示以及接口对接上有先 天的优势，但也不是所有的数据都应该用xml表示。有些时候单纯的文本表示可能会更合适。下面先举个ajax处理返回xml文档的例子再讨论什么时候使用 xml。
7.5.1、处理返回的xml
例子8 -- sample7_1.htm：
在这个例子中，我们采用之前确定的ajax开发框架，稍微修改一下body内容和processrequest的相应方式，将先前的employees.xml的内容读取出来并显示。
body的内容如下：
<input type="button" name="read"
value="读取xml" οnclick="send_request('employees.xml')">
processrequest()方法修改如下：
// 处理返回信息的函数
function processrequest() {
if (http_request.readystate == 4) { // 判断对象状态
if (http_request.status == 200) { // 信息已经成功返回，开始处理信息
var returnobj = http_request.responsexml;
var xmlobj = http_request.responsexml;
var employees = xmlobj.getelementsbytagname("employee");
var feedbackstr = "";
for(var i=0;i<employees.length;i++) { // 循环读取employees.xml的内容
var employee = employees[i];
feedbackstr += "员工：" + employee.getattribute("name");
feedbackstr +=
" 职位：" + employee.getelementsbytagname("job")[0].firstchild.data;
feedbackstr +=
" 工资：" + employee.getelementsbytagname("salary")[0].firstchild.data;
feedbackstr += "/r/n";
}
alert(feedbackstr);
} else { //页面不正常
alert("您所请求的页面有异常。");
}
}
}
运行一下，看来效果还不错：
7.5.2、选择合适的xml生成方式
现在的web应用程序往往采用了mvc三层剥离的设计方式。xml作为一种数据保存、呈现、交互的文档，其数据往往是动态生成的，通常由 javabean转换过来。由javabean转换成xml文档的方式有好几种，选择合适的转换方式往往能达到事半功倍的效果。下面介绍两种常用的方式， 以便需要的时候根据情况取舍。
a、类自行序列化成xml
类自行序列化成xml即每个类都实现自己的toxml()方法，选择 合适的api、适当的xml结构、尽量便捷的生成逻辑快速生成相应的xml文档。显然，这种方式必须要求每个类编写专门的xml生成代码，每个类只能调用 自己的toxml()方法。应用诸如jdom等一些现成的api，可以减少不少开发投入。例子9是一个利用jdom的api形成的toxml()方法。
例子9 -- toxml() 的 jdom 实现 -- employ类的toxml()方法：
public element toxml() {
element employee = new element(“employee”);
employee.setattribute(“name”,name);
element jobe = new element(“job”).addcontent(job);
employee.setcontent(jobe);
element salarye = new element(“salary”).addcontent(salary);
employee.setcontent(salarye);
return employee;
}
jdom提供了现成的api，使得序列化成xml的工作更加简单，我们只需要把toxml()外面包装一个document，然后使用 xmloutputter把文档写入servlet就可以了。toxml()允许递归调用其子类的toxml()方法，以便生成包含子图的xml文档。
使用类自行序列化成xml的方式，要每个类都实现自己的toxml()方法，而且存在数据模型与视图耦合的问题，即要么为每个可能的视图编写独立的toxml()方法，要么心甘情愿接收冗余的数据，一旦数据结构或者文档发生改变，toxml()就要做必要的修改。
b、页面模板生成xml方式
一般的，可以采用通用的页面模板技术来生成xml文档，这个xml 文档可以符合任何需要的数据模型，供ajax灵活的调用。另外，模板可以采用任何标记语言编写，提高工作效率。下面是一个采用struts标签库编写的 xml文档，输出之前提到的employees.xml：
sample8_2.jsp：
<%@ page contenttype="application/xml; charset=gb2312" import="employee"%>
<%@ page import="java.util.collection,java.util.arraylist"%>
<?xml version="1.0"?>
<%@ taglib uri="/web-inf/struts-logic.tld" prefix="logic" %>
<%@ taglib uri="/web-inf/struts-bean.tld" prefix="bean"%>
<%
employee em1 = new employee();
em1.setname("j.doe");
em1.setjob("programmer");
em1.setsalary("32768");
employee em2 = new employee();
em2.setname("a.baker");
em2.setjob("sales");
em2.setsalary("70000");
employee em3 = new employee();
em3.setname("big cheese");
em3.setjob("ceo");
em3.setsalary("100000");
collection employees = new arraylist();
employees.add(em1);
employees.add(em2);
employees.add(em3);
pagecontext.setattribute("employees",employees);
%>
<employees>
<logic:iterate name="employees" id="employee">
<employee name="<bean:write name='employee' property='name'/>">
<job><bean:write name="employee" property="job"/></job>
<salary><bean:write name="employee" property="salary"/></salary>
</employee>
</logic:iterate>
</employees>
采用页面模板生成xml方式，需要为每个需要的的数据模型建立一个对立的jsp文件，用来生成符合规范的xml文档，而不能仅仅在类的toxml()方法中组织对象图来实现。不过，倒是可以更加方便的确保标记匹配、元素和属性的顺序正确以及xml实体正确转义。
参考资料中philip mccarthy的文章还描述了一种javascript对象标注的生成方式，本文在此不赘述。有兴趣的读者可以自行查看了解。
7.5.3、如何在使用xml还是普通文本间权衡
使用xml文档确实有其方便之处。不过xml文档的某些问题倒是要考虑 一下，比如说延迟，即服务器不能立即解析xml文档成为dom模型。这个问题在一定程度上会影响ajax要求的快速反应能力。另外，某些情况下我们并不需 要使用xml来表示数据，比如说数据足够简单成只有一个字符串而已。就好像我们之前提到的数据校验和级联菜单的例子一样。所以，个人认为在下面这些情况下 可以考虑使用xml来作为数据表示的介质：
- 数据比较复杂，需要用xml的结构化方式来表示
- 不用考虑带宽和处理效率支出
- 与系统其他api或者其他系统交互，作为一种数据中转中介
- 需要特定各式的输出视图而文本无法表示的
总之，要认真评估两种表示方式的表示成本和效率，选择合适的合理的表示方式。
在关于ajax的系列文章的下一篇，我们将综合使用dom和xml，来实现一个可以持久化的简单留言簿。另外，还将试着模拟msn space的部分功能，来体会ajax的魅力。