文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
社区首页 >问答首页 >用于获取满足特定条件的元素的XSL键

问用于获取满足特定条件的元素的XSL键
EN

Stack Overflow用户
提问于 2013-07-24 04:27:11
回答 2查看 813关注 0票数 1

我正在使用表条目元素，并希望获得同一表中通过以下测试的所有前面的条目元素：

代码语言：javascript
复制
parent::row/preceding-sibling::row/entry
  [@morerows >= count(parent::row/following-sibling::row
    [not(preceding-sibling::row/entry
      [generate-id() = $id])])]
  [count(preceding-sibling::entry
    [not(@morerows)]) + 1 = count(current()/preceding-sibling::entry) + 1]

XPath给了我想要的结果，但它慢得令人痛苦.我想用钥匙，但遇到了问题。

我按如下方式定义了一个键：

代码语言：javascript
复制
<xsl:key name="moreRowsEntry" match="entry[@morerows]" use="."/>

虽然键确实检索具有morerows属性的所有entry元素，但我实际上只需要它来检索同一祖先表中的那些元素。同样，我也不知道如何测试Morerows值。我尝试过这样的东西：

<xsl:for-each select="key('moreRowsEntry', (@morerows >= count(parent::row/following-sibling::row[not(preceding-sibling::row/entry[generate-id() = $id])])) and (count(preceding-sibling::entry[not(@morerows)]) + 1 = count(current()/preceding-sibling::entry) + 1))">

我必须使用XSL1.0来完成这项工作。任何和所有的帮助都是感激的。

一些进一步的信息：

我正在将CALS表转换为OOXML。对于CALS表中我知道其中缺少单元格的行中的每个条目，我需要添加这些额外的单元格。对于这些entry元素，我有一个$id，它是元素的generate-id()值。

然后，我使用上面的XPath，它测试表(parent::row/preceding-sibling::row/entry)前面行中的任何条目元素，如果这些条目元素的morerows属性大于或等于其自身和id为$id的条目之间的行数，并且这些元素位于应该插入空单元格的正确位置(count(preceding-sibling::entry[not(@morerows)]) + 1 = count(current()/preceding-sibling::entry) + 1)

简化的样本输入：

代码语言：javascript
复制
<table>
    <tbody>
        <row>
            <entry morerows="2">A</entry>
            <entry morerows="1">B</entry>
            <entry>C</entry>
            <entry>D</entry>
        </row>
        <row>
            <entry>E</entry>
            <entry>F</entry>
        </row>
        <row>
            <entry>G</entry>
            <entry>H</entry>
            <entry>I</entry>
        </row>
        <row>
            <entry>J</entry>
            <entry>K</entry>
            <entry>L</entry>
            <entry>M</entry>
        </row>
    </tbody>
</table>

简化的示例输出：

代码语言：javascript
复制
<w:tbl>
    <w:tr>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>A</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>B</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>C</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>D</w:t>
                </w:r>
            </w:p>
        </w:tc>
    </w:tr>
    <w:tr>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>E</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>F</w:t>
                </w:r>
            </w:p>
        </w:tc>
    </w:tr>
    <w:tr>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>G</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>H</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>I</w:t>
                </w:r>
            </w:p>
        </w:tc>
    </w:tr>
    <w:tr>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>J</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>K</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>L</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>M</w:t>
                </w:r>
            </w:p>
        </w:tc>
    </w:tr>
</w:tbl>

输入使用morerows属性来指定跨行。输出要求使用<w:vMerge/>元素为每个跨区单元格插入实际单元格。

另一个示例：

在此示例中，还必须考虑合并列(由namest和nameend属性指定)：

代码语言：javascript
复制
<table>
    <tgroup cols="7">
        <colspec colname="col1"/>
        <colspec colname="col2"/>
        <colspec colname="col3"/>
        <colspec colname="col4"/>
        <colspec colname="col5"/>
        <colspec colname="col6"/>
        <colspec colname="col7"/>
        <tbody>
            <row>
                <entry morerows="5">A</entry>
                <entry morerows="1">B</entry>
                <entry morerows="1">C</entry>
                <entry>D</entry>
                <entry>E</entry>
                <entry>F</entry>
                <entry>G</entry>
            </row>
            <row>
                <entry>2D</entry>
                <entry>2E</entry>
                <entry>2F</entry>
                <entry>2G</entry>
            </row>
            <row>
                <entry morerows="1">3B</entry>
                <entry morerows="1">3C</entry>
                <entry>3D</entry>
                <entry>3E</entry>
                <entry>3F</entry>
                <entry>3G</entry>
            </row>
            <row>
                <entry>4D</entry>
                <entry>4E</entry>
                <entry>4F</entry>
                <entry>4G</entry>
            </row>
            <row>
                <entry morerows="1" nameend="col6" namest="col2">3G - 4G</entry>
                <entry morerows="1">5G</entry>
            </row>
        </tbody>
    </tgroup>
</table>

输出：

代码语言：javascript
复制
<w:tbl>
    <w:tr>
        <w:tc>
            <w:tcPr>
                <w:vMerge w:val="restart"/>
            </w:tcPr>
            <w:p>
                <w:r>
                    <w:t>A</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:tcPr>
                <w:vMerge w:val="restart"/>
            </w:tcPr>
            <w:p>
                <w:r>
                    <w:t>B</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:tcPr>
                <w:vMerge w:val="restart"/>
            </w:tcPr>
            <w:p>
                <w:r>
                    <w:t>C</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>D</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>E</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>F</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>G</w:t>
                </w:r>
            </w:p>
        </w:tc>
    </w:tr>
    <w:tr>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>2D</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>2E</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>2F</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>2G</w:t>
                </w:r>
            </w:p>
        </w:tc>
    </w:tr>
    <w:tr>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:tcPr>
                <w:vMerge w:val="restart"/>
            </w:tcPr>
            <w:p>
                <w:r>
                    <w:t>3B</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:tcPr>
                <w:vMerge w:val="restart"/>
            </w:tcPr>
            <w:p>
                <w:r>
                    <w:t>3C</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>3D</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>3E</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>3F</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>3G</w:t>
                </w:r>
            </w:p>
        </w:tc>
    </w:tr>
    <w:tr>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>4D</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>4E</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>4F</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>4G</w:t>
                </w:r>
            </w:p>
        </w:tc>
    </w:tr>
    <w:tr>
        <w:tc>
            <w:tcPr>
                <w:vMerge/>
            </w:tcPr>
            <w:p/>
        </w:tc>
        <w:tc>
            <w:tcPr>
                <w:gridSpan w:val="5"/>
            </w:tcPr>
            <w:p>
                <w:r>
                    <w:t>3G - 4G</w:t>
                </w:r>
            </w:p>
        </w:tc>
        <w:tc>
            <w:p>
                <w:r>
                    <w:t>5G</w:t>
                </w:r>
            </w:p>
        </w:tc>
    </w:tr>
</w:tbl>
xslt
xslt-1.0
EN

回答 2

Stack Overflow用户

发布于 2013-07-24 23:40:14

如果您的处理器可以执行the exslt:node-set function或类似的操作，如that provided by msxml，那么您可以使用尾递归模板从程序上解决这一问题。我知道这很难看，这与我们通常推荐的XSLT完全相反，但在这种情况下，我认为唯一有效地做到这一点的方法是将信息从一行传递到下一行。假设表的第一行的每一列都有一个entry，那么如下所示如何：

代码语言：javascript
复制
<xsl:template match="tbody">
  <w:tbl>
    <xsl:apply-templates select="row[1]">
      <xsl:with-param name="rowSpec">
        <!-- build the row info structure assuming that the first row has
             the right number of entry elements.  Nothing spans into the
             first row, so they all get @span=0 -->
        <xsl:for-each select="row[1]/entry">
          <r span="0" />
        </xsl:for-each>
      </xsl:with-param>
    </xsl:apply-templates>
  </w:tbl>
</xsl:template>

<xsl:template match="row">
  <xsl:param name="rowSpec" />
  <xsl:variable name="theRow" select="." />

  <w:tr>
    <!-- build up the output for this row -->
    <xsl:for-each select="exsl:node-set($rowSpec)/r">
      <w:tc>
        <xsl:choose>
          <xsl:when test="@span = 0">
            <!-- this row has an entry for the column -->
            <xsl:apply-templates select="$theRow/entry[
               count(current()/preceding-sibling::r[@span = 0]) + 1]" />
          </xsl:when>
          <xsl:otherwise>
            <!-- this column spans from the previous row -->
            <w:tcPr>
              <w:vMerge/>
            </w:tcPr>
            <w:p/>
          </xsl:otherwise>
        </xsl:choose>
      </w:tc>
    </xsl:for-each>
  </w:tr>

  <!-- process the next row with recalculated spans -->
  <xsl:apply-templates select="following-sibling::row[1]">
    <xsl:with-param name="rowSpec">
      <xsl:for-each select="exsl:node-set($rowSpec)/r">
        <xsl:choose>
          <xsl:when test="@span = 0">
            <!-- we had an entry element for this column, use its @morerows
                 as the next span, or 0 if it doesn't have one -->
            <xsl:choose>
              <xsl:when test="$theRow/entry[
                 count(current()/preceding-sibling::r[@span = 0]) + 1]/@morerows">
                <r span="{$theRow/entry[
                 count(current()/preceding-sibling::r[@span = 0]) + 1]/@morerows}" />
              </xsl:when>
              <xsl:otherwise>
                <r span="0" />
              </xsl:otherwise>
            </xsl:choose>
          </xsl:when>
          <xsl:otherwise>
            <!-- we didn't have an entry for this column, it was a span from the
                 previous row - subtract 1 from the span when we pass on to
                 the next row -->
            <r span="{@span - 1}" />
          </xsl:otherwise>
        </xsl:choose>
      </xsl:for-each>
    </xsl:with-param>
  </xsl:apply-templates>
</xsl:template>

<xsl:template match="entry">
  <w:p>
    <w:r>
      <w:t><xsl:value-of select="." /></w:t>
    </w:r>
  </w:p>
</xsl:template>

(哇，这比我刚开始时预期的要复杂得多，但我已经测试过了，它似乎工作正常)。这里的想法是，我们构建一个结构，对每列在处理该行时仍然需要跨越的行数进行编码。因此，对于第一行，我们将有

代码语言：javascript
复制
<r span="0"/>
<r span="0"/>
<r span="0"/>
<r span="0"/>

那第二个就是

代码语言：javascript
复制
<r span="2"/>
<r span="1"/>
<r span="0"/>
<r span="0"/>

第三个

代码语言：javascript
复制
<r span="1"/>
<r span="0"/>
<r span="0"/>
<r span="0"/>

对于每一行，我们都会遍历这个结构，而不是entry元素本身。

编辑:现在你已经改变了问题，所以你需要考虑到列跨度和行跨度的可能性，它变得更加混乱。由于我们致力于使用节点集函数，因此我会考虑LarsH所暗示的两步方法，首先将跨越列的条目展开为实际的entry元素(使用某些属性来标识它们)，然后处理扩展版本的XML，而不是原来的版本。

票数 2
EN

Stack Overflow用户

发布于 2013-07-24 05:12:52

代码语言：javascript
复制
<xsl:key name="moreRowsEntriesByTable" match="entry[@morerows]"
   use="generate-id(ancestor::table[1])" />

更新

这不能简明扼要地完成。

您可以通过在需要的地方插入以下谓词来解决此问题：

代码语言：javascript
复制
[count(key('moreRowsEntriesByTable', $table-id) | .) = 
 count(key('moreRowsEntriesByTable', $table-id)]

其中$table-id是当前()节点的祖先表的id：

代码语言：javascript
复制
<xsl:variable name="table-id" select="generate-id(ancestor::table[1])" />

但这可能比根本不使用密钥要慢：

代码语言：javascript
复制
[generate-id(ancestor::table[1]) = $table-id]

您可以将此谓词附加到XPath表达式中的每个entry节点测试。但再说一次，我不确定它是否会对性能有所帮助。

替代方案

相反，我建议分两个阶段进行转换。您的处理上下文允许这样做吗？为此，您可以运行两个样式表，第一个样式表的输出通过管道传输到第二个样式表的输入；或者使用通用的node-set()扩展函数将一个模板的输出转换为一个节点集，该节点集可以用作另一个模板的输入。

在第一个转换中，您可以向每个表单元格添加属性以帮助计算，例如...

代码语言：javascript
复制
@row -- row number of this entry in current table (position() of parent::row)
@index -- position of this entry among siblings in the parent::row, taking into
  account their colspans if necessary.
@table-id -- generate-id(ancestor::table[1])

这个想法应该是摊销(如果我正确地使用了这个术语)。如果这些值在第一阶段计算一次，而不是在复杂的XPath表达式中多次计算，那么速度会快很多。也许还有其他属性会更有帮助。

您可以在第二个转换中删除(而不是复制)这些辅助属性。

这是一个粗略的建议，但它可能有助于指向一个好的解决方案。

票数 1
EN
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：

https://stackoverflow.com/questions/17820393

复制
相关文章

相似问题

领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2026 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 粤公网安备44030502008569号

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档