Javascript XML 操作类 - 仿.Net XML API

Javascript XML 操作类 仿照.Net XMLDocument 类 API 在firefox 与 ie 下测试通过,类继承机制的实现可以换成自己的方法,这里没有提供.

/*******************************************************************

* Yabin Write by 2007.9.19

* XML 操作类基类

********************************************************************/

var _XmlOperaterBase=function(){}

_XmlOperaterBase.prototype._init=function()

{

this._doc = this.createXMLDoc("root");

if(this._doc!=null)

this._doc.async=false;

}

/*虚函数，派生类必需重载*/

_XmlOperaterBase.prototype.createXMLDoc=function()

{

return null;

}

_XmlOperaterBase.prototype.appendTextNode=function(xmlNode,text)

{

var nodeText = this._doc.createTextNode(text);

xmlNode.appendChild(nodeText);

}

/// <summary>

/// 生成一个节点属性对象

/// </summary>

/// <param name="OwnerDocument">根文档对象</param>

/// <param name="strName">属性名称</param>

/// <param name="strValue">属性值</param>

/// <returns></returns>

_XmlOperaterBase.prototype.createNodeAtt=function(strName,strValue)

{

var att = this._doc.createAttribute(strValue);

att.value=strValue;

return att;

}

_XmlOperaterBase.prototype.createNode=function(strNodeName)

{

return this._doc.createNode(1, strNodeName,"");

}

/// <summary>

/// 为节点对象增加属性

/// </summary>

/// <param name="xmlNode"></param>

/// <param name="strNodeName"></param>

/// <param name="strValue"></param>

/// <returns></returns>

_XmlOperaterBase.prototype.setNodeAtt=function(xmlNode,strNodeName,strValue)

{

xmlNode.setAttribute(strNode,strValue);

}

/// <summary>

/// 获取一个节点的某一个属性

/// </summary>

/// <param name="xmlNode"></param>

/// <param name="strNodeName"></param>

/// <param name="strDefaultValue"></param>

/// <returns></returns>

_XmlOperaterBase.prototype.getNodeAttValue=function(xmlNode,strAttName,strDefaultValue)

{

var strValue = xmlNode.getAttrribute(strAttName);

if(strValue==null)

strValue =strDefaultValue;

return strValue;

}

/// <summary>

/// 得到一个节点的属性转换为HAS

/// </summary>

/// <param name="xmlNode"></param>

/// <returns></returns>

_XmlOperaterBase.prototype.getNodeAttToHashtable=function(xmlNode)

{

var valHas = new HBHashtable();

for(var i=0;i<xmlNode.attributes.length;i++)

{

var sName = xmlNode.attributes[i].name;

var sValue = xmlNode.attributes[i].value;

valHas.put(sName,sValue);

}

return valHas;

}

/// <summary>

/// 得到NODELIST对象所有节点属性到HASLIST对象

/// </summary>

/// <param name="xmlNodeList"></param>

/// <returns></returns>

_XmlOperaterBase.prototype.getNodeListAttToHashtableList=function(xmlNodeList)

{

var listHas = new Array();

for(var i=0;i<xmlNodeList.length;i++)

{

var attHas = this.getNodeAttToHashtable(xmlNodeList[i]);

listHas.push(attHas);

}

return listHas;

}

/// <summary>

/// 为节点对象加入子节点并为子节点批量创建属性

/// </summary>

/// <param name="xmlNode"></param>

/// <param name="strNodeName"></param>

/// <param name="attHas">属性HAS对象</param>

/// <returns></returns>

_XmlOperaterBase.prototype.appendNode=function(xmlNode,strNodeName,attHas)

{

var newNode = this.createNode(strNodeName);

if(attHas instanceof HBHashtable)

this.appendNodeAttByHas(newNode,attHas);

xmlNode.appendChild(newNode);

return xmlNode;

}

/// <summary>

/// 为节点批量创建属性

/// </summary>

/// <param name="xmlNode"></param>

/// <param name="valHas"></param>

/// <returns></returns>

_XmlOperaterBase.prototype.appendNodeAttByHas=function(xmlNode,valHas)

{

for(var i=0;i<valHas.count();i++)

{

var key = valHas.findKey(i);

var value = valHas.get(key);

this.setNodeAtt(xmlNode,key,value);

}

return xmlNode;

}

/// <summary>

/// 批量删除节点属性

/// </summary>

/// <param name="xmlNode"></param>

/// <param name="strCollNodeNames">需要删除的属性集合</param>

_XmlOperaterBase.prototype.removeNodeAttByStrColl=function(xmlNode,strCollNodeNames)

{

for(var i=0;i<strCollNodeNames.count();i++)

{

xmlNode.removeAttribute(strCollNodeNames.getValue(i));

}

}

/// <summary>

/// 批量删除节点属性

/// </summary>

/// <param name="xmlNode"></param>

/// <param name="strAttColl">需要删除的属性字符串集合 simple:"id1|id2|id3|id4"</param>

_XmlOperaterBase.prototype.removeNodeAttByName=function(xmlNode,strAttColl)

{

if(strAttColl instanceof HBStringCollection)

{

this.removeNodeAttByStrColl(strAttColl);

}

}

/// <summary>

/// 查找节点并批量创建子节点并为子节点批量创建属性

/// </summary>

/// <param name="xmlNode"></param>

/// <param name="strCollNodeName">root|node|</param>

/// <param name="attHasList">属性HAS列表对象</param>

/// <param name="bIsCreateNode">是否创建节点</param>

/// <returns></returns>

_XmlOperaterBase.prototype.findNodeByNodeName=function(xmlNode,strCollNodeName,attHasList,bIsCreateNode)

{

if(typeof(strCollNodeName)=='string')

strCollNodeName = HBDataConvert.StringToStringCollection(strCollNodeName);

var childXmlNode = xmlNode;

var iAttHasListIndex = 0;

for (var i=0;i<strCollNodeName.count();i++)

{

var strValue = strCollNodeName.getValue(i);

var findXmlNode = childXmlNode.selectSingleNode("//" + strValue + "");

if (findXmlNode == null)

{

if (bIsCreateNode)

{

childXmlNode = this.appendNode(childXmlNode,strValue);

if (attHasList != null && attHasList.count() > 0 && attHasList.count() > iAttHasListIndex)

{

this.appendNodeAttByHas(childXmlNode, attHasList[iAttHasListIndex]);

iAttHasListIndex++;

}

}

else

return childXmlNode;

}

else

childXmlNode = findXmlNode;

}

return childXmlNode;

}

/*******************************************************************

* Yabin Write by 2007.9.21

* FireFox XML操作扩展

*

********************************************************************/

var _FFXmlOperater =function(){ this._init();}

_FFXmlOperater.inherits(_XmlOperaterBase);

_FFXmlOperater.prototype.transformXMLByXslFile=function(xmlDoc,XSLFilePath,paramHas)

{

var oParser = new DOMParser();

var oXmlDoc =this.createXMLDoc();

oXmlDoc.async = false;

if(typeof(xmlDoc)=='object')

XMLSource=xmlDoc;

else

{

if(xmlDoc.startWith('url:'))

oXmlDoc.load(xmlDoc.substring(4,xmlDoc.length).trim());

else

oXmlDoc.loadXML(xmlDoc);

}

var oXslDoc = this.createXMLDoc();

oXslDoc.async = false;

oXslDoc.load(XSLFilePath);

// 定义XSLTProcessor对象

var oXsltProcessor = new XSLTProcessor();

oXsltProcessor.importStylesheet(oXslDoc);

// transformToDocument方式

var result = oXsltProcessor.transformToDocument(oXmlDoc);

var oXmls = new XMLSerializer();

text = oXmls.serializeToString(result);

return text;

}

/// <summary>

/// 创建XML文档对象

/// </summary>

/// <returns></returns>

_FFXmlOperater.prototype.createXMLDoc=function(strRoot)

{

if(strRoot!=null && strRoot.length>0)

return document.implementation.createDocument("",strRoot, null);

else

return document.implementation.createDocument("","",null);

}

/*******************************************************************

* Yabin Write by 2007.9.21

* IE XML操作扩展

*

********************************************************************/

var _IEXmlOperater =function(){ this._init();}

_IEXmlOperater.inherits(_XmlOperaterBase);

_IEXmlOperater.prototype.transformXMLByXslFile=function(xmlDoc,XSLFilePath,paramHas)

{

try

{

var XSLStyleSheet;

var XMLSource;

var XSLTemplate;

var XSLProcessor;

XMLSource = new ActiveXObject("Msxml2.DOMDocument");

XMLSource.async = false;

XMLSource.resolveExternals = false;

if(typeof(xmlDoc)=='object')

XMLSource=xmlDoc;

else

{

if(xmlDoc.startWith('url:'))

XMLSource.load(xmlDoc.substring(4,xmlDoc.length));

else

XMLSource.loadXML(xmlDoc);

}

var XSLStyleSheet= new ActiveXObject("Msxml2.FreeThreadedDOMDocument");

// We cannot use the following lines, because templates must be created as 'FreeThreadedDOMDocument'

// In case we do not want to set parameters to the style sheet, we can use the code below and skip the rest

XSLStyleSheet.async = false;

XSLStyleSheet.load(XSLFilePath);

XSLStyleSheet.resolveExternals = false;

XSLTemplate= new ActiveXObject("Msxml2.XSLTemplate");

XSLTemplate.stylesheet= XSLStyleSheet;

XSLProcessor= XSLTemplate.createProcessor();

XSLProcessor.input = XMLSource;

// Set an optional parameter to the style sheet

if(paramHas!=null && paramHas.count()>0)

{

for(var i=0;i<paramHas.count();i++)

{

var key = paramHas.findKey(i);

var value = paramHas.get(key);

XSLProcessor.addParameter(key,value);

}

}

// Transform the XML source according to the appropriate style sheet

XSLProcessor.transform();

return XSLProcessor.output;

}

catch(e){alert(e);};

}

_IEXmlOperater.prototype.createXMLDoc=function(strRoot)

{

var aVersions = ["MSXML2.DOMDocument.5.0",

"MSXML2.DOMDocument.4.0","MSXML2.DOMDocument.3.0",

"MSXML2.DOMDocument","Microsoft.XmlDom"];

for (var i = 0; i < aVersions.length; i++)

{

try

{

var oXmlDom = new ActiveXObject(aVersions[i]);

if(strRoot!=null && strRoot.length>0)

{

oXmlDom.loadXML(String.format("<{0}></{0}>",strRoot));

if (oXmlDom.parseError.errorCode == 0)

return oXmlDom;

else

alert(oXmlDom.parseError);

}

return null;

}

catch (e){

}

}

throw new Error("MSXML is not installed.");

}

var XmlHelper;

if(Util.IsIE)

{

XmlHelper = new _IEXmlOperater();

}

else if(Util.IsFF)

{

var g_oEvaluator = new XPathEvaluator();

Element.prototype.selectNodes=function(sXPath)

{

var oResult = g_oEvaluator.evaluate(sXPath,this,null,

XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);

var nodes = new Array();

if (oResult != null)

{

var oElement;

while (oElement = oResult.iterateNext())

nodes.push(oElement);

}

return nodes;

}

Element.prototype.selectSingleNode=function(sXPath)

{

var xresult=g_oEvaluator.evaluate(sXPath,this,null,

XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,null);

if(xresult&&xresult.snapshotLength>0)

{

return xresult.snapshotItem(0);

}

else

{

return null;

}

}

XMLDocument.prototype.selectNodes=function(sXPath)

{

return this.documentElement.selectNodes(sXPath);

}

XMLDocument.prototype.selectSingleNode=function(sXPath)

{

return this.documentElement.selectSingleNode(sXPath);

}

var g_oParser = new DOMParser();

XMLDocument.prototype.loadXML=function(strXML)

{

try

{

var temp = g_oParser.parseFromString(strXML,"text/xml").documentElement;

this.removeChild(this.documentElement);

this.appendChild(temp);

}

catch(e){alert(e);}

}

XMLDocument.prototype.__defineGetter__

(

"xml",

function()

{

return this.documentElement.xml;

}

);

XMLDocument.prototype.__defineGetter__

(

"text",

function()

{

return this.documentElement.text;

}

);

var g_oXmlSerializer = new XMLSerializer();

XMLDocument.errorMessage=function()

{

if (this.firstChild.tagName == "parsererror")

{

var sXmlError = g_oXmlSerializer.serializeToString(oXmlDom);

var reError = "/>([/s/S]*?)Location:([/s/S]*?)Line Number (/d+),"+

"Column(/d+):<sourcetext>([/s/S]*?)(?:/-*/^)/";

reError.test(sXmlError);

return sXmlError;

}

else

return "";

}

Element.prototype.__defineGetter__

(

"xml",

function()

{

return g_oXmlSerializer.serializeToString(this);

}

);

Element.prototype.__defineGetter__

(

"text",

function()

{

try

{

return _getNodeText(this);

}

catch(e){}

function _getNodeText(oNode)

{

var sText = "";

for (var i = 0; i < oNode.childNodes.length; i++)

{

if (oNode.childNodes[i].hasChildNodes())

{

sText += _getNodeText(oNode.childNodes[i]);

}

else

{

sText += oNode.childNodes[i].nodeValue;

}

}

return sText;

}

}

);

XmlHelper = new _FFXmlOperater();

}