L'obtention d'une sous-chaîne APRÈS la dernière occurrence d'un caractère dans XSLT

J'ai une chaîne de caractères dans un fichier XML qui ressemble à ceci:

M:Namespace.Class.Method(quelque Chose d'un, quelque Chose b)

Le nombre de point (.) des personnages est abritrary, le sens qu'il peut être seulement 2 comme dans cet exemple, mais il peut être plus.

Je voudrais utiliser XSLT pour obtenir une sous-chaîne de la chaîne à partir du dernier caractère'.', de sorte que je ne sera laissé avec:

Méthode(quelque Chose d'un, quelque Chose b)

Je ne pouvais pas faire cela à l'aide de la norme sous-chaîne/chaîne-après les fonctions.

Est-il un moyen facile de faire cela?

Dupe de stackoverflow.com/questions/14527/xslt-reverse-find-in-a-string ?

OriginalL'auteur lysergic-acid | 2012-01-31

c#xml xslt

En XSLT 1.0, vous aurez besoin d'utiliser un modèle récursif, comme ceci:

  <xsl:template name="substring-after-last">
    <xsl:param name="string" />
    <xsl:param name="delimiter" />
    <xsl:choose>
      <xsl:when test="contains($string, $delimiter)">
        <xsl:call-template name="substring-after-last">
          <xsl:with-param name="string"
            select="substring-after($string, $delimiter)" />
          <xsl:with-param name="delimiter" select="$delimiter" />
        </xsl:call-template>
      </xsl:when>
      <xsl:otherwise><xsl:value-of 
                  select="$string" /></xsl:otherwise>
    </xsl:choose>
  </xsl:template>

et à l'appeler comme ceci:

<xsl:call-template name="substring-after-last">
  <xsl:with-param name="string" select="'M:Namespace.Class.Method(Something a, Something b)'" />
  <xsl:with-param name="delimiter" select="'.'" />
</xsl:call-template>

Dans XSLT 2.0, vous pouvez utiliser le marquer() fonction et il suffit de sélectionner le dernier élément de la séquence:

tokenize('M:Namespace.Class.Method(Something a, Something b)','\.')[last()]

Merci. Comment puis-je savoir quelle version de XSLT suis-je utiliser? Je suis en invoquant tout cela à partir de code C# (à l'aide de la XslCompiledTransform classe).
Malheureusement .NET ne prend pas en charge XSLT 2.0 en mode natif. Sauf si vous avez Saxon.net, XQSharp, ou d'autres moteurs 2.0, vous aurez besoin d'utiliser un 1.0 solution.
Cela a fait le tour, merci!

OriginalL'auteur Mads Hansen

1

Ici est une solution plus efficace O(N) par rapport à O(N^2) pour la accepté de répondre à:
```
<xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:output method="text"/>

 <xsl:template match="text()" name="skipAfterDots">
  <xsl:param name="pTotalString" select="."/>
  <xsl:param name="pTotalLength" select="string-length(.)"/>
  <xsl:param name="pPosition" select="1"/>
  <xsl:param name="pLastFound" select="-1"/>

  <xsl:choose>
    <xsl:when test="$pPosition > $pTotalLength">
      <xsl:value-of select="substring($pTotalString, $pLastFound + 1)"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:variable name="vIsDot" select=
       "substring($pTotalString, $pPosition, 1) = '.'"/>

      <xsl:call-template name="skipAfterDots">
        <xsl:with-param name="pTotalString" select="$pTotalString"/>
        <xsl:with-param name="pTotalLength" select="$pTotalLength"/>
        <xsl:with-param name="pLastFound" select=
        "$pLastFound * not($vIsDot) + $pPosition * $vIsDot"/>
        <xsl:with-param name="pPosition" select="$pPosition+1"/>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
 </xsl:template>
</xsl:stylesheet>
```
Lorsque cette transformation est appliquée sur le document XML suivant:
```
<t>M:Namespace.Class.Method(Something a, Something b)</t>
```
le voulait, résultat correct est produit:
```
Method(Something a, Something b)
```
Explication:

Cette solution ne contient pas d'appel à la substring-after() fonction. Au lieu de cela, à chaque étape, le seul caractère de la chaîne est comparée pour l'égalité avec le caractère de point. Parce qu'il y a au plus N caractères, c'est O(N) -- linéaire de la complexité.

Au contraire, la accepté de répondre aux appels de la substring-after() fonction sur chaque étape. Dans le pire des cas, il pourrait être N points, et donc ce serait O(N^N) -- complexité quadratique.

Note: Nous faisons l'hypothèse raisonnable que dans les deux solutions de localisation de la k-ième caractère de la chaîne est O(1).

Ancien commentaire, mais je ressens un besoin de commentaire: la solution retenue est également en O(n). Chaque appel (une saine mise en œuvre de l') contains() va regarder à travers des personnages principaux jusqu'à ce qu'il trouve un point. Après il trouve un point, chaque personnage, il a regardé si la mesure est supprimée. Donc, il va chercher à chaque caractère au plus une fois.
Je me réfère à <xsl:with-param name="string" select="substring-after($string, $delimiter)"/>. Si il y a m points dans la chaîne de caractères et la longueur de la chaîne est n, alors cet algorithme est O(m*n)
À droite, vous avez raison. Je ne considère pas que substring-after aurez à regarder à travers l'ensemble de l' (restant) de la chaîne.
Mon explication était fausse (mentionné contains() au lieu de substring-after()). Fixe maintenant.

OriginalL'auteur Dimitre Novatchev
-1

Si vous ne savez pas que vous avez exactement deux points dans vos cordes, alors vous pouvez essayer:
```
<xsl:value-of select="substring-after(substring-after($str, '.'), '.')" /> 
```
Cela ne fonctionnera pas si j'ai un nombre arbitraire de . dans ma chaîne.. Par exemple: le Composant.Quelque chose.D'autre.Classe.Méthode( ... )

OriginalL'auteur Igor Korkhov

Vous devez vous connecter pour publier un commentaire.