XPath官方手册中文版 - 青年IT男 - ITeye博客

`

1028826685

浏览: 940927 次
性别:
来自: 重庆

最近访客更多访客>>

stingice

u014594108

f641385712

StartKeep

博主相关

博客

微博

相册

收藏

留言

关于我

文章分类

社区版块

存档分类

最新评论

misisipi101：假设库已经分为32个，那么要扩展到64个，怎样做呢
订单分库分表实践总结以及关键步骤
mfkxk298：简单明了的例子，解决了问题，谢谢啦！
关于ListView中notifyDataSetChanged()刷新数据不更新原因
whbwang： " target="_blank" ...
java web开发高并发处理
suguoqian： ...
java web开发高并发处理
xiangnanyujing：
Dubbox+Redis3.0+Spring+Hibernate+zookeeper实现消息推送核心搭建

XPath官方手册中文版

博客分类：

J2EE

XPath官方手册中文版

阅读更多

字号：大中小 XPATH指南
实例 1基本的XPath语法类似于在一个文件系统中定位文件,如果路径以斜线 / 开始, 那么该路径就表示到一个元素的绝对路径

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

实例 3星号 * 表示选择所有由星号之前的路径所定位的元素

实例 4方块号里的表达式可以进一步的指定元素, 其中数字表示元素在选择集里的位置, 而last()函数则表示选择集中的最后一个元素.

实例 5
实例 6属性的值可以被用来作为选择的准则, normalize-space函数删除了前部和尾部的空格, 并且把连续的空格串替换为一个单一的空格

实例 7函数可以计数所选元素的个数
count()
实例 8函数返回元素的名称, start-with()函数在该函数的第一个参数字符串是以第二个参数字符开始的情况返回true, contains()函数当其第一个字符串参数包含有第二个字符串参数时返回true.
name()
实例 9函数返回字符串的字符数,你应该用<替代<, 用>代替>
string-length
实例 10多个路径可以用分隔符 | 合并在一起

实例 11轴(axis)包含上下文节点的子元素, 作为默认的轴,可以忽略不写.
child
实例 12后代)轴包含上下文节点的后代,一个后代是指子节点或者子节点的子节点等等, 因此descendant轴不会包含属性和命名空间节点.
descendant (
实例 13轴(axis)包含上下文节点的父节点, 如果有父节点的话
parent
实例 14轴(axis)包含上下节点的祖先节点, 该祖先节点由其上下文节点的父节点以及父节点的父节点等等诸如此类的节点构成,所以ancestor轴总是包含有根节点,除非上下文节点就是根节点本身.
ancestor
实例 15轴(axis)包含上下文节点之后的所有兄弟节点
following-sibling
实例 16轴(axis)包含上下文节点之前的所有兄弟节点
preceding-sibling
实例 17轴(axis)包含同一文档中按文档顺序位于上下文节点之后的所有节点, 除了祖先节点,属性节点和命名空间节点
following
实例 18轴(axis)包含同一文档中按文档顺序位于上下文节点之前的所有节点, 除了祖先节点,属性节点和命名空间节点
following
实例 19轴(axis)包含上下文节点本身和该节点的后代节点
descendant-or-self
实例 20轴(axis)包含上下文节点本身和该节点的祖先节点
ancestor-or-self
实例 21和self轴(axis)分割了XML文档(忽略属性节点和命名空间节点), 不能交迭, 而一起使用则包含所有节点
ancestor, descendant, following, preceding
实例 22运算符做浮点除法运算, mod运算符做求余运算, floor函数返回不大于参数的最大整数(趋近于正无穷), ceiling返回不小于参数的最小整数(趋近于负无穷)
div

>> 实例 1 << | 前页 | 后页

基本的XPath语法类似于在一个文件系统中定位文件,如果路径以斜线 / 开始, 那么该路径就表示到一个元素的绝对路径

/AAA
选择根元素AAA

     <AAA>
          <BBB/>
          <CCC/>
          <BBB/>
          <BBB/>
          <DDD>
               <BBB/>
          </DDD>
          <CCC/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

/AAA/CCC
选择AAA的所有CCC子元素

     <AAA>
          <BBB/>
          <CCC/>
          <BBB/>
          <BBB/>
          <DDD>
               <BBB/>
          </DDD>
          <CCC/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

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

     <AAA>
          <BBB/>
          <CCC/>
          <BBB/>
          <BBB/>
          <DDD>
               <BBB/>
          </DDD>
          <CCC/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

The basic XPath syntax is similar to filesystem addressing. If the path starts with the slash / , then it represents an absolute path to the required element.
基本的XPATH语法类似于文件系统寻址。
如果以/开头，这表示绝对路径

/AAA
Select the root element AAA

     <AAA>
          <BBB/>
          <CCC/>
          <BBB/>
          <BBB/>
          <DDD>
               <BBB/>
          </DDD>
          <CCC/>
     </AAA>
Open the example in XLab. | Tree view (JPG)

/AAA/CCC
Select all elements CCC which are children of the root element AAA

     <AAA>
          <BBB/>
          <CCC/>
          <BBB/>
          <BBB/>
          <DDD>
               <BBB/>
          </DDD>
          <CCC/>
     </AAA>
Open the example in XLab. | Tree view (JPG)



>> 实例 2 << | 前页 | 后页

如果路径以双斜线 // 开头, 则表示选择文档中所有满足双斜线//之后规则的元素(无论层级关系)
===========即，//后的是匹配的通配符，返回所有满足这个路径条件的节点。

//BBB
选择所有BBB元素

     <AAA>
          <BBB/>
          <CCC/>
          <BBB/>
          <DDD>
               <BBB/>
          </DDD>
          <CCC>
               <DDD>
                    <BBB/>
                    <BBB/>
               </DDD>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//DDD/BBB
选择所有父元素是DDD的BBB元素

     <AAA>
          <BBB/>
          <CCC/>
          <BBB/>
          <DDD>
               <BBB/>
          </DDD>
          <CCC>
               <DDD>
                    <BBB/>
                    <BBB/>
               </DDD>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 3 << | 前页 | 后页

星号 * 表示选择所有由星号之前的路径所定位的元素

/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>
在XLab中打开实例 | 树视图 (JPG)

/*/*/*/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>
在XLab中打开实例 | 树视图 (JPG)

//*
选择所有元素

     <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>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 4 << | 前页 | 后页

方块号里的表达式可以进一步的指定元素, 其中数字表示元素在选择集里的位置, 而last()函数则表示选择集中的最后一个元素.
======类似于数组。但它是从1开始，而不是C,Java那样从0开始。

/AAA/BBB[1]
选择AAA的第一个BBB子元素

     <AAA>
          <BBB/>
          <BBB/>
          <BBB/>
          <BBB/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

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

     <AAA>
          <BBB/>
          <BBB/>
          <BBB/>
          <BBB/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 5 << | 前页 | 后页

====@xxx   是选择所有属性为xxx的属性

//@id
选择所有的id属性======这里返回的是Attribute属性对象。而不是节点Node对象。

     <AAA>
          <BBB id = "b1"/>
          <BBB id = "b2"/>
          <BBB name = "bbb"/>
          <BBB/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//BBB[@id]
选择有id属性的BBB元素

     <AAA>
          <BBB id = "b1"/>
          <BBB id = "b2"/>
          <BBB name = "bbb"/>
          <BBB/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//BBB[@name]
选择有name属性的BBB元素

     <AAA>
          <BBB id = "b1"/>
          <BBB id = "b2"/>
          <BBB name = "bbb"/>
          <BBB/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//BBB[@*]
选择有任意属性的BBB元素

     <AAA>
          <BBB id = "b1"/>
          <BBB id = "b2"/>
          <BBB name = "bbb"/>
          <BBB/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//BBB[not(@*)]
选择没有属性的BBB元素

     <AAA>
          <BBB id = "b1"/>
          <BBB id = "b2"/>
          <BBB name = "bbb"/>
          <BBB/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 6 << | 前页 | 后页

属性的值可以被用来作为选择的准则, normalize-space函数删除了前部和尾部的空格, 并且把连续的空格串替换为一个单一的空格
=======这里，=表示等于。类似于SQL的语法，不同于Java和C++的语法。
//BBB[@id='b1']
选择含有属性id且其值为'b1'的BBB元素

     <AAA>
          <BBB id = "b1"/>
          <BBB name = " bbb "/>
          <BBB name = "bbb"/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//BBB[@name='bbb']
选择含有属性name且其值为'bbb'的BBB元素

     <AAA>
          <BBB id = "b1"/>
          <BBB name = " bbb "/>
          <BBB name = "bbb"/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

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

     <AAA>
          <BBB id = "b1"/>
          <BBB name = " bbb "/>
          <BBB name = "bbb"/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 7 << | 前页 | 后页

count()函数可以计数所选元素的个数

//*[count(BBB)=2]
选择含有2个BBB子元素的元素

     <AAA>
          <CCC>
               <BBB/>
               <BBB/>
               <BBB/>
          </CCC>
          <DDD>
               <BBB/>
               <BBB/>
          </DDD>
          <EEE>
               <CCC/>
               <DDD/>
          </EEE>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//*[count(*)=2]
选择含有2个子元素的元素

     <AAA>
          <CCC>
               <BBB/>
               <BBB/>
               <BBB/>
          </CCC>
          <DDD>
               <BBB/>
               <BBB/>
          </DDD>
          <EEE>
               <CCC/>
               <DDD/>
          </EEE>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//*[count(*)=3]
选择含有3个子元素的元素

     <AAA>
          <CCC>
               <BBB/>
               <BBB/>
               <BBB/>
          </CCC>
          <DDD>
               <BBB/>
               <BBB/>
          </DDD>
          <EEE>
               <CCC/>
               <DDD/>
          </EEE>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 8 << | 前页 | 后页

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>
在XLab中打开实例 | 树视图 (JPG)

//*[starts-with(name(),'B')]
选择所有名称以"B"起始的元素

     <AAA>
          <BCC>
               <BBB/>
               <BBB/>
               <BBB/>
          </BCC>
          <DDB>
               <BBB/>
               <BBB/>
          </DDB>
          <BEC>
               <CCC/>
               <DBD/>
          </BEC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//*[contains(name(),'C')]
选择所有名称包含"C"的元素

     <AAA>
          <BCC>
               <BBB/>
               <BBB/>
               <BBB/>
          </BCC>
          <DDB>
               <BBB/>
               <BBB/>
          </DDB>
          <BEC>
               <CCC/>
               <DBD/>
          </BEC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 9 << | 前页 | 后页

string-length函数返回字符串的字符数,你应该用<替代<, 用>代替>

//*[string-length(name()) = 3]
选择名字长度为3的元素

     <AAA>
          <Q/>
          <SSSS/>
          <BB/>
          <CCC/>
          <DDDDDDDD/>
          <EEEE/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//*[string-length(name()) < 3]
选择名字长度小于3的元素

     <AAA>
          <Q/>
          <SSSS/>
          <BB/>
          <CCC/>
          <DDDDDDDD/>
          <EEEE/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//*[string-length(name()) > 3]
选择名字长度大于3的元素

     <AAA>
          <Q/>
          <SSSS/>
          <BB/>
          <CCC/>
          <DDDDDDDD/>
          <EEEE/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 10 << | 前页 | 后页

多个路径可以用分隔符 | 合并在一起
=======用|表示或者。不同于java中用||表示或者。

//CCC | //BBB
选择所有的CCC和BBB元素

     <AAA>
          <BBB/>
          <CCC/>
          <DDD>
               <CCC/>
          </DDD>
          <EEE/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

/AAA/EEE | //BBB
选择所有的BBB元素和所有是AAA的子元素的EEE元素

     <AAA>
          <BBB/>
          <CCC/>
          <DDD>
               <CCC/>
          </DDD>
          <EEE/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

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

     <AAA>
          <BBB/>
          <CCC/>
          <DDD>
               <CCC/>
          </DDD>
          <EEE/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 11 << | 前页 | 后页

child轴(axis)包含上下文节点的子元素, 作为默认的轴,可以忽略不写.
======child::前缀，表示只包含该节点（就是返回它自己），不包括该节点的子、孙节点。这是默认的。写不写都一样！

/AAA
等价于 /child::AAA

     <AAA>
          <BBB/>
          <CCC/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

/child::AAA
等价于/AAA

     <AAA>
          <BBB/>
          <CCC/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

/AAA/BBB
等价于/child::AAA/child::BBB

     <AAA>
          <BBB/>
          <CCC/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

/child::AAA/child::BBB
等价于/AAA/BBB

     <AAA>
          <BBB/>
          <CCC/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

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

     <AAA>
          <BBB/>
          <CCC/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 12 << | 前页 | 后页

descendant (后代)轴包含上下文节点的后代,一个后代是指子节点或者子节点的子节点等等, 因此descendant轴不会包含属性和命名空间节点.

/descendant::*
选择文档根元素的所有后代.即所有的元素被选择

     <AAA>
          <BBB>
               <DDD>
                    <CCC>
                         <DDD/>
                         <EEE/>
                    </CCC>
               </DDD>
          </BBB>
          <CCC>
               <DDD>
                    <EEE>
                         <DDD>
                              <FFF/>
                         </DDD>
                    </EEE>
               </DDD>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

/AAA/BBB/descendant::*
选择/AAA/BBB的所有后代元素

     <AAA>
          <BBB>
               <DDD>
                    <CCC>
                         <DDD/>
                         <EEE/>
                    </CCC>
               </DDD>
          </BBB>
          <CCC>
               <DDD>
                    <EEE>
                         <DDD>
                              <FFF/>
                         </DDD>
                    </EEE>
               </DDD>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//CCC/descendant::*
选择在祖先元素中有CCC的所有元素

     <AAA>
          <BBB>
               <DDD>
                    <CCC>
                         <DDD/>
                         <EEE/>
                    </CCC>
               </DDD>
          </BBB>
          <CCC>
               <DDD>
                    <EEE>
                         <DDD>
                              <FFF/>
                         </DDD>
                    </EEE>
               </DDD>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//CCC/descendant::DDD
选择所有以CCC为祖先元素的DDD元素

     <AAA>
          <BBB>
               <DDD>
                    <CCC>
                         <DDD/>
                         <EEE/>
                    </CCC>
               </DDD>
          </BBB>
          <CCC>
               <DDD>
                    <EEE>
                         <DDD>
                              <FFF/>
                         </DDD>
                    </EEE>
               </DDD>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 13 << | 前页 | 后页

parent轴(axis)包含上下文节点的父节点, 如果有父节点的话

//DDD/parent::*
选择DDD元素的所有父节点

     <AAA>
          <BBB>
               <DDD>
                    <CCC>
                         <DDD/>
                         <EEE/>
                    </CCC>
               </DDD>
          </BBB>
          <CCC>
               <DDD>
                    <EEE>
                         <DDD>
                              <FFF/>
                         </DDD>
                    </EEE>
               </DDD>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 14 << | 前页 | 后页

Ancestor(祖先)轴(axis)包含上下节点的祖先节点, 该祖先节点由其上下文节点的父节点以及父节点的父节点等等诸如此类的节点构成,所以ancestor轴总是包含有根节点,除非上下文节点就是根节点本身.
=====注意，和父节点一样，把包含自身。
只有child是包含自身，其他前缀都不包含自身。
/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>
在XLab中打开实例 | 树视图 (JPG)

//FFF/ancestor::*
选择FFF元素的祖先节点

     <AAA>
          <BBB>
               <DDD>
                    <CCC>
                         <DDD/>
                         <EEE/>
                    </CCC>
               </DDD>
          </BBB>
          <CCC>
               <DDD>
                    <EEE>
                         <DDD>
                              <FFF/>
                         </DDD>
                    </EEE>
               </DDD>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 15 << | 前页 | 后页

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>
在XLab中打开实例 | 树视图 (JPG)

//CCC/following-sibling::*

     <AAA>
          <BBB>
               <CCC/>
               <DDD/>
          </BBB>
          <XXX>
               <DDD>
                    <EEE/>
                    <DDD/>
                    <CCC/>
                    <FFF/>
                    <FFF>
                         <GGG/>
                    </FFF>
               </DDD>
          </XXX>
          <CCC>
               <DDD/>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 16 << | 前页 | 后页

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>
在XLab中打开实例 | 树视图 (JPG)

//CCC/preceding-sibling::*

     <AAA>
          <BBB>
               <CCC/>
               <DDD/>
          </BBB>
          <XXX>
               <DDD>
                    <EEE/>
                    <DDD/>
                    <CCC/>
                    <FFF/>
                    <FFF>
                         <GGG/>
                    </FFF>
               </DDD>
          </XXX>
          <CCC>
               <DDD/>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 17 << | 前页 | 后页

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>
在XLab中打开实例 | 树视图 (JPG)

//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>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 18 << | 前页 | 后页

preceding轴(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>
在XLab中打开实例 | 树视图 (JPG)

//GGG/preceding::*

     <AAA>
          <BBB>
               <CCC/>
               <ZZZ>
                    <DDD/>
               </ZZZ>
          </BBB>
          <XXX>
               <DDD>
                    <EEE/>
                    <DDD/>
                    <CCC/>
                    <FFF/>
                    <FFF>
                         <GGG/>
                    </FFF>
               </DDD>
          </XXX>
          <CCC>
               <DDD/>
          </CCC>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 19 << | 前页 | 后页

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>
在XLab中打开实例 | 树视图 (JPG)

//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>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 20 << | 前页 | 后页

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>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 21 << | 前页 | 后页

ancestor, descendant, following, preceding 和self轴(axis)分割了XML文档(忽略属性节点和命名空间节点), 不能交迭, 而一起使用则包含所有节点

注意：除了child::放在节点名的前面（等于不放），其他轴都是放在节点名的后面。这样的形式：
节点名/轴::*

//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>
在XLab中打开实例 | 树视图 (JPG)

//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>
在XLab中打开实例 | 树视图 (JPG)

//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>
在XLab中打开实例 | 树视图 (JPG)

//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>
在XLab中打开实例 | 树视图 (JPG)

注意：
/child::AAA与/AAA/self::*一样！

//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>
在XLab中打开实例 | 树视图 (JPG)

//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>
在XLab中打开实例 | 树视图 (JPG)

>> 实例 22 << | 前页 | 后页

div运算符做浮点除法运算, mod运算符做求余运算, floor函数返回不大于参数的最大整数(趋近于正无穷), ceiling返回不小于参数的最小整数(趋近于负无穷)

//BBB[position() mod 2 = 0 ]
选择偶数位置的BBB元素

     <AAA>
          <BBB/>
          <BBB/>
          <BBB/>
          <BBB/>
          <BBB/>
          <BBB/>
          <BBB/>
          <BBB/>
          <CCC/>
          <CCC/>
          <CCC/>
     </AAA>
在XLab中打开实例 | 树视图 (JPG)

//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>
在XLab中打开实例 | 树视图 (JPG)

//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>

分享到：

怎样修改Servlet模版 | 常用服务器及其端口

2012-05-17 19:58
浏览 2433
评论(1)
分类:Web前端
查看更多

评论

1 楼 125348369 2012-10-26

请问他的官方网站是多少呀，找不到呢。郁闷呀

发表评论

您还没有登录,请您登录后再发表评论

相关推荐

XPath参考手册中文CHM版最新版本: 本文给大家带来XPath参考手册，需要的可以参考下！ XPath 路径表达式 XPath 使用路径表达式来选取 XML 文档中的节点或者节点集。这些路径表达式和我们在常规的电脑文件系统中看到的表达式非常相似。 XPath 标准...

参考手册xpath: 学习XPath时，可以参考W3CSchool提供的XPath2.0、XQuery1.0和XSLT2.0的内置函数参考手册。通过使用实例文档（如"books.xml"）进行实践，可以加深对XPath语法和表达式的理解。通过实例的展示，学习者可以掌握如何利用...

XPath详细参考手册: Xpath开发详细中文参考手册，帮助你快速查阅XPath语法

XPath参考手册.zip: XPath即为XML路径语言，它是一种用来确定XML（标准通用标记语言的子集）文档中某部分位置的语言。XPath基于XML的树状结构，提供在数据结构树中找寻节点的能力。起初 XPath 的提出的初衷是将其作为一个通用的、介于...

XPATH参考手册: "XPath参考手册" XPath 是一门在 XML 文档中查找信息的语言，XPath 可用来在 XML 文档中对元素和属性进行遍历。XPath 是 W3C XSLT 标准的主要元素，并且 XQuery 和 XPointer 同时被构建于 XPath 表达之上。因此，对...

XPath.chm参考手册: XPath.chm参考手册应该包含了XPath的详细语法、函数、轴、示例等内容，对于理解和使用XPath进行XML处理非常有帮助。通过学习这本手册，开发者可以更好地掌握XPath，从而在处理XML数据时更加高效和精准。

xpath手册: 介绍xpath的教程，通俗易懂

XPath CHM 手册: XPath参考手册，详细的介绍了XPath、XQuery 以及 XSLT函数。

xpath 依赖包及开发手册: 在这个“xpath 依赖包及开发手册”中，我们主要关注XPath的使用，以及相关的jar包和开发工具。首先，`jaxen-1.1.2-stable.jar`是一个关键的依赖包，它是XPath实现的一部分。Jaxen是一个Java库，提供了一个统一的...

xpath使用手册: 归纳整理的xpath使用手册，在自动化工作中，xpath使用很频繁。

XPath手册.chm: 从w3school下载。自己制作的一个xpath手册。csdn有个兄弟发布了一个，5分的，打开都看不到。于是自己做了一个，希望大家能喜欢。

XPATH 使用手册个人总结版本: 个人在学习 xpath 的过程中，记录的一些属性用法。关注公众号：pctansuo 中文名称：爬虫探索者可以获得 python 学习资料，相关资源

XPath 工具手册(语法、轴、函数等): XPath的工具性手册，非教程，适合对于XPath有初步了解，但对其中的全部功能不是很清楚的人。本人从网上搜集资料，整理而成，以分享。

XPath 教程(XPath Tutorial)多国语言帮助手册.rar: 在提供的压缩包中，除了XPath教程外，还有“XmlSchema标准参考手册”，这将帮助读者理解XML Schema，它是XML文档的结构定义语言，用于约束XML实例的结构和数据类型。jb51.net.txt可能是网站链接或其他相关信息，而...

XPath学习手册: 详尽描述XPath的各种使用方法。让xml操作更简单。

W3School离线手册中文版（web前端）: **W3School离线手册中文版（Web前端）** 该资源是W3School的中文离线版，专门针对Web前端开发提供详尽的技术参考和学习资料。W3School是全球知名的在线Web技术教程平台，其内容权威且全面，深受开发者喜爱。这份...

XPath快速上手手册.mht: 在博客园收藏的一个网页，说实话不能算是手册，但做为一个入门教程，写得非常通俗。

XPath依赖Jar包: XPath手册通常会包含更多详细的信息，比如XPath的完整语法、函数库的使用、命名空间的处理方法，以及各种复杂查询的实例，这对于初学者来说是非常有价值的参考资料。通过深入学习和实践，开发者可以熟练地利用XPath...

Global site tag (gtag.js) - Google Analytics