XML的DOM解析脚本

最近一直在做javascript的东东，需要解析xml文件在所难免，于是在网上找了许多例子，发现的确是比我写的要好些：

1）我原自己写的解析类：JSDomParse

/**
 *Description:JSDomParse 解析XMLDom对象
 *JSDomParse
 *2008.11.17
*/
function JSDomParse(){}

// 通过text类型xml字符串生成dom对象
JSDomParse.create_XMLDOM = function( vStrXML ){
 try{
  if( typeof ActiveXObject != "undefined" ){  
   var uXMLDom = new ActiveXObject("Microsoft.XMLDOM");
   uXMLDom.loadXML( vStrXML );
   return uXMLDom;
  }else{
   alert("无法创建XML对象....");
   return null;
  }
 }catch(e){
  alert("初始化XML解析器错误!" + e);
  return null;
 }
}

// 根据vStrNodeName获得节点集合
JSDomParse.get_Nodes = function( vNode, vStrNodeName ){
 if( vNode == null) return "";
 var x = vNode.getElementsByTagName( vStrNodeName );
 return x;
}

// 获得第一个节点类型为node的子节点
JSDomParse.get_FirstChildNode = function( vNode ){
 if( vNode == null) return "";
 var x = vNode.firstChild;
 while ( x.nodeType != 1 )
 {
    x = x.nextSibling;
 }
 return x;
}
// 获得最后一个节点类型为node的子节点
JSDomParse.get_LastChildNode = function( vNode ){
 if( vNode == null) return "";
 var x = vNode.lastChild;
 while ( x.nodeType != 1)
 {
 x = x.previousSibling;
 }
 return x;
}

// 获得节点中所有的文本值
JSDomParse.get_NodeValue = function( vNode ){
 if( vNode == null) return "";
 var uNodeList = vNode.childNodes;
 var x = "";
 for(var i=0; i<uNodeList.length; i++){
  x += uNodeList.item(i).nodeValue;  
 } 
 return x;

}

// 获得节点列中第一个子节点值
JSDomParse.get_FirstChildNodeValue = function( vNodeList ){
 if( vNodeList == null) return "";
 else{ // 一个NodeList
  if( vNodeList.length > 0){
   return JSDomParse.get_NodeValue( vNodeList.item(0) );
  }else{
   return "";
  }
 }
}

// 获得节点列中最后一个子节点值
JSDomParse.get_LastChildNodeValue = function( vNodeList ){
 if( vNodeList == null) return "";
 else{ // 一个NodeList
  if( vNodeList.length > 0){
   return JSDomParse.get_NodeValue( vNodeList.item( vNodeList.length - 1 ) );
  }else{
   return "";
  }
 }
}

2）在网上找了个例子，然后改造了些：

// xmlDomParse.js

var DOM_ELEMENT_NODE = 1;
var DOM_ATTRIBUTE_NODE = 2;
var DOM_TEXT_NODE = 3;
var DOM_CDATA_SECTION_NODE = 4;
var DOM_ENTITY_REFERENCE_NODE = 5;
var DOM_ENTITY_NODE = 6;
var DOM_PROCESSING_INSTRUCTION_NODE = 7;
var DOM_COMMENT_NODE = 8;
var DOM_DOCUMENT_NODE = 9;
var DOM_DOCUMENT_TYPE_NODE = 10;
var DOM_DOCUMENT_FRAGMENT_NODE = 11;
var DOM_NOTATION_NODE = 12;

var ez_xmlDomParse = {
 /**
  * http://developer.mozilla.org/en/docs/DOMParser
  * 接受一段xml，解析成为xml document对象
  * 调用时可用try{}catch(e){}捕捉错误，错误对象具有parser xml message属性
  * @param {String} xml string
  * @return {Object} xml document object
  */
 xmlDocument : function (/* String */xmlString){
  var doc = null;

  if (window.ActiveXObject){
   var ActiveIds = ['MSXML2.XMLDOM', 'Microsoft.XMLDOM', 'MSXML.XMLDOM', 'MSXML3.XMLDOM'];
   for (var len = ActiveIds.length, i = 0; i < len; i++){
    var id = ActiveIds[i];
    try{
     var doc = new ActiveXObject(id);
     doc.async = false;
     doc.setProperty('SelectionLanguage', 'XPath');
     doc.loadXML(xmlString);
     break;
    }catch (e){}finally{
     if (doc && doc.parseError && doc.parseError.errorCode != 0){
      throw {parser:'MSXML', message:doc.parseError.reason, xml:xmlString, func:'xmlDocument'};
     }
    }
   }
  }else if (typeof DOMParser != 'undefined'){
   var parser = new DOMParser();
   var doc = parser.parseFromString(xmlString, 'text/xml');
   if (doc.documentElement.nodeName == 'parsererror'){
    throw {parser:'DOMParser', message:doc.documentElement.firstChild.nodeValue, xml:xmlString, func:'xmlDocument'};
   }
  }else{ return false; }

  return doc;
 },
 /**
  * 获取指定节点或文档对象的xml内容
  * port from ajaxslt xmlText()
  * @param {Object} xml DOM Node or xml Document
  * @return {String} xml string
  */
 xmlText : function (/* Document|Element */node){
  if (typeof node == 'string'){ return node; }

  if (node.innerXML){
   return node.innerXML;
  }else if (node.xml){
   return node.xml;
  }else if (typeof XMLSerializer != 'undefined'){
   return (new XMLSerializer()).serializeToString(node);
  }else{ return false; }
 },
 /**
  * 获取所有节点的内容
  * port from ajaxslt xmlValue()
  * @param {Object} xml DOM Node or xml Document
  * @return {String}
  */
 xmlValue : function (/* Document|Element */node){
  var val = '';
  if (node.nodeType == DOM_TEXT_NODE ||
   node.nodeType == DOM_CDATA_SECTION_NODE ||
   node.nodeType == DOM_ATTRIBUTE_NODE){
   val += node.nodeValue;
  }else if (node.nodeType == DOM_ELEMENT_NODE ||
      node.nodeType == DOM_DOCUMENT_NODE ||
      node.nodeType == DOM_DOCUMENT_FRAGMENT_NODE){
   for (var len = node.childNodes.length, i = 0; i < len; i++){
    val += arguments.callee(node.childNodes[i]);
   }
  }
  return val;
 },
 /**
  * 获取节点属性，以对象形式返回
  * @param {Object}
  * @return {Object}
  */
 xmlGetAttributes : function (/* Element */node){
  var result = {};
  var nodeMap = node.attributes;
  if (nodeMap){
   for (var len = nodeMap.length, i = 0; i < len; i++){
    var aNode = nodeMap.item(i);
    result[aNode.nodeName] = aNode.nodeValue;
   }
  }
  return result;
 },
 /**
  * 设置节点属性
  * @param {Object} xml DOM Node
  * @param {Object} attribute data as object type
  * @return {Void}
  */
 xmlSetAttributes : function (/* Element */node, /* Object */attributes){
  var attributes = attributes || {};
  for (key in attributes){
   node.setAttribute(key, attributes[key]);
  }
 },
 /**
  * 使用xpath在xml树中查询
  * http://developer.mozilla.org/en/docs/Introduction_to_using_XPath_in_JavaScript
  * @param {Object} xml Document or xml DOM Node
  * @param {String} xpath query string
  * @param {Boolean} if set true, only return first result node
  * @return {Mixed} return array include all nodes or first node
  */
 xpathSelectNodes : function (/* Document|Element */root, /* String */query, /* Boolean */returnFirst){
  if (window.ActiveXObject){
   return returnFirst ? root.selectSingleNode(query) : root.selectNodes(query);
  }else if (document.evaluate){
   /**
    * DOMParser的return type有ordered和unordered两种
    * ordered会按照树中间的顺序排列结果，unordered不一定
    * 另外还有一种snapshots的，这种结果是树节点的一个clone
    * 也就是说，如果操作结果节点，原来的节点不会有改变
    * 这里使用非clone方式
    */
   var returnType = returnFirst ? XPathResult.FIRST_ORDERED_NODE_TYPE : XPathResult.ORDERED_NODE_ITERATOR_TYPE;
   var doc = (root.nodeType == DOM_DOCUMENT_NODE) ? root : root.ownerDocument;
   var root = (root.nodeType == DOM_DOCUMENT_NODE) ? root.documentElement : root;
   var result = doc.evaluate(query, root, null, returnType, null);

   if (returnFirst){
    var nodes = result.singleNodeValue;
   }else{
    var nextNode = result.iterateNext();
    var nodes = [];
    while (nextNode){
     nodes.push(nextNode);
     nextNode = result.iterateNext();
    }
   }
  }
  return nodes;
 },
 /**
  * http://developer.mozilla.org/en/docs/Transforming_XML_with_XSLT
  * http://developer.mozilla.org/en/docs/Using_the_Mozilla_JavaScript_interface_to_XSL_Transformations
  * @param {Mixed} source xml, xml string or xml Document or xml DOM Node
  * @param {Mixed} xslt style sheet, xml string or xml Document or xml DOM Node
  * @param {Boolean} if set true, return processed xml as Document
  * @return {Mixed} return string or Document
  */
 xsltProcess : function (/* String|Document|Element */srcDoc, /* String|Document|Element */stylesheet, /* Boolean */returnAsDoc){
  var returnAsDoc = (typeof returnAsDoc == 'undefined') ? false : returnAsDoc;
  try{
   var srcDoc = (typeof srcDoc == 'string') ? xmlDocument(srcDoc) : srcDoc;
   var stylesheet = (typeof stylesheet == 'string') ? xmlDocument(stylesheet) : stylesheet;
  }catch(e){ e.func = 'xsltProcess'; throw e; }

  if (typeof XSLTProcessor != 'undefined'){
   var processor = new XSLTProcessor();
   try{
    processor.importStylesheet(stylesheet);
    var dest = processor.transformToDocument(srcDoc);
    return returnAsDoc ? dest : xmlText(dest);
   }catch(e){ throw {func:'xsltProcess', processor:'XSLTProcessor', xml:xmlText(srcDoc), xslt:xmlText(stylesheet)}; }
  }else if (window.ActiveXObject){
   try{
    var dest = srcDoc.transformNode(stylesheet);
    return returnAsDoc ? xmlDocument(dest) : dest;
   }catch(e){ throw {func:'xsltProcess', processor:'MSXML', xml:xmlText(srcDoc), xslt:xmlText(stylesheet)}; }
  }

  return false;
 }
}

总结：

     1）中JSDomParse和2）中的ez_xmlDomParse纯粹是为了当命名空间来用。因为公司以前的代码由于确实命名空间，发现很多问题，所以偶都有阴影了。

现在发现用json格式（也就是2）中的描述风格）写类有很多好处，最外层的ez_xmlDomParse相当于java中的包的概念，很有层次感，以后尽量用此方式定义类了。