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中的包的概念，很有层次感，以后尽量用此方式定义类了。