javascript与XML

曾几何时，XML一度成为存储和通过因特网传输结构化数据的标准，之前，浏览器无法解析XML数据时，开发人员都要手动编写自己的XML解析器。而自从DOM出现后，所有浏览器都内置了对XML的原生支持（XML DOM）,同时也提供了一些相关的技术支持。

创建空白的XML文档：

DOM2级在document.implementation中引入了createDocument（）方法。IE9+、Firefox、Opera、Chrome、safari都支持者个方法：

var xmldom=document.implementation.createDocument(namespaceUri,root,doctype);

在通过javascript处理XML时，通常只使用参数root，因为这个参数指定的是XML DOM文档元素的标签名。而namespaceUri参数则很少用到，原因是在javascript中管理命名空间比较困难。最后，doctype参数用的就更少了。

因此先要创建一个新的、文档元素为<root>的XML文档，可以使用如下代码：

    var xmldom=document.implementation.createDocument("","root",null);
      console.log(xmldom.documentElement.tagName);//"root"
      var child=xmldom.createElement("child");
      xmldom.documentElement.appendChild(child);//创建一个子元素并加入到心创建的XML文档内

以上是创建了一个无默认命名空间，没指定文档类型的，标签名为root的XML DOM文档。并创建了一个子元素，插入了进去。

如果需要检测浏览器是否支持DOM2级XML，可以使用如下代码：

    var hasXmlDom=document.implementation.hasFeature("XML","2.0");
      console.log(hasXmlDom);//true

DOMParser类型：（将XML转化为DOM文档）

为了将XML解析为DOM文档，firefox引入了DOMParser类型，后来IE9、safari、chrome、opera也支持了这个类型。在解析XML之前，首先必须创建一个DOMParser的实例，然后再调用parseFromString（）方法，这个方法接收两个参数：要解析的XML字符串和内容类型（内容类型始终应该是“text/xml”）。返回的值是一个document的实例。例如：

    var parser =new DOMParser();//创建一个DOMParser的实例
      var xmldom=parser.parseFromString("<root><child></child></root>","text/xml");
      console.log(xmldom.documentElement.tagName);//"root"
      console.log(xmldom.documentElement.firstChild.tagName);//"child"

      var anotherChild=xmldom.createElement("child");
      xmldom.documentElement.appendChild(anotherChild);
      var children=xmldom.getElementsByTagName("child");
      console.log(children.length);//2

上述代码我们把一个简单的XML字符串解析成了一个DOM文档。以<root>作为其文档元素，该元素还有一个<child>子元素。此后就可以使用DOM方法对返回的这个文档进行操作了。

DOMParser只能解析格式良好的XML，因此不能把HTML解析为HTML文档，在发生解析错误时，仍然会从parseFromString（）中返回一个Document对象，但这个对象的文档元素是<parsererror>,而文档元素的内容是对解析错误的描述。

比如讲上面的xml字符串中的root标签少写一个结束标签，就会返回一个文档元素是<parsererror>的document对象。

因为每个浏览器再解析XML发生错误时，反应不同，但都会返回一个<parsererror>元素，所以可以用一个try-catch语句块来检测是否解决错误：

    var parser=new DOMParser(),
          xmldom,
          errors;
      try{
            xmldom=parser.parseFromString("<root>","text/xml");//少一个root的结束标签，肯定会有错误
            errors=xmldom.getElementsByTagName("parsererror");
            if(errors.length>0){//应对firefox和opera
                  throw new Error("parsing error!");
            }
      }catch(ex){
            console.log("parseing error!");
      }

XMLSerializer类型：（将DOM转化为XML）

在引入DOMParser的同时，firefox还引入XMLSerializer类型，提供了相反的功能：将DOM文档序列化为XML字符串。后来IE9+、opera、chrome、safari都支持了XMLSerializer。

要序列化DOM文档，首先必须创建XMLSerialize的实例，然后将文档传入其XMLSerializeToString（）方法，例：

    var parser=new DOMParser();
      var xmldom=parser.parseFromString("<root><child></child></root>","text/xml");

      var serializer=new XMLSerializer();
      var xml=serializer.serializeToString(xmldom);
      console.log(xml);

但是，serializerToString（）方法返回的字符串并不适合打印，因此看起来乱糟糟的。

XMLSerializer可以序列化任何有效的DOM对象，不仅包括个别的节点，也包括HTML文档，将HTML文档传入serializeToString（）以后，HTML文档将被视为XML文档，因此得到的代码也将是良好的。

如果将非DOM对象传入serializeToString（），会导致错误。

IE8之前的版本中的XML：

IE是第一个原生支持XML的浏览器，而这一支持是通过ActiveX对象实现的。为了便于左面应用程序开发人员处理XML，微软创建了MSXML库；但微软并没有针对javascript创建不同的对象，而只是让web开发人员能够通过浏览器访问相同的对象。

通过IE中的ActiveXObject类型可以在javascript中创建ActiveX对象的实例。同样，要创建一个XML文档的实例，也要使用ActiveXObject构造函数并为其传入一个表示XML文档版本的字符串。有6种不同的XML文档版本可以供选择。

Microsoft.XmlDom:	最初随同IE发布；不建议使用
MSXML2.DOMDocument:	为方便脚本处理而更新的版本，建议仅在特殊情况下作为后备版本使用。
MSXML2.DOMDocument.3.0:	为了再javascript中使用，这是最低的建议版本
MSXML2.DOMDocument.4.0:	在通过脚本处理时并不可靠，使用这个版本可能导致安全警告。
MSXML2.DOMDocument.5.0:	在通过脚本处理时并不可靠，使用这个版本可能导致安全警告。
MSXML2.DOMDocument.6.0:	通过脚本能够可靠处理的最新版本。

这6个版本中微软只推荐使用MSXML2.DOMDocument.6.0或MSXML2.DOMDocument.3.0前者是最新最可靠的版本，而后者是大多数windows操作系统都支持的版本。可以作为后备版本的MSXML2.DOMDocument，仅在IE5.5之前的浏览器开发时才有必要使用。

通过尝试创建每个版本的实例并观察是否有错误发生，可以确定哪个版本可用。例如：

    function createDocument(){
            if(typeof arguments.callee.activeXString!="string"){//严格模式会报错
                  var versions=["MSXML2.DOMDocument.6.0","MSXML2.DOMDocument.3.0","MSXML2.DOMDocument"],
                      i,
                      len;
                  for(i=0,len=versions.length;i<len;i++){
                        try{
                              new ActiveXObject(versions[i]);//不支持会报错
                              arguments.callee.activeXString=versions[i];
                              break;
                        }catch(ex){
                              //跳过
                        }
                  }
            }
            return new ActiveXObject(arguments.callee.activeXString);
      }

以上代码是在IE8之前创建适合的XML文档的版本的ActiveX对象的实例，返回一个对象；

要解析XML字符串，首先必须创建一个DOM文档，然后调用loadXML（）方法。新创建的XML文档完全是一个空文档，因而不能对其执行任何操作。为loadXML（）方法传入的XML字符串经解析之后会填充到DOM文档中：

    var xmldom=createDocument();
      xmldom.loadXML("<root><child></child></root>");
      console.log(xmldom.documentElement.tagName);//"root"
      console.log(xmldom.documentElement.firstChild.tagName);//"child"

      var anotherChild=xmldom.createElement("child");
      xmldom.documentElement.appendChild(anotherChild);
      var children=xmldom.getElementsByTagName("child");
      console.log(children.length);//2 

在新DOM文档中填充了XML内容之后，就可以像操作其它DOM文档一样操作它了（可以使用任何属性和方法）；

如果解析过程中出错，可以在parseError属性中找到错误信息。这个属性本身是一个包含多个属性的对象，每个属性都包含着有关解析错误的某一方面信息。

errorCode	错误类型的数值编码；在没有发生错误时值为0
filePos	文件中导致错误发生的位置
line	发生错误的行
linePos	发生错误的行中的字符
reason	对错误的文本解释
srcText	导致错误的代码
url	导致错误的文件的URL（如果有这个文件的话）

另外，parseError的valueOf（）方法返回errorCode的值，因此可以通过下列代码检测是否发生了解析错误

    if(xml.parseError!=0){
            console.log("parsing error occurred.");
      }

我们可以将这些信息组织起来给出更有价值的解释：

    if(xml.parseError!=0){
            console.log(
            "解析错误:"+ xmldom.parseError.errorCode+"\n"
            + "发生错误的行:"+xmldom.parseError.line+"\n"
            + "发生错误行中的字符:"+xmldom.parseError.linePos+"\n"
            + "错误解释:"+xmldom.parseError.reason
            );
      }

应该在调用loadXML（）之后、查询XML文档之前，检查是否发生了解析错误。

1.序列化XML

IE将序列化XML的能力内置在了DOM文档中。每个DOM节点都有一个xml属性，其中保存着表示该节点的XML字符串。例如：

    console.log(xmldom.xml);

2.加载XML文件：（从服务器加载）

IE中的XML文档对象也可以加载来自服务器的文件。与DOM3级中的功能类似，要加载XML文档必须与页面中运行的javascript代码来自同一台服务器。同样与DOM3级规范类似，加载文档的方式也可以分为同步和异步两种。要指定加载文档的方式，可以设置async属性，true表示异步，false表示同步（默认值为true）。例如：

    var xmldom=createDocument();
      xmldom.async=false;//同步加载

在确定了加载XML文档的方式之后，调用load（）启动下载过程，这个方法接收一个参数，即要加载的XML文件的URL。在同步方式下，调用load（）后可以立即检测解析错误并执行相关的XML处理，例如：

    var xmldom=createDocument();//创建ActiveX对象实例
      xmldom.async=false;//同步加载（规定加载方式）
      xmldom.load("example.xml");//指定远程URL
      if(xmldom.parseError!=0){
            //解析错误的处理，比如console出来错误原因
      }else{
　　　　　　　//对获取来的并解析好的xml文档进行操作
            console.log(xmldom.documentElement.tagName);//"root"
            console.log(xmldom.documentElement.firstChild.tagName);//"child"
            var anotherChild=xmldom.createElement("child");
            xmldom.documentElement.appendChild(anotherChild);
            var children=xmldom.getElementsByTagName("child");
            console.log(children.length);//2
            console.log(xmldom.xml);//序列化xml
      }

由于是以同步的方式处理XML文件，因此在解析完之前，代码不会继续执行，这样的变成工作要简单一点。虽然同步方式比较方便，但如果下载的时间太长，会导致程序反应很慢，因此在加载XML文档时，通常采用异步的方式。

在异步加载XML文件的情况下，需要XMLDOM文档的onreadystatechange事件指定处理程序。有4个就绪状态（ready state）

1：DOM正在加载数据；

2：DOM已经加载完数据；

3：DOM已经可以使用，但某些部分可能还无法访问。

4：DOM已经加载完成，完全可以使用；

在实际开发中，要关注的只有一个就绪状态：4.这个状态表示XML文件已经全部加载完毕，而且已经全部解析为DOM文档。通过XML文档的readyState属性可以取得其就绪状态。以一部方式加载XML文件的典型模式如下：

    var xmldom=createDocument();
      xmldom.async=true;
      xmldom.onreadystatechange=function(){
            if(xmldom.readyState==4){
                  if(xmldom.parseError!=0){
                        console.log(
                        "解析错误:"+ xmldom.parseError.errorCode+"\n"
                        + "发生错误的行:"+xmldom.parseError.line+"\n"
                        + "发生错误行中的字符:"+xmldom.parseError.linePos+"\n"
                        + "错误解释:"+xmldom.parseError.reason
                        );//最好都是英文
                  }else{
                        //操作xmldom文档
                  }
            }
      };
      xmldom.load("example.xml");//指定远程url

要注意的是：为onreadystatechange事件指定处理程序的语句，必须放在调用load（）方法的语句之前；这样才能确保在就绪状态变化时调用该事件梳理程序。另外，在事件处理程序内部还必须注意要使用XML文档变量的名称（xmldom），不能使用this对象。原因是ActiceX控件为为预防安全问题不允许使用this对象。当文档的就绪状态变为4时，就可以放心检测是否发生了解析错误，并在未发生错误的情况下处理XML了。

跨浏览器处理XML：（解析xml）

很少有开发人员能够有福气专门针对一款浏览器做开发。因此，编写能够跨浏览器处理XML的函数就成为了常见的需求。对解析XML而言，下面这个函数可以在所有4种主要浏览器中使用：

    function parseXml(xml){
            var xmldom=null;
            if(typeof DOMParser!="undefined"){//IE高版本和其它浏览器
                  xmldom=(new DOMParser()).parseFromString(xml,"text/xml");//创建xml文档并解析
                  var errors=xmldom.getElementsByTagName("parsererror");//检测是否解析错误
                  if(errors.length){//解析错误处理
                        throw new Error("XML parsing error:"+errors[0].textContent);
                  }
            }else if(typeof ActiveXObject!="undefined"){//IE8之前版本
                  xmldom=createDocument();
                  xmldom.loadXML(xml);
                  if(xmldom.parseError!=0){//解析错误处理
                        throw new Error("XML parsing error:"+xmldom.parseError.reason);
                  }
            }else{
                  throw new Error("NO XML parser available");
            }
            return xmldom;
      }

在使用以上方法解析XML字符串时，应该放在try-catch块儿中，以防发生错误，来看下面的例子：

    var xmldom=null;
      try{
            xmldom=parseXml("<root><child></child></root>");
      }catch(ex){
            console.log(ex.message);
      }
      //进一步处理

跨浏览器序列化XML：

    function serializeXml(xmldom){
            if(typeof XMLSerializer!="undefined"){
                  return (new XMLSerializer()).serializeToString(xmldom);
            }else if(typeof xmldom.xml!="undefined"){//IE8以前版本
                  return xmldom.xml;
            }else {
                  throw new Error("could not serialize XML DOM");
            }
      }

浏览器对XPath的支持：

XPath是设计用来在DOM文档中查找节点的一种手段，因而对XML的处理也很重要。但是DOM3级以前的标准并没有就XPath的API作出规定；XPath是在DOM3级XPath模块中首次跻身推荐标准行列的。很多浏览器都实现了这个推荐标准，但IE则以自己的方式实现了XPath。

DOM3级XPath规范定义了再DOM中对XPath表达式求值的接口。要确定某浏览器是否支持DOM3级XPath，可以使用下列javascript代码：

    var supportsXPath=document.implementation.hasFeature("XPath","3.0");
      console.log(supportsXPath);//true

在DOM3级XPath规范定义的类型中，最重要的两个类型是XPathEvaluator和XPathResult。

XPathEvaluator用于在特定的上下文中对XPath表达式求值。这个类型有下列3个方法。

createExpression（expression，nsresolve）：	将XPath表达式及相应的命名空间信息转换成一个XPathExpression，这是查询的编译版。在多次使用同一个查询时很有用。
createNSResolver（node）：	根据node命名空间信息创建一个新的XPathNSResolve对象，在基于使用命名空间的XML文档求值时，需要使用XPathNSResolve对象。
evaluate（expression，context，nsresolver，type，result）：	在给定的上下文中，基于特定的命名空间信息来对XPath表达式求值。剩下的参数指定如何返回结果。

在firefox、safari、chrome、opera中，document类型通常都是与XPathEvaluator接口一起实现的。换句话说，在这些浏览器中，既可以创建XPathEvaluator的新实例，也可以使用Document实例中的方法（XML或HTML文档均是如此）。

在上面这三个方法中，evaluator（）是最常用的。这个方法接收5个参数：XPath表达式、上下文节点、命名空间求解器、返回结果的类型和保存结果的XPathResult对象（通常是null，因为结果也会以函数值的形式返回）。其中，第三个参数（命名空间求解器）只在XML代码中使用了XML命名空间时有必要指定；如果XML代码中没有指定命名空间，则这个参数应该指定为null。第4个参数（返回结果的类型）的取值范围是下列常量之一：

XPathResult.ANY_TYPE:	返回与XPath表达式匹配的数据类型
XPathResult.NUMBER_TYPE:	返回数值
XPathResult.STRING_TYPE:	返回字符串值
XPathResult.BOOLEAN_TYPE:	返回布尔值
XPathResult.UNORDERED_NODE_ITERATOR_TYPE:	返回匹配的节点集合，集合中节点的次序与他们在文档中的次序不一致
XPathResult.ORDERED_NODE_ITERATOR_TYPE:	返回匹配的节点集合，集合中节点的次序与他们在文档中的次序一致，这是最常用的结果类型
XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE:	返回节点集合的快照，由于是在文档外部捕获节点，因此对文档的后续操作不会影响到这个节点的集合，集合中节点的次序不一定与他们在文档中的次序一致
XPathResult.ORDERED_NODE_SNAPSHOT_TYPE:	返回节点集合的快照，由于是在文档外部捕获节点，因此对文档的后续操作不会影响到这个节点的集合，集合中节点的次序与他们在文档中的次序一致
XPathResult.ANY_UNORDERED_NODE_TYPE:	返回匹配的节点集合，但集合中的节点次序不一定与他们在文档中的节点次序一致
XPathResult.FIRST_ORDERED_NODE_TYPE:	返回只包含一个节点的节点集合，包含的这个节点就是文档中第一个匹配的节点

指定的结果类型决定了如何取得结果的值。来看一个例子：

    var result=xmldom.evaluate("employee/name",xmldom.documentElement,null,XPathResult.ORDERED_NODE_ITERATOR_TYPE,null);
      if(result!=null){
            var element=result.iterateNext();
            while(element){
                  console.log(element.tagName);
                  node=result.iterateNext();
            }
      }

上述例子返回最常用的结果类型，返回匹配表达式的结果且次序与文档保持一致。。如果没有节点匹配XPath表达式，evaluate（）返回null；否则它返回一个XPathResult对象。这个XPathResult对象带有的属性和方法，可以用来取得特定类型的结果。如果节点是一个节点迭代器，无论是次序一致还是次序不一致，都必须要使用iteratorNext（）方法从节点中取得匹配的节点。在没有更多匹配节点时，iteratorNext（）返回null；

如果指定的是快照结果类型（不管是次序一致还是次序不一致），就必须使用snapshotItem（）方法和snapshotLength属性，例如：

    var result=xmldom.evaluate("employee/name",xmldom.documentElement,null,XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,null);
      if(result!==null){
            for(var i=0,len=result.snapshotLength;i<len;i++){
                  console.log(result.snapshotItem());
            }
      }

1.单节点结果：

指定常量XPathResult.FIRST_ORDERED_NODE_TYPE会返回第一个匹配的节点，可以通过结果的singleNodeValue属性来访问该节点。例如：

    var result=xmldom.evaluate("employee/name",xmldom.documentElement,null,XPathResult.FIRST_ORDERED_NODE_TYPE,null);
      if(result!==null){
            console.log(result.singleNodeValue.tagName);
      }

与前面的查询一样，在没有匹配节点的情况下，evaluate（）返回null。如果有结果返回，那么久可以通过singleNodeValue来访问它。

2.简单类型结果：

通过XPath也可以取得简单的非节点数据类型，这时候就要使用XPathResult的布尔值、数值、和字符串类型了。这几个结果类型分别会通过booleanValue、numberValue、stringValue属性返回一个值。对于布尔值类型，如果有一个节点与XPath表达式匹配，则求职结果为true，否则返回false。例如：

    var result=xmldom.evaluate("employee/name",xmldom.documentElement,null,XPathResult.BOOLEAN_TYPE,null);
      console.log(result.booleanValue);

对于数值类型，必须在XPath表达式参数的位置上指定一个能返回数值的XPath函数，例如计算与给定模式匹配的所有节点数量count（）。例如：

    var result=xmldom.evaluate("count(employee/name)",xmldom.documentElement,null,XPathResult.NUMBER_TYPE,null);
      console.log(result.numberValue);

以上代码会输出与“employee/name”匹配的节点数量（即2）。如果使用这个方法的时候没有指定与前例类似的XPath函数，那么numberValue的值将等于NaN.

对于字符串类型，evaluate（）方法会查找与XPath表达式匹配的第一个节点，然后返回其第一个子节点的值（实际上是假设第一个子节点为文本节点）。如果没有匹配的节点，结果就是一个空字符串。例如：

    var result=xmldom.evaluate("employee/name",xmldom.documentElement,null,XPathResult.STRING_TYPE,null);
      console.log(result.stringValue);

3.默认结果类型：

所有XPath表达式都会自动映射到特定的结果类型。像前面那样设置特定的结果类型，可以限制表达式的输出。而使用XPathResult.ANY_TYPE常量可以自动确定返回结果的类型。一般来说，自动选择的结果类型可能是布尔值、数值、字符串、或一个次序不一致的节点迭代器。要确定返回的是什么结果类型，可以检测结果的resultType属性，如下面的例子所示。

    var result=xmldom.evaluate("employee/name",xmldom.documentElement,null,XPathResult.ANY_TYPE,null);
      if(result !==null){
            switch(result.resultType){
                  case XPathResult.STRING_TYPE:
                        //处理字符串类型
                        break;
                  case XPathResult.NUMBER_TYPE:
                        //处理数值类型
                        break;
                  case XPathResult.BOOLEAN_TYPE:
                        //处理布尔值类型
                        break;
                  case XPathResult.UNORDERED_NODE_ITERATOR_TYPE:
                        //处理次序不一致的节点迭代器类型
                        break;
                  default:
                        //处理其他可能的结果类型
            }
      }

显然，XPathResult.ANY_TYPE可以让我们更灵活地使用XPath，但是却要求有更多的处理代码来处理返回的结果。

4.命名空间的支持：

对于利用了命名空间的XML文档，XPathEvaluator必须知道命名空间信息，然后才能正确地进行求值。处理命名空间的方法也不止一种。我们以下面的XML代码为例：

    <?xml version="1.0" ?>
      <wrox:books xmlns:wrox="http://www.wrox.com/">
            <wrox:book>
                  <wrox:title>professionnal Javascript for web Developers</wrox:title>
                  <wrox:author>Nicholas C. Zakas</wrox:author>
            </wrox:book>
            <wrox:book>
                  <wrox:title>professionnal Ajax</wrox:title>
                  <wrox:author>Nicholas C. Zakas</wrox:author>
                  <wrox:author>Jeremy Mcpeak</wrox:author>
                  <wrox:author>Joe Fawcett</wrox:author>
            </wrox:book>
      </wrox:books>

正在这个XML文档中，所有的元素定义都来自http://www.wrox.com/命名空间，以前缀wrox标识。如果要对这个文档使用XPath，就需要定义要使用的命名空间；否则求值将会失败。

　　处理命名空间的第一种方法是通过createNSResolver（）来创建XPathNSResolver对象，这个方法接收一个参数，即文档中包含命名空间定义的节点。对于前面的XML文档来说，这个节点就是文档元素<wrox:books>，它的xmlns特性定义了命名空间。可以把这个节点传递给createNSResolver（），然后可以像下面这样在evaluate（）中使用返回的结果：

    var nsresolver=xmldom.createNSResolver(xmldom.documentElement);//XML的文档元素
      var result=xmldom.evaluate("wrox:book/wrox:author",xmldom.documentElement,nsresolver,XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,null);
      console.log(result.snapshotLength);

在将nsresolver对象传入到evaluate（）之后，就可以确保它能够理解XPath表达式中使用的wrox前缀。读者可以试一试使用相同的表达式，如果不使用XPathNSResolver的话，就会导致错误。

　　处理命名空间的第二种方法就是定义一个函数，让它接收一个命名空间前缀，返回关联的URI，例如：

    var nsresolver=function(prefix){
            switch(prefix){
                  case "wrox": return "http://www.wrox.com";
                  //其它前缀
            }
      }
      var result=xmldom.evaluate("count(wrox:book/wrox:author)",xmldom.documentElement,nsresolver,XPathResult.NUMBER_TYPE,null);
      console.log(result.numberValue);

在不确定文档中的哪个节点包含命名空间定义的情况下，这个命名空间解析函数就可以派上用场了。只要你知道前缀和URI，就可以定义一个返回该信息的函数，然后将它作为第三个参数传递给evaluate（）即可。

IE中的XPath：

IE对XPath的支持是内置在基于ActiveX的XML DOM文档对象中的，没有使用DOMParser返回的DOM对象。因此，为了再IE9及之前版本中使用XPath，必须使用基于ActiveX的实现。这个借口在每个节点上额外定义了两个方法：selectSingleNode（）和selectNodes（）。其中，selectSingleNode（）方法接收一个XPath模式，在找到匹配节点时返回第一个匹配的的节点，如果没有找到匹配的节点就返回null。例如：

    var element=xmldom.documentElement.selectSingleNode("employee/name");
      if(element!=null){
            console.log(element.xml);//序列化
      }

这里，会返回匹配“employee/name”的第一个节点。上下文节点是xmldom.documentElement，因此就调用了该节点的selectSingleNode（）。

另一个方法selectNodes（）也接收一个XPath模式作为参数，但他返回与模式匹配的所有节点的NodeList（如果没有匹配的节点，则返回一个包含0项的NodeList）。例如：

    var elements=xmldom.documentElement.selectNodes("employee/name");
      console.log(elements.length);

无论有没有匹配的节点都会返回NodeList，但是其包含的元素可能会动态改变，所以每次访问它都有可能得到不同的结果。

IE对命名空间的支持：

要在IE中处理包含命名空间的XPath表达式，你必须知道自己使用的命名空间，并按照下列格式创建一个字符串：

    "xmlns:prefix1='uri1' xmlns:prefix2='uri2' xmlns:prefix3='uri3'"

然后，必须将这个字符串传入到XML DOM文档对象的特殊方法setProperty（）中，这个方法接收两个参数：要设置的属性名和属性值。在这里，属性名应该是"SelectionNameSpaces",属性值就是按照前面的格式创建的字符串。下面来看一个在DOM Xpath命名空间中对XML文档求值的例子：

    xmldom.setproperty("selectionNameSpaces","xmlns:wrox='http://www.wrox.com/'");
      var result=xmldom.documentElement.selectNodes("wrox:book/wrox:author");
      console.log(result.length);

对于这个DOM XPath的例子来说，如果不提供命名空间解析信息，就会在对表达式求值时导致一个错误。

跨浏览器使用XPath：

鉴于IE对XPath功能的支持有限，因此跨浏览器XPath只能保证达到IE支持的功能。换句话说，也就是要在其它使用DOM3级XPath对象的浏览器中，重新创建selectSingleNode（）和selectNodes（）方法。第一个函数是selectSingleNode（），它接收三个参数：上下文节点、XPath表达式和可选的命名空间对象。命名空间对象应该是下面这种字面量形式：

    var namespaces={
            prefix1:"uri1",
            prefix2:"uri2",
            prefix3:"uri3"
      }

以这种方式提供的命名空间信息，可以方便的转换为针对特定浏览器的命名空间解析格式。下面给出了selectSingleNode（）函数的完整代码：

    function selectSingleNode(context,expression,namespaces){
            var doc=(context.nodeType!=9?context.ownerDocument:context);//确定文档类型是XML
            if(typeof doc.evaluate!="undefined"){//确定有evaluate函数
                  var nsresolver=null;
                  if(namespaces instanceof Object){//确定namespaces是object类型
                        nsresolver=function(prefix){
                              return namespaces[prefix];
                        }
                  }
                  var result = doc.evaluate(expression,context,nsresolver,XPathResult.FIRST_ORDERED_NODE_TYPE,null);
                  return (result!=null?result.singleNodeValue:null);
            }else if(typeof context.selectSingleNode!="undefined"){//IE9之前
                  //创建命名空间字符串
                  if(namespaces instanceof Object){//确定namespaces是object类型
                        var ns="";
                        for(var prefix in namespaces){
                              if(namespaces.hasOwnProperty(prefix)){
                                    ns+="xmlns:"+prefix+"='"+namespaces[prefix]+"'";
                              }
                        }
                        doc.setproperty("SelectionNamespaces",ns);
                  }
                  return context.selectSingleNode(expression);
            }else{
                  throw new Error("No XPath engine found.");
            }
      }

以下是使用selectSingleNode（）函数的事例：

    var result=selectSingleNode(xmldom.documentElement,"wrox:book/wrox:author",{wrox:"http://www.wrox.com/"});
      console.log(serializeXml(result));//将xml转化为dom

类似的，也可以创建一个跨浏览器的selectNodes（）函数，这个函数同样接收三个参数：上下文节点、XPath表达式、可选的命名空间对象；

    function selectNodes(context,expression,namespaces){
            var doc=(context.nodeType!=9?context.ownerDocument:context);
            if(typeof doc.evaluate!="undefined"){
                  var nsresolver=null;
                  if(namespaces instanceof Object){
                        nsresolver=function(prefix){
                              return namespaces[prefix];
                        }
                  }
                  var result=doc.evaluate(expression,context,nsresolver,XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,null);
                  var nodes=new Array();
                  if(result!==null){
                        for(var i=0,len=result.snapshotLength;i<len;i++){
                              nodes.push(result.snapshotItem(i));
                        }
                  }
                  return nodes;
            }else if(typeof context.selectNodes!="undefined"){
                  //创建命名空间字符串
                  if(namespaces instanceof Object){
                        var ns="";
                        for(var prefix in namespaces){
                              if(namespaces.hasOwnProperty(prefix)){
                                    ns+="xmlns:"+prefix+"='"+namespaces[prefix]+"' ";
                              }
                        }
                        doc.setproperty("SelectionNamespaces",ns);
                  }
                  var result=context.selectNodes(expression);
                  var nodes=new Array();
                  for(var i=0,len=result.length;i<len;i++){
                        nodes.push(result[i]);
                  }
                  return nodes;
            }else{
                  throw new Error("No XPath engine found.");
            }
      }

使用事例：

    var result=selectNodes(xmldom.documentElement,"wrox:book/wrox:author",{wrox:"http://www.wrox.com"});
      console.log(result.length);

为了求得最佳的浏览器兼容性，建议再javascript中使用XPath时，只考虑着两个方法。

浏览器对XSLT的支持：

先来了解一下什么是XSLT，在了解XSLT之前，的先了解XSL，xsl是xml的样式表，可以比喻成css是html的样式表，只是使用起来有些不同，而XSLT，则用来将xml装换成不同格式的xml文档，比如XHTML、HTML等。（具体可以上w3cschool来具体了解，讲的很详细，而且很快可以了解一遍）。

DOM中并没有实现XSLT，只有浏览器开发商来实现，不过也可以通过javascript来使用XSLT.

1.简单的XSLT转换

使用XSLT样式表转换XML文档的最简单的方式，就是将它们分别加到一个DOM文档中，然后再使用transformNode（）方法。这个方法存在与文档的所有节点中，它接受一个参数，即包含XSLT样式表的文档。调用transformNode（）方法会返回一个包含你转换信息的字符串。例如：

    //加载XML和XSLT（仅限于IE）
      xmldom.load("employees.xml");
      xsltdom.load("employees.xslt");
      //转换
      var result = xmldom.transformNode(xsltdom);

以上例子加载了一个XML的DOM文档和一个XSLT样式表的DOM文档。然后在XML文档节点上调用了transformNode（）方法，并传入XSLT。变量result中最后就会保存一个转换之后得到的字符串。需要注意的是，由于是在文档节点上调用的transformNode（），因此转换是从文档节点开始的。实际上，XSLT转换可以在文档的任何级别上进行，只要在想要开始转换的节点上调用transformNode（）方法即可。比如：

    result=xmldom.documentElement.transformNode(xsltdom);
      result=xmldom.documentElement.childNodes[1].transformNode(xsltdom);
      result=xmldom.getElementsByTagName("name")[0].transformNode(xsltdom);
      result=xmldom.documentElement.firstChild.lastChild.transformNode(xsltdom);

2.复杂的XSLT转换

当使用这种语言的更复杂的方式时，必须要使用XSL模板和XSL处理器。第一步要把XSLT样式表加载到一个线程安全的XML文档中。而这可以通过使用Active对象MSXML2.FreeThreadedDocument来做到。这个ActiveX对象与IE中常规的DOM支持相同的接口。此外，创建这个对象时应该尽可能使用最新版本。例如：

略略略。。。看w3c更详细。。。

3.跨浏览器使用XSLT

只能返回结果是字符串

    function transform(context,xslt){
            if(typeof XSLTProcessor!="undefined"){
                  var processor=new XSLTProcessor();
                  processor.importStylesheet(xslt);
                  var result=processor.transformToDocument(context);
                  return (new XMLSerializer()).serializeToString(result);
            }else if(typeof context.transformNode!="undefined"){
                  return context.transformNode(context);
            }else {
                  throw new Error("No XSLT processor available");
            }
      }

这个方法接收两个参数，上下文节点和XSLT文档对象