zdhsoft 阅读(55) 评论(0)

这里是基于node的xmldom上扩展的工具,在使用appium的时候,常常需要用source功能来分析当前上下文,所以扩展了若干函数,用于分析。

这些代码是基于node 6.9.x JavaScript ES6语法实现。(关于如何在node使用ES6的语法,请参考我的前文:js笔记四:node 6.9.x for gulp完整配置过程

完成代码如下:xml_utils.js

  1 import { DOMParser } from "xmldom";
  2 
  3 xml_utils = {};
  4 //------------------------------------------------------------------------------
  5 //解析XML字符串,并返回XML的dom对象
  6 xml_utils.parseFromString = function ( xmlstring ) {
  7     return new DOMParser().parseFromString( xmlstring );
  8 }
  9 
 10 //判断是否有该属性的值
 11 xml_utils.hasNodeAttrib = function ( node, attrib, attrib_value, flag_index ) {
 12     var nCnt = ( node && node.attributes ) ? node.attributes.length : 0;
 13     for ( var i = 0; i < nCnt; i++ ) {
 14         var attr = node.attributes[i];
 15         //if (attr.name == attrib) {
 16         //    console.log("found attrib:" + attrib + "=" + attr.value + ", dest=" + attrib_value);
 17         //}
 18         if ( attr.name != attrib ) continue;
 19         if ( flag_index === true ) {
 20             if ( attr.value.indexOf( attrib_value ) >= 0 ) return true;
 21         }
 22         else {
 23             if ( attr.value.trim() == attrib_value ) return true;
 24         }
 25     }
 26     return false;
 27 }
 28 
 29 //取指定的属性
 30 xml_utils.getNodeAttrib = function ( node, attrib ) {
 31     var nCnt = ( node && node.attributes ) ? node.attributes.length : 0;
 32     for ( var i = 0; i < nCnt; i++ ) {
 33         var attr = node.attributes[i];
 34         if ( attr.name == attrib ) return attr;
 35     }
 36     return null;
 37 }
 38 
 39 //前一个节点
 40 xml_utils.getNodePre = function ( node ) {
 41     if ( node == null || node.parentNode == null ) return null;
 42     var pNode = node.parentNode;
 43     var nCnt = pNode.childNodes ? pNode.childNodes.length : 0;
 44     var nIndex = -1;
 45     for ( var i = 0; i < nCnt; i++ ) {
 46         if ( pNode.childNodes.item( i ) === node ) {
 47             nIndex = i;
 48             break;
 49         }
 50     }
 51     if ( nIndex > 0 ) {
 52         var nNextIndex = nIndex - 1;
 53         if ( nNextIndex < nCnt ) return pNode.childNodes.item( nNextIndex );
 54     }
 55     return null;
 56 }
 57 
 58 
 59 //下一个节点
 60 xml_utils.getNodeNext = function ( node ) {
 61     if ( node == null || node.parentNode == null ) return null;
 62     var pNode = node.parentNode;
 63     var nCnt = pNode.childNodes ? pNode.childNodes.length : 0;
 64     var nIndex = -1;
 65     for ( var i = 0; i < nCnt; i++ ) {
 66         if ( pNode.childNodes.item( i ) === node ) {
 67             nIndex = i;
 68             break;
 69         }
 70     }
 71     if ( nIndex >= 0 ) {
 72         var nNextIndex = nIndex + 1;
 73         if ( nNextIndex < nCnt ) return pNode.childNodes.item( nNextIndex );
 74     }
 75     return null;
 76 }
 77 
 78 //查找指定属性的节点
 79 xml_utils.findNodeByAttribName = function ( node, attrib, attrib_value, flag_index ) {
 80     if ( this.hasNodeAttrib( node, attrib, attrib_value, flag_index ) ) return node;
 81     //便利所有的子节点  使用深度遍历的方式
 82     var nChildCnt = node.childNodes ? node.childNodes.length : 0;
 83     for ( var i = 0; i < nChildCnt; i++ ) {
 84         var n = node.childNodes.item( i );
 85         var nRet = this.findNodeByAttribName( n, attrib, attrib_value, flag_index );
 86         if ( nRet ) {
 87             return nRet;
 88         }
 89     }
 90     return null;
 91 }
 92 
 93 //将节点数组中指定的属性值,放到集合中
 94 xml_utils.nodesAttribToSet = function (nodeArray, attribName) {
 95     let retSet = new Set();
 96     for(let n of nodeArray)    
 97     {
 98         if(n.attrMap)
 99         {
100             let v = n.attrMap.get(attribName);
101             if(v) retSet.add(v);
102         }
103         else
104         {
105             let nCnt = n.attributes ? n.attributes.length : 0;
106             for(let i = 0;i < nCnt;i++) {
107                 let attr = n.attributes.item(i);
108                 if(attr && attr.name.trim() == attribName)
109                 {
110                     retSet.add(attr.value.trim());
111                     break;
112                 }
113             }
114         }
115     }
116     return retSet;
117 }
118 
119 //通过指定的函数,来确定要设的值
120 xml_utils.nodesAttribToSetEx = function (nodeArray, getFunction) {
121     if(typeof getFunction === "function") {
122         let retSet = new Set();
123         for(let n of nodeArray)    
124         {
125             let [r,txt] = getFunction(n);
126             if(r) retSet.add(txt.trim());
127         }
128         return retSet;    
129     }
130     else if(Array.isArray(getFunction)) {  //如果传入的是一个数组
131         return xml_utils.nodesAttribToSetEx(nodeArray, new Set(getFunction));
132     }
133     else if(getFunction instanceof Set) {
134         let s = getFunction;
135         let retSet = new Set();
136         for (let n of nodeArray) {
137             let nCnt = n.attributes ? n.attributes.length : 0;
138             for (let i = 0; i < nCnt; i++) {
139                 let attr = n.attributes.item(i);
140                 if (attr && s.has(attr.name.trim())) {
141                     if (!attr.value) continue;  //如果属性值不存在
142                     let v = attr.value.trim();
143                     if (v.length == 0) continue//如果为空串
144                     retSet.add(v);
145                 }
146             }
147         }  
148         return retSet;     
149     }
150     else return new Set();
151     //if(!(typeof getFunction ==="function")) return retSet;
152 }
153 
154 //判断是否有指定含有属性的节点 这里会要求指定节点名称,也就是class 其它需要的属性,则要另外判断
155 //node表示是当前的节点  
156 //要查找的节点名称和属性列表 [{class:"xxx",y:"134"},{class:"yyyy"}]
157 //返回符合条件的节点数组
158 //这里的方法,类似于 getNodesByAttrib 但是这个方法在性能上做了优化,参数更加直观
159 xml_utils.getNodesByClass = function(node, classNameList) {
160     let r = [];
161     if(!node) r;
162 
163     let cmap = new Map();           //class和class条件列表
164 
165     if(Array.isArray(classNameList)) {
166         for(let e of classNameList) {  //将每个条件取出来
167             let classValue = e.class;  
168             if(classValue) 
169             {
170                 let nCnt = 0;
171                 for(let i in e) nCnt ++;  //计算需要比较属性的数量,并保存,用于后面比较
172                 cmap.set(classValue, {c:e, count:nCnt}); 
173             }
174         }
175     }
176 
177     function check(n) {
178         if(!n) return false;  //如果节点为null,则返回false
179 
180         let attrCnt = xml_utils.getAttributeCount(n);
181         if(attrCnt == 0) return false;  //没有没有任何属性
182 
183         let e = cmap.get(n.nodeName);     //取条件列表,如果没有它的条件列表,则返回false
184         if(!e) return false;  
185         let c = e.c;  //条件列表
186 
187         //构建属性映射表
188         let foundCount = 0;
189         for(let i = 0; i < attrCnt; i++) {
190             let attr = n.attributes[i];            
191             let cValue = c[attr.name];
192             if(cValue === undefined) continue;      //如果这个不是条件之一,则下一个
193             if(cValue === null || cValue === attr.value) foundCount++;
194             else return false;      //如果找到属性存在,但是属性值不相同,则表示不合条件
195         }
196         //计算条件的数量
197         return e.count == foundCount;
198     }
199     //编历所有节点
200     function findNode(n, r) {
201         if(check(n)) r.push(n);
202         let childCnt = xml_utils.getChildNodeCount(n);
203         for(let i = 0; i < childCnt; i++) {
204             findNode(n.childNodes.item(i),r);
205         }
206     }
207     findNode(node, r);
208     return r;
209 }
210 
211 //判断是否有指定含有属性的节点
212 //node表示是当前的节点
213 //attrib是一个二维数组键值对  如[["attrib1","value1"],["attrib2","value2"],["attrib3"]]
214 //返回符合条件的节点数组
215 xml_utils.getNodesByAttrib = function (node, attrib) {
216     let r = [];
217     if(!node) r;
218     //构造条件
219     let c = {};
220     c.map = new Map();
221     c.set = new Set();
222     if(Array.isArray(attrib)) {
223         for(let e of attrib) {
224             if(!Array.isArray(e)) continue;
225             if(e.length == 1) c.set.add(e[0]);
226             else if(e.length == 2) {
227                 let mm = c.map.get(e[0]);
228                 if(!mm) {
229                     mm = new Set();
230                     c.map.set(e[0],mm);
231                 }
232                 mm.add(e[1]);
233             }
234         }
235     }
236     //检查有没有符合属性的节点
237     function check(n) {
238         let attrCnt = xml_utils.getAttributeCount(n);
239         //编历所有属性,判断是不是符合要求
240         for(let i = 0; i < attrCnt; i++) {
241             let attr = n.attributes[i];
242             if(c.set.has(attr.name)) return true;
243             let o = c.map.get(attr.name);
244             if(o && o.has(attr.value.trim())) return true;
245         }
246         return false;
247     }
248     //编历所有节点
249     function findNode(n, r) {
250         if(check(n)) r.push(n);
251         let childCnt = xml_utils.getChildNodeCount(n);
252         for(let i = 0; i < childCnt; i++) {
253             findNode(n.childNodes.item(i),r);
254         }
255     }
256     findNode(node, r);
257     return r;
258 }
259 
260 //判断指定的节点中,是含有指定的属性列表
261 //attrib是一个二维数组键值对  如[["attrib1","value1"],["attrib2","value2"],["attrib3"]]
262 xml_utils.hasAttribInNode = function (node, attrib) {
263     if(!Array.isArray(attrib)) return false;
264     let nAttribCount = (node && node.attributes) ? node.attributes.length : 0;
265     if(nAttribCount <= 0) return false;
266     let mapAttr = new Map();
267     for(let i = 0;i < nAttribCount;i++) {
268         let e = node.attributes[i];
269         mapAttr.set(e.name.trim(), e.value.trim());
270     }
271     let bRet = true;
272     for(let i = 0;i < attrib.length;i++) {
273         let attr = attrib[i];
274         if(!Array.isArray(attr)) continue;  //如果不是数组,则忽略
275         if(attr.length <= 0) continue;        //如果数组为空,则忽略
276         if(attr.length == 1) //如果只有一个属性,则判断该属性是否存在
277         {
278             if(!mapAttr.has(attr[0])) return false;
279         }
280         else {
281             if(!(mapAttr.get(attr[0]) === attr[1])) return false;
282         }
283     }
284     node.attrMap = mapAttr;
285     return bRet;
286 }
287 //将一个xml节点含属性转为字符  不含比子节点
288 xml_utils.nodeAttribToString = function (node) {
289     let strRet = "<" + (node.tagName || "") + " ";
290     let nAttribCount = (node && node.attributes) ? node.attributes.length : 0;
291     for(let i = 0;i < nAttribCount;i++) {
292         let e = node.attributes[i];
293         strRet = strRet + ' ' + e.name + '="' + e.value + '"';
294     }
295     strRet += " />"
296     return strRet;
297 }
298 
299 
300 //取找tagName的第一个节点  
301 /**
302  * 默认是深度遍历
303  * @param node 开始查找的节点
304  * @param targetTagName 节点的名称
305  * @param flagBreadth 广度遍历的标志 @default = false
306  */
307 xml_utils.findNodeByTagName = function (node, targetTagName, flagBreadth = false) {
308     if(!node) return null;
309     if(node.tagName === targetTagName) {
310         console.log("找到节点1:",  xml_utils.nodeAttribToString(node));
311         return node;
312     }
313     let childCnt = node.childNodes?node.childNodes.length:0;
314     if(flagBreadth){
315         for(let i = 0; i < childCnt; i++)
316         {
317             let childNode = node.childNodes.item(i);
318             if(childNode.tagName === targetTagName) {
319                 console.log("找到节点2:",  xml_utils.nodeAttribToString(childNode));
320                 return childNode;
321             }
322         }
323         for(let i = 0; i < childCnt; i++)
324         {
325             let n = this.findNodeByTagName(node.childNodes.item(i), targetTagName, flagBreadth);
326             if(n != nullreturn n;
327         }
328     }
329     else {
330         for(let i = 0; i < childCnt; i++)
331         {
332             let n = this.findNodeByTagName(node.childNodes.item(i), targetTagName, flagBreadth);
333             if(n != nullreturn n;
334         }
335     }
336     return null;
337 }
338 
339 //取节点的子节点的个数
340 xml_utils.getChildNodeCount = function(node) {
341     if(!node) return 0;
342     if(!node.childNodes) return 0;
343     return node.childNodes.length;
344 }
345 //取节点的属性个数
346 xml_utils.getAttributeCount = function(node) {
347     if(!node) return 0;
348     if(!node.attributes) return 0;
349     return node.attributes.length;
350 }
351 //取指定下标的子节点
352 xml_utils.getChildNodeByIndex = function (node, index) {
353     if(!node) return null;
354     if(!node.childNodes) return null;
355     return node.childNodes.item(index);
356 }
357 //取指定下标的属性
358 xml_utils.getAttributeByIndex = function(node, index) {
359     if(node) return null;
360     if(!node.attributes) return null;
361     return node.attributes[index];
362 }
363 //打印指定node XML
364 //这个是用于测试
365 xml_utils.dumpXmlNode = function (pre, node) {
366     pre = pre || "";
367     let tagName = (node && node.tagName)?node.tagName:"";
368     let nChildCnt = xml_utils.getChildNodeCount(node);
369     let nAttrCnt = xml_utils.getAttributeCount(node);
370     let s = `${pre}<${tagName}`;
371     for(let i = 0; i < nAttrCnt; i++) {
372         let attr = node.attributes[i];
373         s = s + ` ${attr.name}="${attr.value}"`;
374     }
375     if(nChildCnt > 0) {
376         s = s + ">";
377         console.log(s);
378         for(let i = 0; i < nChildCnt; i++)
379         {
380             xml_utils.dumpXmlNode(pre + "  ", node.childNodes.item(i));
381         }
382         console.log(`${pre}</${tagName}>`);
383     } else {
384         s = s + "/>";
385         console.log(s);
386     }
387 }
388 export { xml_utils};
389 export default xml_utils;