xpath手册

2023-11-10

 

XPath手册 [源于ZVON]

  • /AAA
  • /AAA/CCC
  • /AAA/DDD/BBB
  • //BBB
  • //DDD/BBB
  • /AAA/CCC/DDD/*
  • /*/*/*/BBB
  • //*
  • /AAA/BBB[1]
  • /AAA/BBB[last()]
  • //@id
  • //BBB[@id]
  • //BBB[@name]
  • //BBB[@*]
  • //BBB[not(@*)]
  • //BBB[@id='b1']
  • //BBB[@name='bbb']
  • //BBB[normalize-space(@name)='bbb']
  • //*[count(BBB)=2]
  • //*[count(*)=2]
  • //*[count(*)=3]
  • //*[name()='BBB']
  • //*[starts-with(name(),'B')]
  • //*[contains(name(),'C')]
  • //*[string-length(name()) = 3]
  • //*[string-length(name()) < 3]
  • //*[string-length(name()) > 3]
  • //CCC | //BBB
  • /AAA/EEE | //BBB
  • /AAA/EEE | //DDD/CCC | /AAA | //BBB
  • /AAA
  • /child::AAA
  • /AAA/BBB
  • /child::AAA/child::BBB
  • /child::AAA/BBB
  • /descendant::*
  • /AAA/BBB/descendant::*
  • //CCC/descendant::*
  • //CCC/descendant::DDD
  • //DDD/parent::*
  • /AAA/BBB/DDD/CCC/EEE/ancestor::*
  • //FFF/ancestor::*
  • /AAA/BBB/following-sibling::*
  • //CCC/following-sibling::*
  • /AAA/XXX/preceding-sibling::*
  • //CCC/preceding-sibling::*
  • /AAA/XXX/following::*
  • //ZZZ/following::*
  • /AAA/XXX/preceding::*
  • //GGG/preceding::*
  • /AAA/XXX/descendant-or-self::*
  • //CCC/descendant-or-self::*
  • /AAA/XXX/DDD/EEE/ancestor-or-self::*
  • //GGG/ancestor-or-self::*
  • //GGG/ancestor::*
  • //GGG/descendant::*
  • //GGG/following::*
  • //GGG/preceding::*
  • //GGG/self::*
  • //GGG/ancestor::* | //GGG/descendant::* | //GGG/following::* | //GGG/preceding::* | //GGG/self::*
  • //BBB[position() mod 2 = 0 ]
  • //BBB[ position() = floor(last() div 2 + 0.5) or position() = ceiling(last() div 2 + 0.5) ]
  • //CCC[ position() = floor(last() div 2 + 0.5) or position() = ceiling(last() div 2 + 0.5) ]
基本的XPath语法类似于在一个文件系统中定位文件,如果路径以斜线 / 开始, 那么该路径就表示到一个元素的绝对路径
/AAA
选择根元素AAA

     <AAA
          <BBB/> 
          <CCC/> 
          <BBB/> 
          <BBB/> 
          <DDD
               <BBB/> 
          </DDD
          <CCC/> 
     </AAA>
/AAA/CCC
选择AAA的所有CCC子元素

     <AAA
          <BBB/> 
          <CCC/> 
          <BBB/> 
          <BBB/> 
          <DDD
               <BBB/> 
          </DDD
          <CCC/> 
     </AAA>
/AAA/DDD/BBB
选择AAA的子元素DDD的所有子元素

     <AAA
          <BBB/> 
          <CCC/> 
          <BBB/> 
          <BBB/> 
          <DDD
               <BBB/> 
          </DDD
          <CCC/> 
     </AAA>
如果路径以双斜线 // 开头, 则表示选择文档中所有满足双斜线//之后规则的元素(无论层级关系)
//BBB
选择所有BBB元素

     <AAA
          <BBB/> 
          <CCC/> 
          <BBB/> 
          <DDD
               <BBB/> 
          </DDD
          <CCC
               <DDD
                    <BBB/> 
                    <BBB/> 
               </DDD
          </CCC
     </AAA>
//DDD/BBB
选择所有父元素是DDD的BBB元素

     <AAA
          <BBB/> 
          <CCC/> 
          <BBB/> 
          <DDD
               <BBB/> 
          </DDD
          <CCC
               <DDD
                    <BBB/> 
                    <BBB/> 
               </DDD
          </CCC
     </AAA>
星号 * 表示选择所有由星号之前的路径所定位的元素
/AAA/CCC/DDD/*
选择所有路径依附于/AAA/CCC/DDD的元素

     <AAA
          <XXX
               <DDD
                    <BBB/> 
                    <BBB/> 
                    <EEE/> 
                    <FFF/> 
               </DDD
          </XXX
          <CCC
               <DDD
                    <BBB/> 
                    <BBB/> 
                    <EEE/> 
                    <FFF/> 
               </DDD
          </CCC
          <CCC
               <BBB
                    <BBB
                         <BBB/> 
                    </BBB
               </BBB
          </CCC
     </AAA>
/*/*/*/BBB
选择所有的有3个祖先元素的BBB元素

     <AAA
          <XXX
               <DDD
                    <BBB/> 
                    <BBB/> 
                    <EEE/> 
                    <FFF/> 
               </DDD
          </XXX
          <CCC
               <DDD
                    <BBB/> 
                    <BBB/> 
                    <EEE/> 
                    <FFF/> 
               </DDD
          </CCC
          <CCC
               <BBB
                    <BBB
                         <BBB/> 
                    </BBB
               </BBB
          </CCC
     </AAA>
//*
选择所有元素

     <AAA
          <XXX
               <DDD
                    <BBB/> 
                    <BBB/> 
                    <EEE/> 
                    <FFF/> 
               </DDD
          </XXX
          <CCC
               <DDD
                    <BBB/> 
                    <BBB/> 
                    <EEE/> 
                    <FFF/> 
               </DDD
          </CCC
          <CCC
               <BBB
                    <BBB
                         <BBB/> 
                    </BBB
               </BBB
          </CCC
     </AAA>
方块号里的表达式可以进一步的指定元素, 其中数字表示元素在选择集里的位置, 而last()函数则表示选择集中的最后一个元素.
/AAA/BBB[1]
选择AAA的第一个BBB子元素

     <AAA
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
     </AAA>
/AAA/BBB[last()]
选择AAA的最后一个BBB子元素

     <AAA
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
     </AAA>
//@id
选择所有的id属性

     <AAA
          <BBB id = "b1"/> 
          <BBB id = "b2"/> 
          <BBB name = "bbb"/> 
          <BBB/> 
     </AAA>
//BBB[@id]
选择有id属性的BBB元素

     <AAA
          <BBB id = "b1"/> 
          <BBB id = "b2"/> 
          <BBB name = "bbb"/> 
          <BBB/> 
     </AAA>
//BBB[@name]
选择有name属性的BBB元素

     <AAA
          <BBB id = "b1"/> 
          <BBB id = "b2"/> 
          <BBB name = "bbb"/> 
          <BBB/> 
     </AAA>
//BBB[@*]
选择有任意属性的BBB元素

     <AAA
          <BBB id = "b1"/> 
          <BBB id = "b2"/> 
          <BBB name = "bbb"/> 
          <BBB/> 
     </AAA>
//BBB[not(@*)]
选择没有属性的BBB元素

     <AAA
          <BBB id = "b1"/> 
          <BBB id = "b2"/> 
          <BBB name = "bbb"/> 
          <BBB/> 
     </AAA>
属性的值可以被用来作为选择的准则, normalize-space函数删除了前部和尾部的空格, 并且把连续的空格串替换为一个单一的空格
//BBB[@id='b1']
选择含有属性id且其值为'b1'的BBB元素

     <AAA
          <BBB id = "b1"/> 
          <BBB name = " bbb "/> 
          <BBB name = "bbb"/> 
     </AAA>
//BBB[@name='bbb']
选择含有属性name且其值为'bbb'的BBB元素

     <AAA
          <BBB id = "b1"/> 
          <BBB name = " bbb "/> 
          <BBB name = "bbb"/> 
     </AAA>
//BBB[normalize-space(@name)='bbb']
选择含有属性name且其值(在用normalize-space函数去掉前后空格后)为'bbb'的BBB元素

     <AAA
          <BBB id = "b1"/> 
          <BBB name = " bbb "/> 
          <BBB name = "bbb"/> 
     </AAA>
count()函数可以计数所选元素的个数
//*[count(BBB)=2]
选择含有2个BBB子元素的元素

     <AAA
          <CCC
               <BBB/> 
               <BBB/> 
               <BBB/> 
          </CCC
          <DDD
               <BBB/> 
               <BBB/> 
          </DDD
          <EEE
               <CCC/> 
               <DDD/> 
          </EEE
     </AAA>
//*[count(*)=2]
选择含有2个子元素的元素

     <AAA
          <CCC
               <BBB/> 
               <BBB/> 
               <BBB/> 
          </CCC
          <DDD
               <BBB/> 
               <BBB/> 
          </DDD
          <EEE
               <CCC/> 
               <DDD/> 
          </EEE
     </AAA>
//*[count(*)=3]
选择含有3个子元素的元素

     <AAA
          <CCC
               <BBB/> 
               <BBB/> 
               <BBB/> 
          </CCC
          <DDD
               <BBB/> 
               <BBB/> 
          </DDD
          <EEE
               <CCC/> 
               <DDD/> 
          </EEE
     </AAA>
name()函数返回元素的名称, start-with()函数在该函数的第一个参数字符串是以第二个参数字符开始的情况返回true, contains()函数当其第一个字符串参数包含有第二个字符串参数时返回true.
//*[name()='BBB']
选择所有名称为BBB的元素(这里等价于//BBB)

     <AAA
          <BCC
               <BBB/> 
               <BBB/> 
               <BBB/> 
          </BCC
          <DDB
               <BBB/> 
               <BBB/> 
          </DDB
          <BEC
               <CCC/> 
               <DBD/> 
          </BEC
     </AAA>
//*[starts-with(name(),'B')]
选择所有名称以"B"起始的元素

     <AAA
          <BCC
               <BBB/> 
               <BBB/> 
               <BBB/> 
          </BCC
          <DDB
               <BBB/> 
               <BBB/> 
          </DDB
          <BEC
               <CCC/> 
               <DBD/> 
          </BEC
     </AAA>
//*[contains(name(),'C')]
选择所有名称包含"C"的元素

     <AAA
          <BCC
               <BBB/> 
               <BBB/> 
               <BBB/> 
          </BCC
          <DDB
               <BBB/> 
               <BBB/> 
          </DDB
          <BEC
               <CCC/> 
               <DBD/> 
          </BEC
     </AAA>
string-length函数返回字符串的字符数,你应该用&lt;替代<, 用&gt;代替>
//*[string-length(name()) = 3]
选择名字长度为3的元素

     <AAA
          <Q/> 
          <SSSS/> 
          <BB/> 
          <CCC/> 
          <DDDDDDDD/> 
          <EEEE/> 
     </AAA>
//*[string-length(name()) < 3]
选择名字长度小于3的元素

     <AAA
          <Q/> 
          <SSSS/> 
          <BB/> 
          <CCC/> 
          <DDDDDDDD/> 
          <EEEE/> 
     </AAA>
//*[string-length(name()) > 3]
选择名字长度大于3的元素

     <AAA
          <Q/> 
          <SSSS/> 
          <BB/> 
          <CCC/> 
          <DDDDDDDD/> 
          <EEEE/> 
     </AAA>
多个路径可以用分隔符 | 合并在一起
//CCC | //BBB
选择所有的CCC和BBB元素

     <AAA
          <BBB/> 
          <CCC/> 
          <DDD
               <CCC/> 
          </DDD
          <EEE/> 
     </AAA>
/AAA/EEE | //BBB
选择所有的BBB元素和所有是AAA的子元素的EEE元素

     <AAA
          <BBB/> 
          <CCC/> 
          <DDD
               <CCC/> 
          </DDD
          <EEE/> 
     </AAA>
/AAA/EEE | //DDD/CCC | /AAA | //BBB
可以合并的路径数目没有限制

     <AAA
          <BBB/> 
          <CCC/> 
          <DDD
               <CCC/> 
          </DDD
          <EEE/> 
     </AAA>
child轴(axis)包含上下文节点的子元素, 作为默认的轴,可以忽略不写.
/AAA
等价于 /child::AAA

     <AAA
          <BBB/> 
          <CCC/> 
     </AAA>
/child::AAA
等价于/AAA

     <AAA
          <BBB/> 
          <CCC/> 
     </AAA>
/AAA/BBB
等价于/child::AAA/child::BBB

     <AAA
          <BBB/> 
          <CCC/> 
     </AAA>
/child::AAA/child::BBB
等价于/AAA/BBB

     <AAA
          <BBB/> 
          <CCC/> 
     </AAA>
/child::AAA/BBB
二者都可以被合并

     <AAA
          <BBB/> 
          <CCC/> 
     </AAA>
descendant (后代)轴包含上下文节点的后代,一个后代是指子节点或者子节点的子节点等等, 因此descendant轴不会包含属性和命名空间节点.
/descendant::*
选择文档根元素的所有后代.即所有的元素被选择

     <AAA
          <BBB
               <DDD
                    <CCC
                         <DDD/> 
                         <EEE/> 
                    </CCC
               </DDD
          </BBB
          <CCC
               <DDD
                    <EEE
                         <DDD
                              <FFF/> 
                         </DDD
                    </EEE
               </DDD
          </CCC
     </AAA>
/AAA/BBB/descendant::*
选择/AAA/BBB的所有后代元素

     <AAA
          <BBB
               <DDD
                    <CCC
                         <DDD/> 
                         <EEE/> 
                    </CCC
               </DDD
          </BBB
          <CCC
               <DDD
                    <EEE
                         <DDD
                              <FFF/> 
                         </DDD
                    </EEE
               </DDD
          </CCC
     </AAA>
//CCC/descendant::*
选择在祖先元素中有CCC的所有元素

     <AAA
          <BBB
               <DDD
                    <CCC
                         <DDD/> 
                         <EEE/> 
                    </CCC
               </DDD
          </BBB
          <CCC
               <DDD
                    <EEE
                         <DDD
                              <FFF/> 
                         </DDD
                    </EEE
               </DDD
          </CCC
     </AAA>
//CCC/descendant::DDD
选择所有以CCC为祖先元素的DDD元素

     <AAA
          <BBB
               <DDD
                    <CCC
                         <DDD/> 
                         <EEE/> 
                    </CCC
               </DDD
          </BBB
          <CCC
               <DDD
                    <EEE
                         <DDD
                              <FFF/> 
                         </DDD
                    </EEE
               </DDD
          </CCC
     </AAA>
parent轴(axis)包含上下文节点的父节点, 如果有父节点的话
//DDD/parent::*
选择DDD元素的所有父节点

     <AAA
          <BBB
               <DDD
                    <CCC
                         <DDD/> 
                         <EEE/> 
                    </CCC
               </DDD
          </BBB
          <CCC
               <DDD
                    <EEE
                         <DDD
                              <FFF/> 
                         </DDD
                    </EEE
               </DDD
          </CCC
     </AAA>
ancestor轴(axis)包含上下节点的祖先节点, 该祖先节点由其上下文节点的父节点以及父节点的父节点等等诸如此类的节点构成,所以ancestor轴总是包含有根节点,除非上下文节点就是根节点本身.
/AAA/BBB/DDD/CCC/EEE/ancestor::*
选择一个绝对路径上的所有节点

     <AAA
          <BBB
               <DDD
                    <CCC
                         <DDD/> 
                         <EEE/> 
                    </CCC
               </DDD
          </BBB
          <CCC
               <DDD
                    <EEE
                         <DDD
                              <FFF/> 
                         </DDD
                    </EEE
               </DDD
          </CCC
     </AAA>
//FFF/ancestor::*
选择FFF元素的祖先节点

     <AAA
          <BBB
               <DDD
                    <CCC
                         <DDD/> 
                         <EEE/> 
                    </CCC
               </DDD
          </BBB
          <CCC
               <DDD
                    <EEE
                         <DDD
                              <FFF/> 
                         </DDD
                    </EEE
               </DDD
          </CCC
     </AAA>
following-sibling轴(axis)包含上下文节点之后的所有兄弟节点
/AAA/BBB/following-sibling::*
 

     <AAA
          <BBB
               <CCC/> 
               <DDD/> 
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//CCC/following-sibling::*
 

     <AAA
          <BBB
               <CCC/> 
               <DDD/> 
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
preceding-sibling 轴(axis)包含上下文节点之前的所有兄弟节点
/AAA/XXX/preceding-sibling::*
 

     <AAA
          <BBB
               <CCC/> 
               <DDD/> 
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//CCC/preceding-sibling::*
 

     <AAA
          <BBB
               <CCC/> 
               <DDD/> 
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
following轴(axis)包含同一文档中按文档顺序位于上下文节点之后的所有节点, 除了祖先节点,属性节点和命名空间节点
/AAA/XXX/following::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ
                    <DDD/> 
                    <DDD
                         <EEE/> 
                    </DDD
               </ZZZ
               <FFF
                    <GGG/> 
               </FFF
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//ZZZ/following::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ
                    <DDD/> 
                    <DDD
                         <EEE/> 
                    </DDD
               </ZZZ
               <FFF
                    <GGG/> 
               </FFF
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
following轴(axis)包含同一文档中按文档顺序位于上下文节点之前的所有节点, 除了祖先节点,属性节点和命名空间节点
/AAA/XXX/preceding::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ
                    <DDD/> 
               </ZZZ
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//GGG/preceding::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ
                    <DDD/> 
               </ZZZ
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
descendant-or-self 轴(axis)包含上下文节点本身和该节点的后代节点
/AAA/XXX/descendant-or-self::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ
                    <DDD/> 
               </ZZZ
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//CCC/descendant-or-self::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ
                    <DDD/> 
               </ZZZ
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
ancestor-or-self 轴(axis)包含上下文节点本身和该节点的祖先节点
/AAA/XXX/DDD/EEE/ancestor-or-self::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ
                    <DDD/> 
               </ZZZ
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//GGG/ancestor-or-self::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ
                    <DDD/> 
               </ZZZ
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <DDD/> 
                    <CCC/> 
                    <FFF/> 
                    <FFF
                         <GGG/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
ancestor, descendant, following, preceding 和self轴(axis)分割了XML文档(忽略属性节点和命名空间节点), 不能交迭, 而一起使用则包含所有节点
//GGG/ancestor::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ/> 
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <FFF
                         <HHH/> 
                         <GGG
                              <JJJ
                                   <QQQ/> 
                              </JJJ
                              <JJJ/> 
                         </GGG
                         <HHH/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//GGG/descendant::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ/> 
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <FFF
                         <HHH/> 
                         <GGG
                              <JJJ
                                   <QQQ/> 
                              </JJJ
                              <JJJ/> 
                         </GGG
                         <HHH/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//GGG/following::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ/> 
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <FFF
                         <HHH/> 
                         <GGG
                              <JJJ
                                   <QQQ/> 
                              </JJJ
                              <JJJ/> 
                         </GGG
                         <HHH/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//GGG/preceding::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ/> 
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <FFF
                         <HHH/> 
                         <GGG
                              <JJJ
                                   <QQQ/> 
                              </JJJ
                              <JJJ/> 
                         </GGG
                         <HHH/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//GGG/self::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ/> 
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <FFF
                         <HHH/> 
                         <GGG
                              <JJJ
                                   <QQQ/> 
                              </JJJ
                              <JJJ/> 
                         </GGG
                         <HHH/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
//GGG/ancestor::* | //GGG/descendant::* | //GGG/following::* | //GGG/preceding::* | //GGG/self::*
 

     <AAA
          <BBB
               <CCC/> 
               <ZZZ/> 
          </BBB
          <XXX
               <DDD
                    <EEE/> 
                    <FFF
                         <HHH/> 
                         <GGG
                              <JJJ
                                   <QQQ/> 
                              </JJJ
                              <JJJ/> 
                         </GGG
                         <HHH/> 
                    </FFF
               </DDD
          </XXX
          <CCC
               <DDD/> 
          </CCC
     </AAA>
div运算符做浮点除法运算, mod运算符做求余运算, floor函数返回不大于参数的最大整数(趋近于正无穷), ceiling返回不小于参数的最小整数(趋近于负无穷)
//BBB[position() mod 2 = 0 ]
选择偶数位置的BBB元素

     <AAA
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <CCC/> 
          <CCC/> 
          <CCC/> 
     </AAA>
//BBB[ position() = floor(last() div 2 + 0.5) or position() = ceiling(last() div 2 + 0.5) ]
选择中间的BBB元素

     <AAA
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <CCC/> 
          <CCC/> 
          <CCC/> 
     </AAA>
//CCC[ position() = floor(last() div 2 + 0.5) or position() = ceiling(last() div 2 + 0.5) ]
选择中间的CCC元素

     <AAA
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <BBB/> 
          <CCC/> 
          <CCC/> 
          <CCC/> 
     </AAA>
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

xpath手册 的相关文章

随机推荐

  • logback 不同类的日志打印在不同的文件中

    在Spring Boot中 您可以使用Logback为不同的类配置不同的日志文件 以下是一个基本的 logback xml 配置示例 展示了如何为两个类 com example Class1 和 com example Class2 配置不
  • MySql:局域网和权限用户管理

    MySql 5 6 XP 5 7 win7 添加用户和设置局域访问权限操作 请在 http sourceforge net 下载MySql Control Center 不是安装版本 use mysql select from user u
  • OPEN CV 环境配置 VS 2022(超详细+图解)

    先来说明一下写这篇博客的初衷吧 由于前段时间在和一位大佬的交流之中 他提出了一个建议 说叫我平时可以自己做一些嵌入式开发项目什么的 有极大的利处 我就跟着bi站的老师 华清创客学院 开始学习 但是老师的教程是用虚拟机创建一个linux系统
  • 人事管理系统 数据流图_大学毕业设计-宾馆管理系统

    目录 第一章 绪论 1 1 1概述 1 第二章 宾馆管理系统系统分析 1 2 1可行性分析 1 2 2 需求分析 2 第三章 系统概要设计 2 3 1 功能需求 2 3 2 主要功能 3 3 3 系统开发目的 3 3 4 运行环境 3 3
  • 异步日志的实现

    异步日志的实现 异步管理类 异步工厂类 登录校验 登录 异步管理类 采用单例模式的静态饥饿加载 利用空间换时间 提高效率 使用异步延迟任务线程池 通过其内直接创建饥一个static对象 形成饥饿加载 以达到记录日志时的单例模式 import
  • Android-Studio-常用配置和快捷键

    原文链接http www open open com lib view open1466732917214 html articleHeader1 http www jianshu com p bc8f6bfe12c6 以下直接在 Sett
  • VS版本、GCC版本与C++版本的对应关系

    做嵌入式开发经常遇到一些编译器和C 版本不匹配的问题 现整理如下 目前C语言的标准有 C89 ANSI C C90 C95 C99 ISO C C11 C1x 目前C 语言的标准有 C 98 C 03 对98小幅修改 C 11 全面进化 C
  • C语言与C++,C#究竟是什么关系?

    简单来说 C 就像是C语言的亲弟弟 而C 就是他们二者的远房亲戚 其实它更像是Java的表兄弟 小编c 学习群825414254获取c 一整套系统性的学习资料还有数十套pdf这三门语言都是十分优秀的编程语言 也都有很高的运行效率 这三种编程
  • Gradle是个啥东东?

    如何通俗地理解 Gradle 我以前一直用 Eclipse with ADT 来开发Android 项目 而且对它的基础的原理掌握不深 直接上手开发的 没有去考虑太多的东西 现在手头上有一个新的项目要使用到Android Studio 我早
  • SQL编程:外键约束

    外键 foreign key 一个表中的foreign key指向另一个表中的unique key 唯一约束的键 对于两个具有关联关系的表而言 相关联字段中主键所在的表就是主表 外键所在的表就是从表 子表 外键约束 foreign key约
  • SpringCloud gateway+zookeeper实现网关路由

    准备工作 需要两个项目去实现路由 demo1为springboot项目用于接入网关 测试网关连通性 gateway为网关路由项目 网关搭建 1 电脑安装好zookeeper 并且正常运行服务 Zookeeper官网 2 创建一个spring
  • python3 100示例学习

    http www runoob com python python 100 examples html
  • CSS属性之渐变属性(gradient)

    渐变分为线性渐变和径向渐变 所谓渐变就是几种颜色之间的平稳过渡 线性渐变 线性渐变 linear gradient 实现线性渐变 你至少需要定义两种颜色的结点 这两种结点就是你想平稳过渡的颜色 即 其中一种颜色结点为起点 另一种颜色结点为结
  • 论文阅读—基于目标偏置的双向APF-RRT*算法的无人机轨迹规划

    基于目标偏置的双向APF RRT 算法的无人机轨迹规划 算法 APF选择最好的父节点 双向搜索树 主要提升策略 实验分析 J Fan X Chen and X Liang UAV trajectory planning based on b
  • 40核至强服务器性能如何,Intel 10nm 14核心至强曝光:同频性能暴涨54%

    日前我们曾经从GeekBench测试数据库里见到一颗疑似Intel 10nm Ice Lake SP服务器平台的6核心型号 外媒称对比现有14nm产品 多线程性能提升多达118 颇为不可思议 但真实性也有待检验 现在 SiSoftware数
  • 期刊分区常识

    作为一个科研工作者 了解期刊论文的一些基本常识是大有裨益的 这对于我们深入了解所从事领域的研究 和论文的写作与发表等都会有很大的帮助 比如对于期刊分区的问题 从事科研的人都听过 但是也许你并没有深入了解其概念和意义 尤其对于刚刚步入科研领域
  • 用docker 创建centos7 ,无法使用systemctl解决方法

    docker run privileged it d name centos odoo centos centos7 9 2009 usr sbin init 1 privileged it d 一定要加 2 name 后面是容器名称和使用
  • 一句话征服了美国人,这位饱受争议的数学博士竟从未上过学?

    全世界只有3 14 的人关注了 青少年数学之旅 前两天 有位不愿意透露姓名的模友问了超模君一个问题 虽然这个问题超模君已经解答过无数遍了 但看到模友如此虔诚的态度 超模君决定今天再给模友们讲一个犹太小伙用数学征服美国军官的故事 偌大维也纳
  • qt的visible hide 等布局隐藏函数

    https blog csdn net dbzhang800 article details 6300021
  • xpath手册

    XPath手册 源于ZVON AAA AAA CCC AAA DDD BBB BBB DDD BBB AAA CCC DDD BBB AAA BBB 1 AAA BBB last id BBB id BBB name BBB BBB not