Multiplier 2 nombres, et somme

Je vais avoir un moment difficile essayer de faire quelque chose qui semble comme il devrait être très facile à faire. En gros, je veux multiplier 2 nombres dans un nœud puis additionner le total de ces nombres pour tous les nœuds. Voici le code XSLT, j'ai essayé.

<xsl:value-of select="sum(Parts/Part/Quantity * Parts/Part/Rate)"/>

Ce code provoque une erreur qui dit que "l'Argument 1 de la fonction somme ne peut être converti en un ensemble de nœuds."

Quelqu'un a une idée de ce qui est mal ou comment je peux accomplir ce que je suis en train de faire?

Est-ce XSLT version 1 ou 2?
vous devez mentionner l'suffisamment de détails .. alors que les autres peuvent penser de vous aider .. XSLT version, processeur saxonne (ou someother) ou @Moins logiciel (Visual studio/ Altova XML Spy) doit être mentionné ..

OriginalL'auteur | 2009-01-12

xslt

Voici trois solutions possibles:

Solution1 XSLT2:

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

    <xsl:template match="/">
      <xsl:sequence select="sum(/*/*/(rate * quantity))"/>
    </xsl:template>
</xsl:stylesheet>

Lorsque cette transformation est appliquée sur le document XML suivant:

<parts>
  <part>
        <rate>0.37</rate>
    <quantity>10</quantity>
  </part>
  <part>
        <rate>0.03</rate>
    <quantity>10</quantity>
  </part>
</parts>

Le résultat voulu est produit:

La XSLT 2.0 solution utilise le fait que, dans XPath 2.0 il est admis que le droit à l'argument de la dernière opérateur "/" peut être une expression, ou, plus généralement une fonction. Cette expression de la fonction/est appliquée pour chacun des nœuds sélectionnés jusqu'à présent, agissant comme le nœud de contexte, et chaque fonction de l'application produit un résultat.

Solution2 XSLT 1.0:

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

    <xsl:template match="/">
      <xsl:call-template name="sumProducts">
        <xsl:with-param name="pList" select="*/*"/>
      </xsl:call-template>
    </xsl:template>

    <xsl:template name="sumProducts">
        <xsl:param name="pList"/>
        <xsl:param name="pAccum" select="0"/>

        <xsl:choose>
          <xsl:when test="$pList">
            <xsl:variable name="vHead" select="$pList[1]"/>

            <xsl:call-template name="sumProducts">
              <xsl:with-param name="pList" select="$pList[position() > 1]"/>
              <xsl:with-param name="pAccum"
               select="$pAccum + $vHead/rate * $vHead/quantity"/>
            </xsl:call-template>
          </xsl:when>
          <xsl:otherwise>
            <xsl:value-of select="$pAccum"/>
          </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
</xsl:stylesheet>

Lorsqu'il est appliqué sur le dessus de document XML, le résultat correct est produit:

C'est typique de XSLT 1.0 solution récursive. Note de la façon dont le sumProducts modèle appelle récursivement, jusqu'à ce que l'ensemble de l'entrée de la liste, transmise dans le paramètre $pList est traitée.

Solution3 FXSL (XSLT 1.0):

<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:ext="http://exslt.org/common"
xmlns:test-map-product="test-map-product"
exclude-result-prefixes="xsl ext test-map-product"
>
   <xsl:import href="sum.xsl"/>
   <xsl:import href="map.xsl"/>
   <xsl:import href="product.xsl"/>

   <!-- This transformation is to be applied on:
        salesMap.xml

        It contains the code of the "sum of products" from the 
        article "The Functional Programming Language XSLT"
     -->

   <test-map-product:test-map-product/>

   <xsl:output method="text"/>

   <xsl:template match="/">
     <!-- Get: map product /sales/sale -->
     <xsl:variable name="vSalesTotals">
         <xsl:variable name="vTestMap" select="document('')/*/test-map-product:*[1]"/>
         <xsl:call-template name="map">
           <xsl:with-param name="pFun" select="$vTestMap"/>
           <xsl:with-param name="pList1" select="/sales/sale"/>
         </xsl:call-template>
     </xsl:variable>

     <!-- Get sum map product /sales/sale -->
      <xsl:call-template name="sum">
        <xsl:with-param name="pList" select="ext:node-set($vSalesTotals)/*"/>
      </xsl:call-template>
   </xsl:template>

    <xsl:template name="makeproduct" match="*[namespace-uri() = 'test-map-product']">
      <xsl:param name="arg1"/>

      <xsl:call-template name="product">
        <xsl:with-param name="pList" select="$arg1/*"/>
      </xsl:call-template>
    </xsl:template>
</xsl:stylesheet>

Lorsque cette transformation est appliquée sur le document XML suivant:

<sales>
  <sale>
    <price>3.5</price>
    <quantity>2</quantity>
    <Discount>0.75</Discount>
    <Discount>0.80</Discount>
    <Discount>0.90</Discount>
  </sale>
  <sale>
    <price>3.5</price>
    <quantity>2</quantity>
    <Discount>0.75</Discount>
    <Discount>0.80</Discount>
    <Discount>0.90</Discount>
  </sale>
</sales>

Le résultat correct est produit:

7.5600000000000005

Dans le dernier cas, pour chaque sale nous de calculer le produit de price, quantity et tous disponibles (nombre variable) discount-s.

FXSL est un pur XSLT mise en œuvre des fonctions supérieures. Dans cet exemple, la fonction d'ordre supérieur f:map() est utilisé pour mapper la fonction f:product() sur la liste des enfants de tous les sale élément. Ensuite, les résultats sont additionnés pour produire le résultat final.

Merci. Solution n ° 2 était exactement ce dont j'avais besoin pour créer un total de multiplication de la fonction.
+1 pour l'effort et les dépenses du temps .. 🙂
Merci pour votre appréciation! Si vous avez aimé ce que vous allez comme un grand nombre de choses sur mon blog: dnovatchev.spaces.live.com/Blog

OriginalL'auteur Dimitre Novatchev

Tous Dimitre les solutions de travail et il est vrai que vous n'avez pas besoin pour utiliser les fonctions d'extension, mais parfois, il rend la vie plus facile. Il n'est pas trop dangereux, surtout lorsque vous utilisez exslt extensions qui sont pris en charge à travers de multiples processeurs XSLT. Aussi, la raison pour laquelle vous obtenez les erreurs de séquence est probablement parce que vous êtes à l'aide d'une transformation XSLT 1 processeur.

Si vous souhaitez persister avec la solution choisie, vous aurez besoin d'utiliser Saxonne ou une autre processeur XSLT qui prend en charge XSLT 2.

Sinon, voici une méthode alternative de le faire dans XSLT 1. Cela fonctionne dans la plupart des processeurs XSLT et certains gens peut-être plus facile à analyser que la version récursive. Personnellement, je préfère une version récursive (Dimitre 3ème proposition), parce qu'il est plus portable.

<xsl:stylesheet version="1.0"
                xmlns:ex="http://exslt.org/common"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>

  <xsl:template name="GetProducts">
    <xsl:param name="left"/>
    <xsl:param name="right"/>

    <xsl:for-each select="$left/text()">
      <product>
        <xsl:value-of select="number(.) * number($right[position()])"/>
      </product>
    </xsl:for-each>
  </xsl:template>

  <xsl:template match="/">
    <xsl:variable name="products">
      <xsl:call-template name="GetProducts">
        <xsl:with-param name="left" select="Parts/Part/Rate"/>
        <xsl:with-param name="right" select="Parts/Part/Quantity"/>
      </xsl:call-template>
    </xsl:variable>

    <xsl:value-of select="sum(ex:node-set($products)/product)"/>
  </xsl:template>
</xsl:stylesheet>

OriginalL'auteur cddr

Vous devez vous connecter pour publier un commentaire.