Esta documentación está archivada y no tiene mantenimiento.

Función string

Convierte un objeto en una cadena.


string string(object?)

La función string() convierte un conjunto de nodos en una cadena devolviendo el valor de cadena del primer nodo en el conjunto de nodos, que en algunas instancias podría producir resultados inesperados. Por ejemplo, si está posicionado en el nodo <test> abajo:

<test>
  <item>Apple</item>
  <item>Banana</item>
  <item>Orange</item>
</test>

Entonces la siguiente llamada de función string() devuelve la primera cadena de nodo ("Apple"):

string(//text())

Si desea que la función string() concatene todo el texto secundario, tiene que pasar un nodo único en vez de un conjunto de nodo. Por ejemplo, la siguiente llamada de función string() devolvería "AppleBananaOrange":

string(.)

Este comportamiento se mantiene verdadero para todas las funciones XPath que toman argumentos de cadena. Por ejemplo, la siguiente llamada de función contains(),

contains(//text(),'Banana')

, devuelve un valor de false. En este ejemplo, esto ocurre porque el primer argumento ("//text()") se convierte en una cadena mediante string(//text()) sólo busca la primera cadena de nodo ("Apple"). Por el contrario, si la función contains() fuese revisada para utilizar el selector de puntos (".") para el primer argumento tal como sigue,

contains(.,'Banana')

, el valor devuelto por contains() sería true porque buscaría la cadena "AppleBananaOrange" en su lugar.

Nota

Si el conjunto de nodos está vacío, se devuelve una cadena vacía.

Los conjuntos de nodos que contienen espacios en blanco pueden controlarse mediante:

  • La eliminación de los nodos de espacios en blanco mediante la instrucción Elemento <xsl:strip-space>

  • El recorrido a través de los nodos descendientes (nodos de espacios en blanco y nodos con texto) mediante una instrucción Elemento <xsl:for-each>.

Por ejemplo, si una expresión .//text() se aplicara al siguiente elemento para seleccionar sus contenidos de texto interno,

<name>element</name>

, devolvería, por defecto, un conjunto de tres nodos, como se ve a continuación, donde el primer y tercer nodo representan nodos de espacios en blanco iniciales y finales adyacentes a los datos de texto reales ("element"):

Node 1: &#10;&#32;&#32;
Node 2: element
Node 03: &#10;

Para ignorar los nodos de sólo espacios en blanco podría especificar la instrucción <xsl:strip-space> tal como sigue en la hoja de estilo XSLT:

<xsl:strip-space elements="name"/>

Por otro lado, podría recorrer y repetir una búsqueda para cada nodo descendiente mediante el ejemplo de bucle <xsl:for-each> que se muestra abajo:

<xsl:for-each select=".//text()">
    <xsl:if test="contains(., 'element')" >
    …
    </xsl:if>
</xsl:for-each>

Un número se convierte en cadena de la siguiente forma:

  • Nan se convierte en la cadena NaN.

  • cero positivo se convierte en la cadena "0".

  • cero negativo se convierte en la cadena "0".

  • infinito positivo se convierte en la cadena "Infinity".

  • infinito negativo se convierte en la cadena "-Infinity".

  • Si el número es un entero, se representa en formato decimal como un número sin punto decimal ni ceros iniciales, precedido de un signo menos (-) si el número es negativo.

  • De otro modo, el número se representa en formato decimal como un número con un punto decimal y al menos un dígito antes del punto decimal y al menos un dígito después del punto decimal, precedido de un signo menos (-) si el número es negativo; no debe haber ceros iniciales antes del punto decimal, aparte posiblemente del dígito requerido inmediatamente antes del punto decimal; más allá del punto requerido después del punto decimal deberá haber tantos como sean necesarios para distinguir de forma exclusiva el número de todos los demás valores numéricos IEEE 754.

Nota

La función string() no está diseñada para convertir números en cadenas para presentación a los usuarios. La función format-number() y el elemento <xsl:number> en transformaciones XSL (XSLT) proporcionan está función.

El valor falso booleano se convierte en al cadena "false". El valor verdadero booleano se convierte en al cadena "true".

Un objeto de un tipo distinto de los cuatro tipos básicos se convierte en una cadena de tal forma que depende de ese tipo.

Si se omite el argumento, se toma como predeterminado un conjunto de nodos con el nodo de contexto como único miembro.

En el siguiente ejemplo se ilustra el uso de la función string() en una expresión XPath. En dos de los casos (consulte las instrucciones en negrita del archivo XSLT que se muestra a continuación), la función se utiliza para tener la seguridad de que su argumento se trata como una expresión de cadena.

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl"    

href="string.xsl"?>      
<arithmetics>
  <operation>
     <operator>+</operator>
     <operand>1</operand>
     <operand>2.00</operand>
  </operation>
  <operation>
     <operator>+</operator>
     <operand>One</operand>
     <operand>2.00</operand>
  </operation>
  <operation>
     <operator>-</operator>
     <operand>1</operand>
     <operand>2.00</operand>
  </operation>
  <operation>
     <operator>*</operator>
     <operand>1</operand>
     <operand>2.00</operand>
  </operation>
  <operation>
     <operator>div</operator>
     <operand>-1</operand>
     <operand>0.0</operand>
  </operation>
  <operation>
     <operator>mod</operator>
     <operand>5</operand>
     <operand>2</operand>
  </operation>
  <operation>
     <operator>mod</operator>
     <operand>5</operand>
     <operand>2.5</operand>
  </operation>
  <operation>
     <operator>mod</operator>
     <operand>5</operand>
     <operand>2.25</operand>
  </operation>
  <operation>
     <operator>&amp;</operator>
     <operand>0</operand>
     <operand>1</operand>
  </operation>
</arithmetics>

<?xml version='1.0'?>
<?xml-stylesheet type="text/xsl" href="string.xsl"?>
<xsl:stylesheet version="1.0"           

xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:output method="html"   
     omit-xml-declaration="yes"/>

  <xsl:template match="/arithmetics">
    <html>
       <head><title>example</title></head>
    <body>
       <xsl:apply-templates/>
    </body>
    </html>
  </xsl:template>

  <xsl:template match="operation">
    <DIV>
     <xsl:choose>
        <xsl:when test="string(operator)='+'">
           <xsl:apply-templates select="." mode="add"/>
        </xsl:when>
        <xsl:when test="string(operator)='-'">
           <xsl:apply-templates select="." mode="sub"/>
        </xsl:when>
        <xsl:when test="string(operator)='*'">
           <xsl:apply-templates select="." mode="mul"/>
        </xsl:when>
        <xsl:when test="string(operator)='div'">
           <xsl:apply-templates select="." mode="div"/>
        </xsl:when>
        <xsl:when test="string(operator)='mod'">
           <xsl:apply-templates select="." mode="mod"/>
        </xsl:when>
        <xsl:otherwise>
           <xsl:apply-templates select="." mode="err"/>
        </xsl:otherwise>
      </xsl:choose>
    </DIV>
  </xsl:template>

  <xsl:template match="operation" mode="show">
     <xsl:value-of select="operand[1]"/> &#160;
     <xsl:value-of disable-output-escaping="yes" 
                   select="string(operator)"/> &#160;
     <xsl:value-of select="operand[2]"/> &#160;
     = &#160;
  </xsl:template>

  <xsl:template match="operation" mode="err">
      <xsl:apply-templates select="." mode="show"/>
      <xsl:value-of select="string('Invalid arithmetic operation')"/>       
  </xsl:template>

  <xsl:template match="operation" mode="add">
      <xsl:apply-templates select="." mode="show"/>
      <xsl:value-of select="operand[1] + operand[2]"/>       
  </xsl:template>

  <xsl:template match="operation" mode="sub">
      <xsl:apply-templates select="." mode="show"/>
      <xsl:value-of select="operand[1] - operand[2]"/>       
  </xsl:template>
  <xsl:template match="operation" mode="mul">
      <xsl:apply-templates select="." mode="show"/>
      <xsl:value-of select="operand[1] * operand[2]"/>       
  </xsl:template>
  <xsl:template match="operation" mode="div">
      <xsl:apply-templates select="." mode="show"/>
      <xsl:value-of select="operand[1] div operand[2]"/>       
  </xsl:template>
  <xsl:template match="operation" mode="mod">
      <xsl:apply-templates select="." mode="show"/>
      <xsl:value-of select="operand[1] mod operand[2]"/>       
  </xsl:template>
</xsl:stylesheet>

Resultados

1     +   2.00   =   3
One   +   2.00   =   NaN
1     -   2.00   =   -1
1     *   2.00   =   2
-1   div   0.0   =   -Infinity
5    mod   2     =   1
5    mod   2.5   =   0
5    mod   2.25  =   0.5
0     &    1     =   Invalid arithmetic operation

Mostrar: