Conseguir una subcadena después de la última aparición de un caracter en XSLT

Question

tengo una cadena en un archivo XML que se parece a esto:

M: Namespace.Class.Method (Algo un, Algo b)

El número de caracteres de período (.) Es abritrary, lo que significa que puede ser solo 2 como en este ejemplo, pero puede ser más.

Me gustaría usar XSLT para obtener una subcadena de esta cadena del último '.' carácter, por lo que sólo se quedará con:

Método (Algo un, Algo b)

no pude lograr esto mediante la subcadena estándar/subcadena-después de las funciones.

¿Hay una manera fácil de hacer esto?

Answer 1

En XSLT 1.0 se tendrá que utilizar una plantilla recursiva, así:

<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> 

e invocar así:

<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> 

En XSLT 2.0, puede utilizar la función detokenize() y sólo tiene que seleccionar el último elemento de la secuencia:

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

Answer 2

Si sabe que tiene exactamente dos puntos en sus cadenas continuación, puede probar:

<xsl:value-of select="substring-after(substring-after($str, '.'), '.')" /> 

Answer 3

Aquí es una solución más eficiente O (N) vs. O (N^2) para la respuesta aceptada:

<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> 

Cuando se aplica esta transformación en el siguiente documento XML:

<t>M:Namespace.Class.Method(Something a, Something b)</t> 

el, resultado correcto querido se produce:

Method(Something a, Something b) 

Explicación:

Esta solución no contiene ninguna llamada a la funciónsubstring-after(). En su lugar, en cada paso solo se compara el carácter de la cadena para la igualdad con el carácter de punto. Debido a que hay como mucho N caracteres, esta es O (N) - complejidad lineal.

Por el contrario, la respuesta aceptada llama a la función substring-after() en cada paso. En el peor de los casos, podría haber N puntos y, por lo tanto, esto sería O (N^N) - complejidad cuadrática.

Nota: Suponemos razonablemente que en ambas soluciones la ubicación del carácter k-ésimo de una cadena es O (1).