XSL Plusieurs de rechercher et de remplacer la fonction

Je suis en essayant d'utiliser le XSL translate() de la fonction à créer quelque chose comme une recherche et remplacer la fonction comme suit:

<xsl:template name="create-id">
    <xsl:param name="id" />
    <xsl:call-template name="search-and-replace">
        <xsl:with-param name="str" select="$id" />
        <xsl:with-param name="search">0123456789</xsl:with-param>
        <xsl:with-param name="replace">abcdefghij</xsl:with-param>
    </xsl:call-template>
</xsl:template>

<xsl:template name="search-and-replace">
    <xsl:param name="str" />
    <xsl:param name="search" />
    <xsl:param name="replace" />
    <xsl:variable name="newstr" select="translate($str, $search,
    $replace)" />
    <xsl:choose>
        <xsl:when test="contains($newstr, $search)">
            <xsl:call-template name="search-and-replace">
                <xsl:with-param name="str" select="$newstr" />
                <xsl:with-param name="search" select="$search" />
                <xsl:with-param name="replace" select="$replace" />
            </xsl:call-template>
        </xsl:when>
        <xsl:otherwise>
            <xsl:value-of select="$newstr" />
        </xsl:otherwise>
    </xsl:choose>
</xsl:template>

Cependant, quelque chose à propos de ma logique est faux qu'il semble l'être de dépouiller le dernier caractère dans la chaîne renvoyée. Ma conjecture est que translate() est seulement le remplacement de la première occurrence de chaque caractère de la chaîne et n'est pas vraiment récursive.

Des pensées ou d'entrée serait appréciée.

Post quelques exemples d'entrée et de sortie que vous voyez, avec ce que vous vous attendez à voir. Translate() ne peut pas faire ce que vous pensez qu'il fait, mais sans exemple nous ne pouvons pas dire ce que c'est.
translate() ne fait pas ce que vous en pensez. Ce n'est pas une bonne idée de faire des suppositions sur ce qu'est une fonction en fait, en regardant son nom: lire la spec en premier.
Bonne question, +1. Voir ma réponse complète XSLT 1.0 solution aux multiples remplacer le problème. Explication détaillée est fournie, trop.

OriginalL'auteur John | 2011-03-12

8

La translate() fonction peut seulement remplacer un caractère par un autre caractère unique (ou avec les caractères vide (supprimer)). Il ne peut donc pas résoudre le problème de la chaîne de remplacement.

Ici est un XSLT 1.0 solution à la remplacer problème:
```
<xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:my="my:my">
    <xsl:output omit-xml-declaration="yes"/>
    <xsl:strip-space elements="*"/>

    <my:params xml:space="preserve">
        <pattern>
            <old>&#xA;</old>
            <new><br/></new>
        </pattern>
        <pattern>
            <old>quick</old>
            <new>slow</new>
        </pattern>
        <pattern>
            <old>fox</old>
            <new>elephant</new>
        </pattern>
        <pattern>
            <old>brown</old>
            <new>white</new>
        </pattern>
    </my:params>

    <xsl:variable name="vPats"
         select="document('')/*/my:params/*"/>

    <xsl:template match="text()" name="multiReplace">
        <xsl:param name="pText" select="."/>
        <xsl:param name="pPatterns" select="$vPats"/>

        <xsl:if test="string-length($pText) >0">
            <xsl:variable name="vPat" select=
            "$vPats[starts-with($pText, old)][1]"/>

            <xsl:choose>
                <xsl:when test="not($vPat)">
                    <xsl:copy-of select="substring($pText,1,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:copy-of select="$vPat/new/node()"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:call-template name="multiReplace">
                <xsl:with-param name="pText" select=
                "substring($pText, 1 + not($vPat) + string-length($vPat/old/node()))"/>
            </xsl:call-template>
        </xsl:if>
    </xsl:template>
</xsl:stylesheet>
```
lorsque cette transformation est appliquée sur le document XML suivant:
```
<t>The quick
brown fox</t>
```
le voulait, résultat correct est produit:
```
The slow<br />white elephant
```
Explication:
1. Un modèle nommé qui s'appelle elle-même de manière récursive est utilisé.
2. Tous les multiples de remplacement modèle --> remplacement paires sont prévues dans un seul paramètre externe, qui pour des raisons de commodité est indiquée en ligne, comme le niveau global de l'élément <my:params> .
3. La récursivité prend chaque caractère dans la chaîne source (de gauche à droite) et trouve le premier motif qui commence par ce caractère à cette position dans la chaîne.
4. Le remplacement peut être non seulement une chaîne de caractères, mais aussi n'importe quel nœud. Dans ce cas précis, on remplace chaque caractère NL avec un <br/> élément.
Merci pour les commentaires et les explications. Je vais voir si cette solution fonctionne dans mon cas.
Vous êtes les bienvenus.
il ressemble à ce qui se passe à travailler pour moi. Cependant, j'ai besoin d'avoir au moins deux ensembles de paramètres pour définir la feuille de style. Comme mon expérience de travail avec les espaces de noms XSL est quelque peu limitée, comment pourrait-on modifier votre code pour passer à définir et à passer dans deux différents jeux de paramètres pour la multiReplace appel?
Le <my:params> arbre doit être passé en paramètre, ou peut-être dans un fichier XML distinct et le nom du fichier doit être passé en paramètre à la transformation. Maintenant, en passant de paramètres externes à la transformation dépend du processeur XSLT utilisés, il faut lire sa documentation. Je chose que votre meilleur itinéraire est d'accepter cette réponse et ensuite poser une question supplémentaire, en précisant le processeur XSLT vous utilisez et en demandant à la façon dont les paramètres doivent être transmises pour ce processeur XSLT. Je ou beaucoup d'autres peut donner de bonnes réponses.

OriginalL'auteur Dimitre Novatchev

La définition de la translate($arg, $mapString, $transString) fonction est:

Renvoie la valeur de $arg modifié, de sorte que
chaque caractère dans la valeur de $arg
qui se produit à une certaine position N dans la
la valeur de $mapString a été remplacé
par le personnage qui se produit à
la position N dans la valeur de
$transString.

Qui est, il n'est pas de remplacer une sous-chaîne par une autre chaîne, mais plutôt des cartes personnages à d'autres personnages. Pour la sous-chaîne de remplacement, utilisez quelque chose comme

<xsl:template name="search-and-replace">
  <xsl:param name="str"/>
  <xsl:param name="search"/>
  <xsl:param name="replace"/>
  <xsl:choose>
    <xsl:when test="contains($str, $search)">
      <xsl:value-of select="substring-before($str, $search)"/>
      <xsl:value-of select="$replace"/>
      <xsl:call-template name="search-and-replace">
        <xsl:with-param name="str" select="substring-after($str, $search)"/>
        <xsl:with-param name="search" select="$search"/>
        <xsl:with-param name="replace" select="$replace"/>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$str"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

Je suis actuellement à la recherche pour plus d'instance multiple de mappage de caractères dans une chaîne, en plus de la recherche et de la remplacer. Je suis désolé si mon post n'était pas clair.

OriginalL'auteur jelovirt

0

Semble que votre ne sera jamais vrai comme vous l'avez déjà remplacé tous les caractères de $recherche $à remplacer dans
```
<xsl:variable name="newstr" select="translate($str, $search,
    $replace)" />
```
à l'avance.

OriginalL'auteur Quincy
0

str:remplacer de exslt. C'est exactement ce que vous voulez, et qui est déjà écrit et le test par certains xslt gourous. La source xslt est également disponible il y.

Je vous remercie. Je ne suis pas sûr que notre système de soutien exslt, mais je vais regarder.
La condition xsd doivent encore travailler, car il n'utilise pas de quelque chose de spécial.

OriginalL'auteur earlNameless

Vous devez vous connecter pour publier un commentaire.