从入门到精通XPath XML数据解析实战指南

威震华夏关云长

1. XPath简介和基础概念

XPath（XML Path Language）是一种用于在XML文档中定位节点的语言。它提供了一种灵活的方式来导航XML文档的元素树结构，并选取节点或节点集。XPath最初是为XSLT设计的，但现在已成为许多XML相关技术的重要组成部分。

XML文档树结构

在了解XPath之前，我们需要理解XML文档的树结构。XML文档被视为一个树形结构，包含以下几种节点类型：

• 元素节点（Element Nodes）：XML文档中的元素，如<book>、<title>等。
• 属性节点（Attribute Nodes）：元素的属性，如category="COOKING"。
• 文本节点（Text Nodes）：元素中的文本内容，如”Everyday Italian”。
• 命名空间节点（Namespace Nodes）：与元素关联的命名空间。
• 处理指令节点（Processing Instruction Nodes）：如<?xml version="1.0"?>。
• 注释节点（Comment Nodes）：XML文档中的注释，如<!-- 这是一个注释 -->。
• 根节点（Root Nodes）：整个XML文档的根节点，是所有节点的祖先。

节点关系

在XML树结构中，节点之间存在以下关系：

• 父节点（Parent）：每个元素和属性都有一个父节点。
• 子节点（Children）：元素节点可以有零个或多个子节点。
• 兄弟节点（Siblings）：具有相同父节点的节点。
• 祖先节点（Ancestors）：一个节点的父节点、父节点的父节点等。
• 后代节点（Descendants）：一个节点的子节点、子节点的子节点等。

让我们通过一个示例XML文档来理解这些概念：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <bookstore>
4.   <book category="COOKING">
5.     <title lang="en">Everyday Italian</title>
6.     <author>Giada De Laurentiis</author>
7.     <year>2005</year>
8.     <price>30.00</price>
9.   </book>
10.   <book category="CHILDREN">
11.     <title lang="en">Harry Potter</title>
12.     <author>J.K. Rowling</author>
13.     <year>2005</year>
14.     <price>29.99</price>
15.   </book>
16. </bookstore>

复制代码

在这个例子中：

• bookstore是根节点，也是两个book元素的父节点。
• 两个book元素是兄弟节点，它们都是bookstore的子节点。
• 每个book元素包含四个子节点：title、author、year和price。
• category是book元素的属性节点。
• “Everyday Italian”是title元素的文本节点。

2. XPath语法和表达式

XPath使用路径表达式来选取XML文档中的节点。这些路径表达式类似于文件系统中的路径。

基本路径表达式

• nodename：选取所有名为nodename的子节点。
• /：从根节点选取。
• //：从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置。
• .：选取当前节点。
• ..：选取当前节点的父节点。
• @：选取属性。

让我们通过示例来理解这些基本表达式：

2. bookstore  /* 选取所有bookstore子节点 */
3. /bookstore /* 从根节点选取bookstore元素 */
4. bookstore/book /* 选取所有属于bookstore子元素的book元素 */
5. //book /* 选取所有book元素，不管它们在文档中的位置 */
6. bookstore//book /* 选取所有属于bookstore后代元素的book元素 */
7. //@lang /* 选取所有名为lang的属性 */

复制代码

谓语（Predicates）

谓语用于查找某个特定的节点或者包含某个指定值的节点。谓语被嵌在方括号[]中。

2. /bookstore/book[1] /* 选取属于bookstore子元素的第一个book元素 */
3. /bookstore/book[last()] /* 选取属于bookstore子元素的最后一个book元素 */
4. /bookstore/book[position()<3] /* 选取最前面的两个属于bookstore子元素的book元素 */
5. //title[@lang] /* 选取所有拥有名为lang的属性的title元素 */
6. //title[@lang='eng'] /* 选取所有title元素，且这些元素拥有值为eng的lang属性 */
7. /bookstore/book[price>35.00] /* 选取bookstore元素的所有book元素，且其中的price元素的值须大于35.00 */

复制代码

通配符

XPath支持通配符，用于选取未知的XML元素。

2. * /* 匹配任何元素节点 */
3. @* /* 匹配任何属性节点 */
4. node() /* 匹配任何类型的节点 */
6. /bookstore/* /* 选取bookstore元素的所有子元素 */
7. //* /* 选取文档中的所有元素 */
8. //title[@*] /* 选取所有带有属性的title元素 */

复制代码

多个路径

通过在XPath表达式中使用|运算符，你可以选取多个路径。

2. //book/title | //book/price /* 选取book元素的所有title和price元素 */
3. //title | //price /* 选取文档中的所有title和price元素 */
4. /bookstore/book/title | //price /* 选取属于bookstore元素的book元素的所有title元素，以及文档中所有的price元素 */

复制代码

3. XPath轴和节点测试

XPath轴定义了相对于当前节点的节点集。轴可以用来更精确地定位节点。

XPath轴

• ancestor：选取当前节点的所有祖先（父、祖父等）。
• ancestor-or-self：选取当前节点的所有祖先以及当前节点本身。
• attribute：选取当前节点的所有属性。
• child：选取当前节点的所有子元素。
• descendant：选取当前节点的所有后代（子、孙等）。
• descendant-or-self：选取当前节点的所有后代以及当前节点本身。
• following：选取文档中当前节点的结束标签之后的所有节点。
• following-sibling：选取当前节点之后的所有兄弟节点。
• namespace：选取当前节点的所有命名空间节点。
• parent：选取当前节点的父节点。
• preceding：选取文档中当前节点的开始标签之前的所有节点。
• preceding-sibling：选取当前节点之前的所有兄弟节点。
• self：选取当前节点。

节点测试

节点测试用于筛选轴中的节点。节点测试可以是节点名称、通配符或节点类型。

2. child::book /* 选取当前节点的所有book子节点 */
3. attribute::lang /* 选取当前节点的lang属性 */
4. child::* /* 选取当前节点的所有子元素 */
5. attribute::* /* 选取当前节点的所有属性 */
6. child::text() /* 选取当前节点的所有文本子节点 */
7. child::node() /* 选取当前节点的所有子节点 */
8. descendant::book /* 选取当前节点的所有book后代节点 */
9. ancestor::book /* 选取当前节点的所有book祖先节点 */
10. child::*/child::price /* 选取当前节点的所有price孙节点 */

复制代码

简写语法

XPath提供了一些简写语法，使得表达式更加简洁：

• child::可以省略，例如child::book可以简写为book。
• attribute::可以简写为@，例如attribute::lang可以简写为@lang。
• //是/descendant-or-self::node()/的简写。
• .是self::node()的简写。
• ..是parent::node()的简写。

4. XPath函数和运算符

XPath提供了丰富的函数库，用于处理字符串、数值、布尔值和节点集。

运算符

• 算术运算符：+（加）、-（减）、*（乘）、div（除）、mod（取余）
• 比较运算符：=（等于）、!=（不等于）、<（小于）、<=（小于等于）、>（大于）、>=（大于等于）
• 布尔运算符：and（与）、or（或）、not()（非）
• 其他运算符：|（并集，返回两个节点集的合并）

节点集函数

• last()：返回当前上下文中的最后一个节点的位置编号。
• position()：返回当前节点的位置编号。
• count(node-set)：返回节点集中的节点数。
• id(string)：返回具有唯一ID的元素节点，该ID由string参数指定。
• local-name(node-set)：返回节点集中第一个节点的本地名称（不带命名空间前缀）。
• namespace-uri(node-set)：返回节点集中第一个节点的命名空间URI。
• name(node-set)：返回节点集中第一个节点的完整名称（带命名空间前缀）。

字符串函数

• string(object)：将对象转换为字符串。
• concat(string, string, ...)：连接两个或多个字符串。
• starts-with(string, string)：如果第一个字符串以第二个字符串开头，则返回true。
• contains(string, string)：如果第一个字符串包含第二个字符串，则返回true。
• substring-before(string, string)：返回第一个字符串中在第二个字符串出现之前的部分。
• substring-after(string, string)：返回第一个字符串中在第二个字符串出现之后的部分。
• substring(string, start, length)：返回从start位置开始的指定长度的子字符串。
• string-length(string)：返回字符串的长度。
• normalize-space(string)：删除字符串前后的空白，并将连续的空白替换为单个空格。
• translate(string, string, string)：将第一个字符串中的字符替换为第三个字符串中对应位置的字符。

布尔函数

• boolean(object)：将对象转换为布尔值。
• not(boolean)：返回布尔值的反值。
• true()：返回true。
• false()：返回false。
• lang(string)：如果上下文节点的语言与指定的语言匹配，则返回true。

数值函数

• number(object)：将对象转换为数值。
• sum(node-set)：返回节点集中所有节点的数值之和。
• floor(number)：返回不大于number的最大整数。
• ceiling(number)：返回不小于number的最小整数。
• round(number)：返回最接近number的整数。

5. 实战案例：使用XPath解析XML

让我们通过一个实际的XML文档来演示XPath的使用。

示例XML文档

2. <?xml version="1.0" encoding="UTF-8"?>
3. <bookstore>
4.   <book category="COOKING">
5.     <title lang="en">Everyday Italian</title>
6.     <author>Giada De Laurentiis</author>
7.     <year>2005</year>
8.     <price>30.00</price>
9.   </book>
10.   <book category="CHILDREN">
11.     <title lang="en">Harry Potter</title>
12.     <author>J.K. Rowling</author>
13.     <year>2005</year>
14.     <price>29.99</price>
15.   </book>
16.   <book category="WEB">
17.     <title lang="en">XQuery Kick Start</title>
18.     <author>James McGovern</author>
19.     <author>Per Bothner</author>
20.     <author>Kurt Cagle</author>
21.     <author>James Linn</author>
22.     <author>Vaidyanathan Nagarajan</author>
23.     <year>2003</year>
24.     <price>49.99</price>
25.   </book>
26.   <book category="WEB">
27.     <title lang="en">Learning XML</title>
28.     <author>Erik T. Ray</author>
29.     <year>2003</year>
30.     <price>39.95</price>
31.   </book>
32. </bookstore>

复制代码

基本XPath查询示例

1. 选取根元素bookstore：/bookstore
2. 选取所有book元素：/bookstore/book
3. 选取所有book元素下的所有title元素：/bookstore/book/title
4. 选取所有book元素下的第一个title元素：/bookstore/book/title[1]
5. 选取所有带有category属性且值为WEB的book元素：/bookstore/book[@category='WEB']
6. 选取所有价格大于35的book元素：/bookstore/book[price>35]
7. 选取所有带有lang属性的title元素：//title[@lang]
8. 选取所有lang属性值为en的title元素：//title[@lang='en']

选取根元素bookstore：

2. /bookstore

复制代码

选取所有book元素：

2. /bookstore/book

复制代码

选取所有book元素下的所有title元素：

2. /bookstore/book/title

复制代码

选取所有book元素下的第一个title元素：

2. /bookstore/book/title[1]

复制代码

选取所有带有category属性且值为WEB的book元素：

2. /bookstore/book[@category='WEB']

复制代码

选取所有价格大于35的book元素：

2. /bookstore/book[price>35]

复制代码

选取所有带有lang属性的title元素：

2. //title[@lang]

复制代码

选取所有lang属性值为en的title元素：

2. //title[@lang='en']

复制代码

高级XPath查询示例

1. 选取所有价格大于35且category为WEB的book元素：/bookstore/book[@category='WEB' and price>35]
2. 选取所有价格大于30或category为CHILDREN的book元素：/bookstore/book[price>30 or @category='CHILDREN']
3. 选取所有title元素，其中title的文本包含”XML”：//title[contains(text(), 'XML')]
4. 选取所有title元素，其中title的文本以”Learning”开头：//title[starts-with(text(), 'Learning')]
5. 选取所有book元素，并按价格降序排列：/bookstore/book（注意：XPath 1.0本身不支持排序，但可以在XSLT或编程语言中实现）
6. 选取所有book元素，并计算它们的平均价格：sum(/bookstore/book/price) div count(/bookstore/book)
7. 选取所有book元素，并找出价格最高的book：/bookstore/book[price = max(/bookstore/book/price)]（注意：max()函数是XPath 2.0引入的，XPath 1.0中需要使用其他方法）
8. 选取所有包含多个作者的book元素：/bookstore/book[count(author) > 1]

选取所有价格大于35且category为WEB的book元素：

2. /bookstore/book[@category='WEB' and price>35]

复制代码

选取所有价格大于30或category为CHILDREN的book元素：

2. /bookstore/book[price>30 or @category='CHILDREN']

复制代码

选取所有title元素，其中title的文本包含”XML”：

2. //title[contains(text(), 'XML')]

复制代码

选取所有title元素，其中title的文本以”Learning”开头：

2. //title[starts-with(text(), 'Learning')]

复制代码

选取所有book元素，并按价格降序排列：

2. /bookstore/book

复制代码

（注意：XPath 1.0本身不支持排序，但可以在XSLT或编程语言中实现）

选取所有book元素，并计算它们的平均价格：

2. sum(/bookstore/book/price) div count(/bookstore/book)

复制代码

选取所有book元素，并找出价格最高的book：

2. /bookstore/book[price = max(/bookstore/book/price)]

复制代码

（注意：max()函数是XPath 2.0引入的，XPath 1.0中需要使用其他方法）

选取所有包含多个作者的book元素：

2. /bookstore/book[count(author) > 1]

复制代码

使用XPath处理命名空间

当XML文档使用命名空间时，XPath查询需要考虑命名空间。

示例XML文档（带命名空间）：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <ns:bookstore xmlns:ns="http://example.com/bookstore">
4.   <ns:book category="COOKING">
5.     <ns:title lang="en">Everyday Italian</ns:title>
6.     <ns:author>Giada De Laurentiis</ns:author>
7.     <ns:year>2005</ns:year>
8.     <ns:price>30.00</ns:price>
9.   </ns:book>
10.   <ns:book category="CHILDREN">
11.     <ns:title lang="en">Harry Potter</ns:title>
12.     <ns:author>J.K. Rowling</ns:author>
13.     <ns:year>2005</ns:year>
14.     <ns:price>29.99</ns:price>
15.   </ns:book>
16. </ns:bookstore>

复制代码

XPath查询示例：

1. 选取所有book元素（需要使用命名空间前缀）：//ns:book
2. 选取所有title元素（需要使用命名空间前缀）：//ns:title

选取所有book元素（需要使用命名空间前缀）：

2. //ns:book

复制代码

选取所有title元素（需要使用命名空间前缀）：

2. //ns:title

复制代码

注意：在实际应用中，命名空间前缀需要与XML处理器中注册的命名空间URI匹配。

6. XPath在不同编程语言中的应用

XPath不仅是一种查询语言，还可以在各种编程语言中使用。下面我们将介绍如何在几种常见的编程语言中使用XPath。

Python中使用XPath

Python中有多个库支持XPath，最常用的是lxml库。

2. pip install lxml

复制代码

2. from lxml import etree
4. # 示例XML文档
5. xml_doc = """
6. <?xml version="1.0" encoding="UTF-8"?>
7. <bookstore>
8.   <book category="COOKING">
9.     <title lang="en">Everyday Italian</title>
10.     <author>Giada De Laurentiis</author>
11.     <year>2005</year>
12.     <price>30.00</price>
13.   </book>
14.   <book category="CHILDREN">
15.     <title lang="en">Harry Potter</title>
16.     <author>J.K. Rowling</author>
17.     <year>2005</year>
18.     <price>29.99</price>
19.   </book>
20.   <book category="WEB">
21.     <title lang="en">XQuery Kick Start</title>
22.     <author>James McGovern</author>
23.     <author>Per Bothner</author>
24.     <author>Kurt Cagle</author>
25.     <author>James Linn</author>
26.     <author>Vaidyanathan Nagarajan</author>
27.     <year>2003</year>
28.     <price>49.99</price>
29.   </book>
30.   <book category="WEB">
31.     <title lang="en">Learning XML</title>
32.     <author>Erik T. Ray</author>
33.     <year>2003</year>
34.     <price>39.95</price>
35.   </book>
36. </bookstore>
37. """
39. # 解析XML文档
40. tree = etree.fromstring(xml_doc.encode('utf-8'))
42. # 1. 选取所有book元素
43. books = tree.xpath('//book')
44. print(f"Total books: {len(books)}")
46. # 2. 选取所有title元素
47. titles = tree.xpath('//title/text()')
48. print("All titles:")
49. for title in titles:
50.     print(f"- {title}")
52. # 3. 选取所有category为WEB的book元素
53. web_books = tree.xpath('//book[@category="WEB"]')
54. print("\nWeb books:")
55. for book in web_books:
56.     title = book.xpath('title/text()')[0]
57.     price = book.xpath('price/text()')[0]
58.     print(f"- {title}: {price}")
60. # 4. 选取价格大于35的book元素
61. expensive_books = tree.xpath('//book[price>35]')
62. print("\nExpensive books:")
63. for book in expensive_books:
64.     title = book.xpath('title/text()')[0]
65.     price = book.xpath('price/text()')[0]
66.     print(f"- {title}: {price}")
68. # 5. 计算所有book的平均价格
69. prices = tree.xpath('//price/text()')
70. total = sum(float(price) for price in prices)
71. average = total / len(prices)
72. print(f"\nAverage price: {average:.2f}")
74. # 6. 使用XPath函数
75. # 选取所有title元素，其中title的文本包含"XML"
76. xml_titles = tree.xpath('//title[contains(text(), "XML")]/text()')
77. print("\nTitles containing 'XML':")
78. for title in xml_titles:
79.     print(f"- {title}")

复制代码

Java中使用XPath

Java内置了对XPath的支持，主要通过javax.xml.xpath包。

2. import javax.xml.parsers.DocumentBuilder;
3. import javax.xml.parsers.DocumentBuilderFactory;
4. import javax.xml.xpath.XPath;
5. import javax.xml.xpath.XPathConstants;
6. import javax.xml.xpath.XPathExpression;
7. import javax.xml.xpath.XPathFactory;
8. import org.w3c.dom.Document;
9. import org.w3c.dom.NodeList;
11. public class XPathExample {
12.     public static void main(String[] args) throws Exception {
13.         // 示例XML文档
14.         String xml = "<?xml version="1.0" encoding="UTF-8"?>\n" +
15.                 "<bookstore>\n" +
16.                 "  <book category="COOKING">\n" +
17.                 "    <title lang="en">Everyday Italian</title>\n" +
18.                 "    <author>Giada De Laurentiis</author>\n" +
19.                 "    <year>2005</year>\n" +
20.                 "    <price>30.00</price>\n" +
21.                 "  </book>\n" +
22.                 "  <book category="CHILDREN">\n" +
23.                 "    <title lang="en">Harry Potter</title>\n" +
24.                 "    <author>J.K. Rowling</author>\n" +
25.                 "    <year>2005</year>\n" +
26.                 "    <price>29.99</price>\n" +
27.                 "  </book>\n" +
28.                 "  <book category="WEB">\n" +
29.                 "    <title lang="en">XQuery Kick Start</title>\n" +
30.                 "    <author>James McGovern</author>\n" +
31.                 "    <author>Per Bothner</author>\n" +
32.                 "    <author>Kurt Cagle</author>\n" +
33.                 "    <author>James Linn</author>\n" +
34.                 "    <author>Vaidyanathan Nagarajan</author>\n" +
35.                 "    <year>2003</year>\n" +
36.                 "    <price>49.99</price>\n" +
37.                 "  </book>\n" +
38.                 "  <book category="WEB">\n" +
39.                 "    <title lang="en">Learning XML</title>\n" +
40.                 "    <author>Erik T. Ray</author>\n" +
41.                 "    <year>2003</year>\n" +
42.                 "    <price>39.95</price>\n" +
43.                 "  </book>\n" +
44.                 "</bookstore>";
46.         // 解析XML文档
47.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
48.         DocumentBuilder builder = factory.newDocumentBuilder();
49.         Document document = builder.parse(new java.io.ByteArrayInputStream(xml.getBytes()));
51.         // 创建XPath对象
52.         XPathFactory xPathFactory = XPathFactory.newInstance();
53.         XPath xpath = xPathFactory.newXPath();
55.         // 1. 选取所有book元素
56.         XPathExpression expr = xpath.compile("//book");
57.         NodeList books = (NodeList) expr.evaluate(document, XPathConstants.NODESET);
58.         System.out.println("Total books: " + books.getLength());
60.         // 2. 选取所有title元素的文本内容
61.         expr = xpath.compile("//title/text()");
62.         NodeList titles = (NodeList) expr.evaluate(document, XPathConstants.NODESET);
63.         System.out.println("\nAll titles:");
64.         for (int i = 0; i < titles.getLength(); i++) {
65.             System.out.println("- " + titles.item(i).getNodeValue());
66.         }
68.         // 3. 选取所有category为WEB的book元素
69.         expr = xpath.compile("//book[@category='WEB']");
70.         NodeList webBooks = (NodeList) expr.evaluate(document, XPathConstants.NODESET);
71.         System.out.println("\nWeb books:");
72.         for (int i = 0; i < webBooks.getLength(); i++) {
73.             String title = xpath.evaluate("title/text()", webBooks.item(i));
74.             String price = xpath.evaluate("price/text()", webBooks.item(i));
75.             System.out.println("- " + title + ": " + price);
76.         }
78.         // 4. 选取价格大于35的book元素
79.         expr = xpath.compile("//book[price>35]");
80.         NodeList expensiveBooks = (NodeList) expr.evaluate(document, XPathConstants.NODESET);
81.         System.out.println("\nExpensive books:");
82.         for (int i = 0; i < expensiveBooks.getLength(); i++) {
83.             String title = xpath.evaluate("title/text()", expensiveBooks.item(i));
84.             String price = xpath.evaluate("price/text()", expensiveBooks.item(i));
85.             System.out.println("- " + title + ": " + price);
86.         }
88.         // 5. 计算所有book的平均价格
89.         expr = xpath.compile("sum(//price) div count(//book)");
90.         Double average = (Double) expr.evaluate(document, XPathConstants.NUMBER);
91.         System.out.printf("\nAverage price: %.2f\n", average);
93.         // 6. 使用XPath函数
94.         // 选取所有title元素，其中title的文本包含"XML"
95.         expr = xpath.compile("//title[contains(text(), 'XML')]/text()");
96.         NodeList xmlTitles = (NodeList) expr.evaluate(document, XPathConstants.NODESET);
97.         System.out.println("\nTitles containing 'XML':");
98.         for (int i = 0; i < xmlTitles.getLength(); i++) {
99.             System.out.println("- " + xmlTitles.item(i).getNodeValue());
100.         }
101.     }
102. }

复制代码

JavaScript中使用XPath

在浏览器环境中，可以使用document.evaluate()方法来执行XPath查询。

2. <!DOCTYPE html>
3. <html>
4. <head>
5.     <title>XPath Example</title>
6. </head>
7. <body>
8.     <div id="result"></div>
10.     <script>
11.         // 示例XML文档
12.         const xmlString = `
13.         <?xml version="1.0" encoding="UTF-8"?>
14.         <bookstore>
15.           <book category="COOKING">
16.             <title lang="en">Everyday Italian</title>
17.             <author>Giada De Laurentiis</author>
18.             <year>2005</year>
19.             <price>30.00</price>
20.           </book>
21.           <book category="CHILDREN">
22.             <title lang="en">Harry Potter</title>
23.             <author>J.K. Rowling</author>
24.             <year>2005</year>
25.             <price>29.99</price>
26.           </book>
27.           <book category="WEB">
28.             <title lang="en">XQuery Kick Start</title>
29.             <author>James McGovern</author>
30.             <author>Per Bothner</author>
31.             <author>Kurt Cagle</author>
32.             <author>James Linn</author>
33.             <author>Vaidyanathan Nagarajan</author>
34.             <year>2003</year>
35.             <price>49.99</price>
36.           </book>
37.           <book category="WEB">
38.             <title lang="en">Learning XML</title>
39.             <author>Erik T. Ray</author>
40.             <year>2003</year>
41.             <price>39.95</price>
42.           </book>
43.         </bookstore>
44.         `;
46.         // 解析XML文档
47.         const parser = new DOMParser();
48.         const xmlDoc = parser.parseFromString(xmlString, "text/xml");
49.         
50.         // 创建结果容器
51.         const resultDiv = document.getElementById('result');
52.         let html = '';
54.         // 辅助函数：执行XPath查询并返回结果
55.         function evaluateXPath(xpath, contextNode = xmlDoc, resultType = XPathResult.ANY_TYPE) {
56.             return document.evaluate(xpath, contextNode, null, resultType, null);
57.         }
59.         // 1. 选取所有book元素
60.         const books = evaluateXPath('//book', xmlDoc, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
61.         html += `<p>Total books: ${books.snapshotLength}</p>`;
63.         // 2. 选取所有title元素的文本内容
64.         const titles = evaluateXPath('//title/text()', xmlDoc, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
65.         html += '<p>All titles:</p><ul>';
66.         for (let i = 0; i < titles.snapshotLength; i++) {
67.             html += `<li>${titles.snapshotItem(i).nodeValue}</li>`;
68.         }
69.         html += '</ul>';
71.         // 3. 选取所有category为WEB的book元素
72.         const webBooks = evaluateXPath('//book[@category="WEB"]', xmlDoc, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
73.         html += '<p>Web books:</p><ul>';
74.         for (let i = 0; i < webBooks.snapshotLength; i++) {
75.             const book = webBooks.snapshotItem(i);
76.             const title = evaluateXPath('title/text()', book, XPathResult.STRING_TYPE).stringValue;
77.             const price = evaluateXPath('price/text()', book, XPathResult.STRING_TYPE).stringValue;
78.             html += `<li>${title}: ${price}</li>`;
79.         }
80.         html += '</ul>';
82.         // 4. 选取价格大于35的book元素
83.         const expensiveBooks = evaluateXPath('//book[price>35]', xmlDoc, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
84.         html += '<p>Expensive books:</p><ul>';
85.         for (let i = 0; i < expensiveBooks.snapshotLength; i++) {
86.             const book = expensiveBooks.snapshotItem(i);
87.             const title = evaluateXPath('title/text()', book, XPathResult.STRING_TYPE).stringValue;
88.             const price = evaluateXPath('price/text()', book, XPathResult.STRING_TYPE).stringValue;
89.             html += `<li>${title}: ${price}</li>`;
90.         }
91.         html += '</ul>';
93.         // 5. 计算所有book的平均价格
94.         const prices = evaluateXPath('//price/text()', xmlDoc, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
95.         let total = 0;
96.         for (let i = 0; i < prices.snapshotLength; i++) {
97.             total += parseFloat(prices.snapshotItem(i).nodeValue);
98.         }
99.         const average = total / prices.snapshotLength;
100.         html += `<p>Average price: ${average.toFixed(2)}</p>`;
102.         // 6. 使用XPath函数
103.         // 选取所有title元素，其中title的文本包含"XML"
104.         const xmlTitles = evaluateXPath('//title[contains(text(), "XML")]/text()', xmlDoc, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
105.         html += '<p>Titles containing "XML":</p><ul>';
106.         for (let i = 0; i < xmlTitles.snapshotLength; i++) {
107.             html += `<li>${xmlTitles.snapshotItem(i).nodeValue}</li>`;
108.         }
109.         html += '</ul>';
111.         // 显示结果
112.         resultDiv.innerHTML = html;
113.     </script>
114. </body>
115. </html>

复制代码

C#中使用XPath

在.NET框架中，可以使用System.Xml.XPath命名空间中的类来处理XPath查询。

2. using System;
3. using System.Xml;
4. using System.Xml.XPath;
6. class XPathExample
7. {
8.     static void Main()
9.     {
10.         // 示例XML文档
11.         string xml = @"<?xml version=""1.0"" encoding=""UTF-8""?>
12. <bookstore>
13.   <book category=""COOKING"">
14.     <title lang=""en"">Everyday Italian</title>
15.     <author>Giada De Laurentiis</author>
16.     <year>2005</year>
17.     <price>30.00</price>
18.   </book>
19.   <book category=""CHILDREN"">
20.     <title lang=""en"">Harry Potter</title>
21.     <author>J.K. Rowling</author>
22.     <year>2005</year>
23.     <price>29.99</price>
24.   </book>
25.   <book category=""WEB"">
26.     <title lang=""en"">XQuery Kick Start</title>
27.     <author>James McGovern</author>
28.     <author>Per Bothner</author>
29.     <author>Kurt Cagle</author>
30.     <author>James Linn</author>
31.     <author>Vaidyanathan Nagarajan</author>
32.     <year>2003</year>
33.     <price>49.99</price>
34.   </book>
35.   <book category=""WEB"">
36.     <title lang=""en"">Learning XML</title>
37.     <author>Erik T. Ray</author>
38.     <year>2003</year>
39.     <price>39.95</price>
40.   </book>
41. </bookstore>";
43.         // 加载XML文档
44.         XmlDocument doc = new XmlDocument();
45.         doc.LoadXml(xml);
47.         // 创建XPath导航器
48.         XPathNavigator navigator = doc.CreateNavigator();
50.         // 1. 选取所有book元素
51.         XPathNodeIterator books = navigator.Select("//book");
52.         Console.WriteLine($"Total books: {books.Count}");
54.         // 2. 选取所有title元素的文本内容
55.         XPathNodeIterator titles = navigator.Select("//title/text()");
56.         Console.WriteLine("\nAll titles:");
57.         while (titles.MoveNext())
58.         {
59.             Console.WriteLine($"- {titles.Current.Value}");
60.         }
62.         // 3. 选取所有category为WEB的book元素
63.         XPathNodeIterator webBooks = navigator.Select("//book[@category='WEB']");
64.         Console.WriteLine("\nWeb books:");
65.         while (webBooks.MoveNext())
66.         {
67.             XPathNavigator book = webBooks.Current;
68.             string title = book.SelectSingleNode("title/text()").Value;
69.             string price = book.SelectSingleNode("price/text()").Value;
70.             Console.WriteLine($"- {title}: {price}");
71.         }
73.         // 4. 选取价格大于35的book元素
74.         XPathNodeIterator expensiveBooks = navigator.Select("//book[price>35]");
75.         Console.WriteLine("\nExpensive books:");
76.         while (expensiveBooks.MoveNext())
77.         {
78.             XPathNavigator book = expensiveBooks.Current;
79.             string title = book.SelectSingleNode("title/text()").Value;
80.             string price = book.SelectSingleNode("price/text()").Value;
81.             Console.WriteLine($"- {title}: {price}");
82.         }
84.         // 5. 计算所有book的平均价格
85.         double total = (double)navigator.Evaluate("sum(//price)");
86.         int count = (int)navigator.Evaluate("count(//book)");
87.         double average = total / count;
88.         Console.WriteLine($"\nAverage price: {average:F2}");
90.         // 6. 使用XPath函数
91.         // 选取所有title元素，其中title的文本包含"XML"
92.         XPathNodeIterator xmlTitles = navigator.Select("//title[contains(text(), 'XML')]/text()");
93.         Console.WriteLine("\nTitles containing 'XML':");
94.         while (xmlTitles.MoveNext())
95.         {
96.             Console.WriteLine($"- {xmlTitles.Current.Value}");
97.         }
98.     }
99. }

复制代码

7. 高级技巧和最佳实践

处理大型XML文档

当处理大型XML文档时，内存使用可能成为一个问题。以下是一些处理大型XML文档的技巧：

1. 使用流式处理：对于非常大的XML文件，考虑使用SAX（Simple API for XML）或StAX（Streaming API for XML）等流式处理方法，而不是DOM（Document Object Model）。
2. 使用XPath优化查询：尽量使用具体的路径表达式，避免使用//，因为它会搜索整个文档。
3. 分块处理：如果可能，将大型XML文档分成较小的块进行处理。
4. 使用XPath的谓词：使用谓词来限制结果集的大小，减少内存使用。

使用流式处理：对于非常大的XML文件，考虑使用SAX（Simple API for XML）或StAX（Streaming API for XML）等流式处理方法，而不是DOM（Document Object Model）。

使用XPath优化查询：尽量使用具体的路径表达式，避免使用//，因为它会搜索整个文档。

分块处理：如果可能，将大型XML文档分成较小的块进行处理。

使用XPath的谓词：使用谓词来限制结果集的大小，减少内存使用。

处理命名空间

处理带有命名空间的XML文档时，需要特别注意：

1. 注册命名空间：在使用XPath查询之前，确保所有相关的命名空间都已注册。
2. 使用命名空间前缀：在XPath表达式中使用命名空间前缀来限定元素和属性名称。
3. 避免使用local-name()函数：虽然可以使用local-name()函数来忽略命名空间，但这会使查询变得脆弱，因为XML结构的变化可能会破坏查询。

注册命名空间：在使用XPath查询之前，确保所有相关的命名空间都已注册。

使用命名空间前缀：在XPath表达式中使用命名空间前缀来限定元素和属性名称。

避免使用local-name()函数：虽然可以使用local-name()函数来忽略命名空间，但这会使查询变得脆弱，因为XML结构的变化可能会破坏查询。

XPath性能优化

以下是一些优化XPath性能的技巧：

1. 使用具体的路径：尽量使用具体的路径表达式，而不是通配符。
2. 避免在谓词中使用复杂表达式：谓词中的复杂表达式可能会降低性能。
3. 使用索引：如果XML处理器支持索引，确保对经常查询的元素和属性建立索引。
4. 缓存查询结果：如果多次使用相同的查询结果，考虑缓存它们。
5. 使用XPath 2.0或更高版本：如果可能，使用XPath 2.0或更高版本，因为它们提供了更多的优化和功能。

使用具体的路径：尽量使用具体的路径表达式，而不是通配符。

避免在谓词中使用复杂表达式：谓词中的复杂表达式可能会降低性能。

使用索引：如果XML处理器支持索引，确保对经常查询的元素和属性建立索引。

缓存查询结果：如果多次使用相同的查询结果，考虑缓存它们。

使用XPath 2.0或更高版本：如果可能，使用XPath 2.0或更高版本，因为它们提供了更多的优化和功能。

XPath与XSLT结合使用

XPath通常与XSLT（Extensible Stylesheet Language Transformations）结合使用，以转换XML文档。以下是一些结合使用XPath和XSLT的技巧：

1. 使用XPath模板匹配：在XSLT中使用XPath来匹配模板。
2. 使用XPath变量：在XSLT中定义XPath变量，以简化复杂的表达式。
3. 使用XPath键：在XSLT中使用xsl:key和key()函数来创建索引，提高查询性能。
4. 使用XPath函数：利用XPath函数库来处理字符串、数值和布尔值。

使用XPath模板匹配：在XSLT中使用XPath来匹配模板。

使用XPath变量：在XSLT中定义XPath变量，以简化复杂的表达式。

使用XPath键：在XSLT中使用xsl:key和key()函数来创建索引，提高查询性能。

使用XPath函数：利用XPath函数库来处理字符串、数值和布尔值。

XPath与XQuery结合使用

XQuery是一种用于查询XML数据的语言，它扩展了XPath的功能。以下是一些结合使用XPath和XQuery的技巧：

1. 使用FLWOR表达式：XQuery的FLWOR（For, Let, Where, Order by, Return）表达式提供了比XPath更强大的查询能力。
2. 使用XPath作为XQuery的基础：XQuery使用XPath来定位节点，因此XPath的知识对于使用XQuery至关重要。
3. 使用XQuery函数：XQuery提供了比XPath更丰富的函数库，可以用于更复杂的数据处理。

使用FLWOR表达式：XQuery的FLWOR（For, Let, Where, Order by, Return）表达式提供了比XPath更强大的查询能力。

使用XPath作为XQuery的基础：XQuery使用XPath来定位节点，因此XPath的知识对于使用XQuery至关重要。

使用XQuery函数：XQuery提供了比XPath更丰富的函数库，可以用于更复杂的数据处理。

8. 性能优化和常见问题解决

XPath性能优化

1. 避免使用//：//操作符会搜索整个文档，这可能会很慢。尽量使用具体的路径。
2. 使用谓词限制结果：使用谓词来限制结果集的大小，减少内存使用。
3. 避免在谓词中使用复杂表达式：谓词中的复杂表达式可能会降低性能。
4. 使用索引：如果XML处理器支持索引，确保对经常查询的元素和属性建立索引。
5. 缓存查询结果：如果多次使用相同的查询结果，考虑缓存它们。

避免使用//：//操作符会搜索整个文档，这可能会很慢。尽量使用具体的路径。

使用谓词限制结果：使用谓词来限制结果集的大小，减少内存使用。

避免在谓词中使用复杂表达式：谓词中的复杂表达式可能会降低性能。

使用索引：如果XML处理器支持索引，确保对经常查询的元素和属性建立索引。

缓存查询结果：如果多次使用相同的查询结果，考虑缓存它们。

常见问题解决

1. 命名空间问题：问题：XPath查询无法找到带有命名空间的元素。解决方案：确保在XPath查询中正确使用命名空间前缀，并在XML处理器中注册命名空间。
2. 问题：XPath查询无法找到带有命名空间的元素。
3. 解决方案：确保在XPath查询中正确使用命名空间前缀，并在XML处理器中注册命名空间。
4. 大小写敏感问题：问题：XPath查询对元素和属性名称的大小写敏感。解决方案：确保XPath表达式中的大小写与XML文档中的大小写匹配。
5. 问题：XPath查询对元素和属性名称的大小写敏感。
6. 解决方案：确保XPath表达式中的大小写与XML文档中的大小写匹配。
7. 上下文问题：问题：XPath查询返回意外的结果，可能是由于上下文不正确。解决方案：确保在正确的上下文中执行XPath查询，可以使用.和..来导航到正确的节点。
8. 问题：XPath查询返回意外的结果，可能是由于上下文不正确。
9. 解决方案：确保在正确的上下文中执行XPath查询，可以使用.和..来导航到正确的节点。
10. 数据类型问题：问题：XPath查询中的数值比较不工作。解决方案：确保数值比较中的值确实是数值类型，可以使用number()函数进行转换。
11. 问题：XPath查询中的数值比较不工作。
12. 解决方案：确保数值比较中的值确实是数值类型，可以使用number()函数进行转换。
13. 特殊字符问题：问题：XPath查询中的特殊字符（如<,>,&等）导致错误。解决方案：使用XML实体或CDATA来处理特殊字符。
14. 问题：XPath查询中的特殊字符（如<,>,&等）导致错误。
15. 解决方案：使用XML实体或CDATA来处理特殊字符。

命名空间问题：

• 问题：XPath查询无法找到带有命名空间的元素。
• 解决方案：确保在XPath查询中正确使用命名空间前缀，并在XML处理器中注册命名空间。

大小写敏感问题：

• 问题：XPath查询对元素和属性名称的大小写敏感。
• 解决方案：确保XPath表达式中的大小写与XML文档中的大小写匹配。

上下文问题：

• 问题：XPath查询返回意外的结果，可能是由于上下文不正确。
• 解决方案：确保在正确的上下文中执行XPath查询，可以使用.和..来导航到正确的节点。

数据类型问题：

• 问题：XPath查询中的数值比较不工作。
• 解决方案：确保数值比较中的值确实是数值类型，可以使用number()函数进行转换。

特殊字符问题：

• 问题：XPath查询中的特殊字符（如<,>,&等）导致错误。
• 解决方案：使用XML实体或CDATA来处理特殊字符。

调试XPath查询

调试XPath查询可能会很困难，以下是一些调试技巧：

1. 使用XPath测试工具：有许多在线和离线的XPath测试工具，可以帮助你测试和调试XPath表达式。
2. 分步调试：将复杂的XPath表达式分解为较小的部分，逐步测试每个部分。
3. 使用count()函数：使用count()函数来检查XPath表达式返回的节点数量。
4. 使用name()函数：使用name()函数来检查节点的名称。
5. 使用string()函数：使用string()函数来检查节点的文本内容。

使用XPath测试工具：有许多在线和离线的XPath测试工具，可以帮助你测试和调试XPath表达式。

分步调试：将复杂的XPath表达式分解为较小的部分，逐步测试每个部分。

使用count()函数：使用count()函数来检查XPath表达式返回的节点数量。

使用name()函数：使用name()函数来检查节点的名称。

使用string()函数：使用string()函数来检查节点的文本内容。

XPath与其他技术的比较

XPath与其他XML处理技术相比，有其优缺点：

1. XPath vs. DOM：XPath：更简洁，更易于编写和维护，适合查询和提取数据。DOM：提供更全面的文档操作能力，适合修改文档结构。
2. XPath：更简洁，更易于编写和维护，适合查询和提取数据。
3. DOM：提供更全面的文档操作能力，适合修改文档结构。
4. XPath vs. SAX：XPath：更适合随机访问和查询XML文档。SAX：更适合顺序处理大型XML文档，内存效率更高。
5. XPath：更适合随机访问和查询XML文档。
6. SAX：更适合顺序处理大型XML文档，内存效率更高。
7. XPath vs. XQuery：XPath：更简单，适合简单的查询和提取数据。XQuery：更强大，适合复杂的查询和转换XML数据。
8. XPath：更简单，适合简单的查询和提取数据。
9. XQuery：更强大，适合复杂的查询和转换XML数据。
10. XPath vs. JSONPath：XPath：用于XML文档，功能更强大。JSONPath：用于JSON文档，语法更简单。
11. XPath：用于XML文档，功能更强大。
12. JSONPath：用于JSON文档，语法更简单。

XPath vs. DOM：

• XPath：更简洁，更易于编写和维护，适合查询和提取数据。
• DOM：提供更全面的文档操作能力，适合修改文档结构。

XPath vs. SAX：

• XPath：更适合随机访问和查询XML文档。
• SAX：更适合顺序处理大型XML文档，内存效率更高。

XPath vs. XQuery：

• XPath：更简单，适合简单的查询和提取数据。
• XQuery：更强大，适合复杂的查询和转换XML数据。

XPath vs. JSONPath：

• XPath：用于XML文档，功能更强大。
• JSONPath：用于JSON文档，语法更简单。

总结

XPath是一种强大的查询语言，用于在XML文档中定位和提取数据。它提供了丰富的语法和函数库，可以处理各种复杂的查询需求。通过本文的介绍，你应该已经了解了XPath的基本概念、语法、函数和高级技巧，以及如何在不同的编程语言中使用XPath。

要精通XPath，需要不断练习和实践。尝试使用XPath来解析各种XML文档，解决实际问题，这将帮助你更好地理解和掌握XPath。同时，关注XPath的最新发展，如XPath 3.1，它引入了许多新功能和改进。

XPath是XML技术栈中的重要组成部分，掌握它将使你能够更有效地处理和利用XML数据。无论是在Web开发、数据集成还是文档处理中，XPath都是一个非常有用的工具。

版权声明

1、转载或引用本网站内容(从入门到精通XPath XML数据解析实战指南)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://pixtech.cc/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://pixtech.cc/thread-38204-1-1.html