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(@*)]
  • //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>
### 三级标题:XPath 在 Selenium 中的应用 在自动化测试过程中,XPath 是一种非常强大的元素定位方式。通过 XPath 表达式,可以精确地找到页面中的任意 HTML 元素,即使该元素没有明确的 ID 或 class 属性。 Selenium 支持使用 XPath 进行元素定位,并提供了 `find_element(By.XPATH, "xpath=表达式")` 和 `find_elements(By.XPATH, "xpath=表达式")` 方法来查找单个或多个匹配的元素 [^3]。例如: ```python element = driver.find_element(By.XPATH, "/html/body/div/form/input") ``` 此代码表示通过绝对路径 `/html/body/div/form/input` 定位一个输入框元素。 #### 使用相对路径 XPath 支持相对路径写法,这在复杂的页面结构中更为灵活。例如: ```python element = driver.find_element(By.XPATH, "//div[@id='login-form']//input[@name='username']") ``` 此表达式表示查找任意层级下的 `div` 元素,其 `id` 为 `login-form`,然后在其子元素中查找 `name` 为 `username` 的 `input` 元素 [^3]。 #### 使用属性定位 XPath 可以根据元素的属性值进行定位。例如,以下代码查找 `type` 为 `submit` 的按钮: ```python element = driver.find_element(By.XPATH, "//button[@type='submit']") ``` 还可以通过部分匹配属性值,例如: - `contains()` 函数用于模糊匹配: ```python element = driver.find_element(By.XPATH, "//a[contains(text(), 'Login')]") ``` 此表达式查找文本内容包含“Login”的链接。 - `starts-with()` 函数用于匹配以特定字符串开头的属性值: ```python element = driver.find_element(By.XPATH, "//input[starts-with(@id, 'user')]") ``` #### 处理动态生成的内容 对于动态加载的网页内容,XPath 可以结合条件判断进行定位。例如: ```python element = driver.find_element(By.XPATH, "//ul/li[last()]") ``` 此表达式表示选择最后一个 `<li>` 子元素。 #### 轴(Axis)和节点关系 XPath 提供了轴(Axis)功能,用于定义节点之间的关系。常见的轴包括: - `parent::`:选择当前节点的父节点。 - `child::`:选择当前节点的直接子节点。 - `ancestor::`:选择所有祖先节点。 - `descendant::`:选择所有后代节点。 例如,以下代码表示查找当前节点的父节点并进一步定位其兄弟节点: ```python element = driver.find_element(By.XPATH, "//input[@id='email']/parent::div/following-sibling::div/button") ``` #### 调试与验证 为了确保 XPath 表达式的正确性,可以通过浏览器开发者工具进行调试。打开控制台并在 Console 面板中输入 `$x("xpath=表达式")` 来查看匹配结果。 此外,在实际测试脚本中,建议优先使用 `find_elements` 获取多个匹配项,并手动筛选出目标元素以确保唯一性。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值