XSLT如何对节点进行分组操作？-XML/RSS教程-PHP中文网

XSLT分组主要有两种方式：XSLT 2.0+使用for-each-group指令，通过group-by等属性实现直观高效的分组；XSLT 1.0则依赖Muenchian Grouping，利用key()和generate-id()筛选每组首个节点，虽复杂但有效。

xslt如何对节点进行分组操作？

XSLT对节点进行分组操作，核心上来说，主要有两种主流方式：对于XSLT 2.0及更高版本，我们有强大的

for-each-group

登录后复制

指令，它极大地简化了分组逻辑；而在XSLT 1.0时代，则需要依赖一种被称为Muenchian Grouping（门兴分组）的技巧，通过

key()

登录后复制

函数和

generate-id()

登录后复制

的组合来实现。

解决方案

要对XSLT中的节点进行分组，我们通常会根据某个节点的特定属性值、子节点内容或者计算出的某个键值来组织相关的节点集合。这在数据转换中非常常见，比如把扁平化的数据转换成带有层级结构的报告。

1. XSLT 2.0+ 中的

for-each-group

登录后复制

指令

这是现代XSLT处理分组的首选方式，它直观且强大。

for-each-group

登录后复制

允许你指定一个节点集合，然后根据一个表达式对这些节点进行分组。

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:output method="xml" indent="yes"/>

  <xsl:template match="/root">
    <grouped-data>
      <!-- 根据'category'属性进行分组 -->
      <xsl:for-each-group select="item" group-by="@category">
        <category-group name="{current-grouping-key()}">
          <xsl:for-each select="current-group()">
            <item-detail id="{@id}">
              <name><xsl:value-of select="name"/></name>
              <price><xsl:value-of select="price"/></price>
            </item-detail>
          </xsl:for-each>
        </category-group>
      </xsl:for-each-group>
    </grouped-data>
  </xsl:template>

</xsl:stylesheet>

登录后复制

对应这个XML输入：

<root>
  <item id="A001" category="Electronics">
    <name>Laptop</name>
    <price>1200</price>
  </item>
  <item id="A002" category="Books">
    <name>XSLT Cookbook</name>
    <price>45</price>
  </item>
  <item id="A003" category="Electronics">
    <name>Mouse</name>
    <price>25</price>
  </item>
  <item id="A004" category="Books">
    <name>XML Basics</name>
    <price>30</price>
  </item>
</root>

登录后复制

输出会是：

<grouped-data>
   <category-group name="Electronics">
      <item-detail id="A001">
         <name>Laptop</name>
         <price>1200</price>
      </item-detail>
      <item-detail id="A003">
         <name>Mouse</name>
         <price>25</price>
      </item-detail>
   </category-group>
   <category-group name="Books">
      <item-detail id="A002">
         <name>XSLT Cookbook</name>
         <price>45</price>
      </item-detail>
      <item-detail id="A004">
         <name>XML Basics</name>
         <price>30</price>
      </item-detail>
   </category-group>
</grouped-data>

登录后复制

group-by

登录后复制

属性定义了分组的依据。

current-grouping-key()

登录后复制

用于获取当前组的键值，而

current-group()

登录后复制

则返回当前组中的所有节点。

2. XSLT 1.0 中的 Muenchian Grouping（键控分组）

在没有

for-each-group

登录后复制

的日子里，Muenchian Grouping是实现分组的“黑魔法”。它利用了

key()

登录后复制

函数能够高效查找节点，以及

generate-id()

登录后复制

函数为每个节点生成唯一ID的特性。其核心思想是：只处理每个分组的“第一个”节点。

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:output method="xml" indent="yes"/>

  <!-- 定义一个键，用于按'category'属性查找item节点 -->
  <xsl:key name="items-by-category" match="item" use="@category"/>

  <xsl:template match="/root">
    <grouped-data>
      <!-- 遍历所有item节点，但只选择每个分组的第一个节点 -->
      <xsl:for-each select="item[count(. | key('items-by-category', @category)[1]) = 1]">
        <xsl:variable name="currentCategory" select="@category"/>
        <category-group name="{$currentCategory}">
          <!-- 遍历当前分组的所有节点 -->
          <xsl:for-each select="key('items-by-category', $currentCategory)">
            <item-detail id="{@id}">
              <name><xsl:value-of select="name"/></name>
              <price><xsl:value-of select="price"/></price>
            </item-detail>
          </xsl:for-each>
        </category-group>
      </xsl:for-each>
    </grouped-data>
  </xsl:template>

</xsl:stylesheet>

登录后复制

使用与上面相同的XML输入，输出结果会是一致的。这里的

item[count(. | key('items-by-category', @category)[1]) = 1]

登录后复制

是Muenchian Grouping的精髓，它巧妙地筛选出每个分组的“领导者”节点。

XSLT 2.0+中如何使用

for-each-group

登录后复制

进行高效分组？

老实说，自从XSLT 2.0引入

for-each-group

登录后复制

，分组操作简直是鸟枪换炮，变得异常直观和强大。我个人觉得，这玩意儿是XSLT 2.0最令人拍案叫绝的特性之一，它把之前那些需要绞尽脑汁才能实现的复杂逻辑，一下子拉到了“所见即所得”的层面。

for-each-group

登录后复制

指令的核心在于它的几个关键属性：

select
登录后复制
: 指定你要分组的节点集合。比如
```
select="item"
```
登录后复制
就是选择所有名为
```
item
```
登录后复制
的节点。
group-by
登录后复制
: 这是最常用的分组方式，根据一个XPath表达式的值来分组。所有该表达式值相同的节点会被分到同一个组。
group-starting-with
登录后复制
: 这是一个非常灵活的选项，它定义了新组的开始条件。当遇到符合这个条件的节点时，一个新的组就会从它开始。这对于处理“非结构化”的兄弟节点序列特别有用，比如HTML文档中，一个
```
<h3>
```
登录后复制
后面跟着若干个
```
<p>
```
登录后复制
，直到下一个
```
<h3>
```
登录后复制
出现。
group-ending-with
登录后复制
: 类似于
```
group-starting-with
```
登录后复制
，但它定义的是一个组的结束条件。
group-adjacent
登录后复制
: 这个属性用于对相邻的、具有相同键值的节点进行分组。它和
```
group-by
```
登录后复制
有点像，但更强调“相邻”这个概念，如果中间隔了其他键值的节点，即使后面有相同键值的节点，也不会归为同一个组。

在

for-each-group

登录后复制

内部，有两个非常重要的函数：

current-group()
登录后复制
: 返回当前正在处理的组中的所有节点。你可以像遍历普通节点集一样遍历它们。
current-grouping-key()
登录后复制
: 返回当前组的键值。这对于在组头显示分组信息非常有用。

举个更复杂的例子，我们想分组销售订单，先按年份，再按月份：

XML输入:

PHP高级开发技巧与范例

PHP是一种功能强大的网络程序设计语言，而且易学易用，移植性和可扩展性也都非常优秀，本书将为读者详细介绍PHP编程。全书分为预备篇、开始篇和加速篇三大部分，共9章。预备篇主要介绍一些学习PHP语言的预备知识以及PHP运行平台的架设；开始篇则较为详细地向读者介绍PKP语言的基本语法和常用函数，以及用PHP如何对MySQL数据库进行操作；加速篇则通过对典型实例的介绍来使读者全面掌握PHP。本书

472

查看详情

<sales>
  <order id="1" date="2023-01-15" amount="100"/>
  <order id="2" date="2023-02-20" amount="150"/>
  <order id="3" date="2023-01-25" amount="120"/>
  <order id="4" date="2022-11-01" amount="80"/>
  <order id="5" date="2023-02-10" amount="200"/>
</sales>

登录后复制

XSLT:

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="xml" indent="yes"/>

  <xsl:template match="/sales">
    <yearly-sales>
      <!-- 第一层分组：按年份 -->
      <xsl:for-each-group select="order" group-by="substring(@date, 1, 4)">
        <year-group year="{current-grouping-key()}">
          <!-- 第二层分组：在当前年份组内，再按月份分组 -->
          <xsl:for-each-group select="current-group()" group-by="substring(@date, 6, 2)">
            <month-group month="{current-grouping-key()}">
              <total-amount><xsl:value-of select="sum(current-group()/@amount)"/></total-amount>
              <orders-in-month>
                <xsl:for-each select="current-group()">
                  <order-summary id="{@id}" date="{@date}" amount="{@amount}"/>
                </xsl:for-each>
              </orders-in-month>
            </month-group>
          </xsl:for-each-group>
        </year-group>
      </xsl:for-each-group>
    </yearly-sales>
  </xsl:template>

</xsl:stylesheet>

登录后复制

这个例子展示了嵌套分组的强大。我们先按年份

substring(@date, 1, 4)

登录后复制

分组，然后在每个年份组内，又对

current-group()

登录后复制

（即当前年份的所有订单）进行月份

substring(@date, 6, 2)

登录后复制

分组。这种层层递进的逻辑，用

for-each-group

登录后复制

来表达简直是水到渠成，写起来也相当顺手。

XSLT 1.0环境下，Muenchian分组模式的实现与局限性

Muenchian Grouping，这个名字听起来有点酷，但它的实现方式，对于初学者来说，绝对是XSLT 1.0时代的一个“智力挑战”。它不是一个内置指令，而是一种巧妙地利用XSLT 1.0固有功能的模式。我记得刚开始学XSLT 1.0的时候，理解这个模式花了我不少时间，因为它确实有点反直觉。

核心思想：

定义键（
xsl:key
登录后复制
）: 使用
```
xsl:key
```
登录后复制
来创建一个索引，将所有需要分组的节点与它们的“分组键”关联起来。
找到每个组的“头”节点: 这是最关键的一步。我们遍历所有节点，但只选择那些在
```
key()
```
登录后复制
函数返回的节点集中，它自己就是第一个节点的。
```
count(. | key('your-key', your-criteria)[1]) = 1
```
登录后复制
就是这个魔法表达式。
- ```
key('your-key', your-criteria)
```
  登录后复制
  ：返回所有符合
```
your-criteria
```
  登录后复制
  的节点。
- ```
key('your-key', your-criteria)[1]
```
  登录后复制
  ：返回这些节点中的第一个。
- ```
count(. | ...)
```
  登录后复制
  ：这是一个集合运算，计算当前节点和第一个节点合并后的节点数量。如果当前节点就是第一个节点，那么合并后节点数量是1；如果不是，合并后节点数量是2。所以，
```
= 1
```
  登录后复制
  就筛选出了每个组的第一个节点。
遍历组内成员: 找到组头后，再次使用
```
key()
```
登录后复制
函数，传入组头的键值，就能获取该组的所有成员。

我们还是用之前的商品分类XML来演示Muenchian Grouping：

<root>
  <item id="A001" category="Electronics">
    <name>Laptop</name>
    <price>1200</price>
  </item>
  <item id="A002" category="Books">
    <name>XSLT Cookbook</name>
    <price>45</price>
  </item>
  <item id="A003" category="Electronics">
    <name>Mouse</name>
    <price>25</price>
  </item>
  <item id="A004" category="Books">
    <name>XML Basics</name>
    <price>30</price>
  </item>
</root>

登录后复制

XSLT 1.0 (Muenchian Grouping):

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:output method="xml" indent="yes"/>

  <!-- 定义一个键，用于按'category'属性查找item节点 -->
  <xsl:key name="items-by-category" match="item" use="@category"/>

  <xsl:template match="/root">
    <grouped-data>
      <!-- 遍历所有item节点，但只选择每个分组的第一个节点 -->
      <xsl:for-each select="item[count(. | key('items-by-category', @category)[1]) = 1]">
        <xsl:variable name="currentCategory" select="@category"/>
        <category-group name="{$currentCategory}">
          <!-- 遍历当前分组的所有节点 -->
          <xsl:for-each select="key('items-by-category', $currentCategory)">
            <item-detail id="{@id}">
              <name><xsl:value-of select="name"/></name>
              <price><xsl:value-of select="price"/></price>
            </item-detail>
          </xsl:for-each>
        </category-group>
      </xsl:for-each>
    </grouped-data>
  </xsl:template>

</xsl:stylesheet>

登录后复制

局限性：

复杂性高: 表达式
```
item[count(. | key('items-by-category', @category)[1]) = 1]
```
登录后复制
对于不熟悉XSLT 1.0技巧的人来说，确实难以理解和记忆。维护起来也容易出错。
可读性差: 相比
```
for-each-group
```
登录后复制
的语义化，Muenchian Grouping的代码看起来更像是一种“黑客行为”，而不是清晰的意图表达。
性能考量: 虽然
```
key()
```
登录后复制
函数本身是优化的，但在处理超大型文档时，反复调用
```
key()
```
登录后复制
可能会带来一定的性能开销。
不支持复杂分组条件: Muenchian Grouping主要适用于基于单一键值的分组。像
```
group-starting-with
```
登录后复制
那种基于节点位置和上下文的分组，用Muenchian Grouping实现起来会异常困难，甚至不可能。
嵌套分组的挑战: 虽然可以实现，但嵌套的Muenchian Grouping会使得表达式更加复杂，代码更难维护。

尽管有这些局限性，但对于那些仍然运行在XSLT 1.0环境下的系统来说，Muenchian Grouping依然是不可或缺的技能。它证明了即使在语言特性有限的情况下，开发者也能通过巧妙的组合实现复杂的功能。

除了基本分组，XSLT还能实现哪些复杂的节点分组场景？

XSLT的分组能力远不止是简单地按一个字段值来归类。在实际项目中，我遇到过各种稀奇古怪的分组需求，有些真的需要跳出常规思维去解决。这正是XSLT的魅力所在，它提供了一套工具集，让你能像搭积木一样，构建出满足特定业务逻辑的转换。

连续兄弟节点分组（

group-starting-with

登录后复制

的妙用） 这是我个人觉得

for-each-group

登录后复制

最出彩的地方之一，尤其是在处理半结构化文档（比如HTML）时。想象一下，你有一段HTML，里面有标题

<h2>

登录后复制

，后面跟着几个段落

<p>

登录后复制

，然后又是另一个

<h2>

登录后复制

。你希望把每个

<h2>

登录后复制

和它后面的所有

<p>

登录后复制

（直到下一个

<h2>

登录后复制

出现）作为一个组。

XML输入 (模拟HTML片段):

<document>
  <h2>Section A</h2>
  <p>Content for A, paragraph 1.</p>
  <p>Content for A, paragraph 2.</p>
  <h2>Section B</h2>
  <p>Content for B, paragraph 1.</p>
  <ul><li>List item 1</li><li>List item 2</li></ul>
  <p>Content for B, paragraph 2.</p>
  <h2>Section C</h2>
  <p>Content for C.</p>
</document>

登录后复制

XSLT (使用

group-starting-with

登录后复制

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="xml" indent="yes"/>

  <xsl:template match="/document">
    <sections>
      <!-- 以h2节点作为新组的开始 -->
      <xsl:for-each-group select="*" group-starting-with="h2">
        <section title="{current-group()[1]}"> <!-- current-group()[1]是h2节点 -->
          <content>
            <xsl:copy-of select="current-group()[position() > 1]"/> <!-- 复制h2后面的所有内容 -->
          </content>
        </section>
      </xsl:for-each-group>
    </sections>
  </xsl:template>

</xsl:stylesheet>

登录后复制

这里，

group-starting-with="h2"

登录后复制

告诉XSLT，每当遇到一个

<h2>

登录后复制

节点，就开启一个新的组。这个组会包含

<h2>

登录后复制

本身，以及它后面所有的兄弟节点，直到遇到下一个

<h2>

登录后复制

为止。这对于将扁平的HTML结构转换为逻辑上的章节结构非常有效。

基于动态或计算值的分组 有时候，分组的依据不是一个简单的属性值，而是一个需要计算出来的结果。比如，我们想把商品按照价格区间（0-50, 51-100, 101-200等）来分组。

XSLT (计算价格区间):
```
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="xml" indent="yes"/>

  <xsl:template match="/root">
    <price-ranges>
      <xsl:for-each-group select="item" group-by="floor(
```
登录后复制