Verifique se uma sequência é nula ou vazia no XSLT

Como posso verificar se um valor é nulo ou vazio com XSL ?

Por exemplo, se categoryNameestá vazio? Eu estou usando um ao escolher construir.

Por exemplo:

<xsl:choose>
    <xsl:when test="categoryName !=null">
        <xsl:value-of select="categoryName " />
    </xsl:when>
    <xsl:otherwise>
        <xsl:value-of select="other" />
    </xsl:otherwise>
</xsl:choose>

test="categoryName != ''"

Edit : Isso cobre a interpretação mais provável, na minha opinião, de "[não] nulo ou vazio", como inferido da pergunta, incluindo seu pseudo-código e minha própria experiência inicial com o XSLT. Ou seja, "Qual é o equivalente do seguinte Java?":

!(categoryName == null || categoryName.equals(""))

Para obter mais detalhes, por exemplo, identificando claramente nulo x vazio, consulte a resposta de johnvey abaixo e / ou o 'violino' do XSLT que adaptei dessa resposta, que inclui a opção no comentário de Michael Kay e a sexta interpretação possível.

Na ausência de outras informações, assumirei o seguinte XML:

<group>
    <item>
        <id>item 1</id>
        <CategoryName>blue</CategoryName>
    </item>
    <item>
        <id>item 2</id>
        <CategoryName></CategoryName>
    </item>
    <item>
        <id>item 3</id>
    </item>
    ...
</group>

Um exemplo de caso de uso seria semelhante a:

<xsl:for-each select="/group/item">
    <xsl:if test="CategoryName">
        <!-- will be instantiated for item #1 and item #2 -->
    </xsl:if>
    <xsl:if test="not(CategoryName)">
        <!-- will be instantiated for item #3 -->
    </xsl:if>
    <xsl:if test="CategoryName != ''">
        <!-- will be instantiated for item #1 -->
    </xsl:if>
    <xsl:if test="CategoryName = ''">
        <!-- will be instantiated for item #2 -->
    </xsl:if>
</xsl:for-each>

Do elemento vazio :

Para testar se o valor de um determinado nó está vazio

Depende do que você quer dizer com vazio.

• Não contém nós filhos: not(node())
• Não contém conteúdo de texto: not(string(.))
• Não contém texto além de espaço em branco: not(normalize-space(.))
• Não contém nada, exceto comentários: not(node()[not(self::comment())])

A respeito?

test="not(normalize-space(categoryName)='')"

Os dois primeiros tratam com valor nulo e os dois segundos tratam com a string vazia.

<xsl:if test="USER/FIRSTNAME">
    USERNAME is not null
</xsl:if>
<xsl:if test="not(USER/FIRSTNAME)">
    USERNAME is null
 </xsl:if>
 <xsl:if test="USER/FIRSTNAME=''">
     USERNAME is empty string
 </xsl:if>
 <xsl:if test="USER/FIRSTNAME!=''">
     USERNAME is not empty string
 </xsl:if>

Em alguns casos, convém saber quando o valor é especificamente nulo, o que é particularmente necessário ao usar XML que foi serializado a partir de objetos .NET. Embora a resposta aceita funcione para isso, ela também retorna o mesmo resultado quando a string está em branco ou vazia, ou seja, '', para que você não possa diferenciar.

<group>
    <item>
        <id>item 1</id>
        <CategoryName xsi:nil="true" />
    </item>
</group>

Então você pode simplesmente testar o atributo.

<xsl:if test="CategoryName/@xsi:nil='true'">
   Hello World.
</xsl:if>

Às vezes, é necessário saber o estado exato e você não pode simplesmente verificar se CategoryName é instanciado, porque, diferentemente do Javascript

<xsl:if test="CategoryName">
   Hello World.
</xsl:if>

Retornará true para um elemento nulo.

Sei que essa pergunta é antiga, mas entre todas as respostas, sinto falta de uma que seja uma abordagem comum para esse caso de uso no desenvolvimento de XSLT.

Estou imaginando que o código ausente do OP se parece com isso:

<xsl:template match="category">
    <xsl:choose>
        <xsl:when test="categoryName !=null">
            <xsl:value-of select="categoryName " />
        </xsl:when>
        <xsl:otherwise>
            <xsl:value-of select="other" />
        </xsl:otherwise>
    </xsl:choose>
</category>

E que a entrada se parece com isso:

<categories>
    <category>
       <categoryName>Books</categoryName>
    </category>
    <category>
       <categoryName>Magazines</categoryName>
       <categoryName>Periodicals</categoryName>
       <categoryName>Journals</categoryName>
    </category>
    <category>
        <categoryName><!-- please fill in category --></categoryName>
    </category>
    <category>
        <categoryName />
    </category>
    <category />
</categories>

Ou seja, suponho que pode haver zero, vazio, único ou vários categoryNameelementos. Lidar com todos esses casos usando xsl:chooseconstruções de estilo-ou, em outras palavras, imperativamente, está ficando rapidamente confuso (ainda mais se os elementos puderem estar em níveis diferentes!). Um idioma típico de programação no XSLT está usando modelos (daí o T no XSLT), que é uma programação declarativa, não imperativa (você não diz ao processador o que fazer, apenas diz o que deseja obter, se determinadas condições forem atendidas). Para este caso de uso, isso pode ser algo como o seguinte:

<!-- positive test, any category with a valid categoryName -->
<xsl:template match="category[categoryName[text()]]">
    <xsl:apply-templates />
</xsl:template>

<!-- any other category (without categoryName, "null", with comments etc) -->
<xsl:template match="category">
    <xsl:text>Category: Other</xsl:text>
</xsl:template>

<!-- matching the categoryName itself for easy handling of multiple names -->
<xsl:template match="categoryName">
    <xsl:text>Category: </xsl:text>
    <xsl:value-of select="." />
</xsl:template>

Isso funciona (com qualquer versão XSLT), porque o primeiro acima tem uma precedência mais alta (tem um predicado). O modelo correspondente "fall-through", o segundo, captura qualquer coisa que não seja válida. O terceiro, então, cuida da saída docategoryName valor de maneira adequada.

Observe que, nesse cenário, não há necessidade de corresponder categoriesoucategory camente , porque o processador processará automaticamente todos os filhos, a menos que seja indicado o contrário (neste exemplo, o segundo e o terceiro modelo não processam mais os filhos, porque não háxsl:apply-templates em eles).

Essa abordagem é mais facilmente extensível que a abordagem imperativa, porque lida automaticamente com várias categorias e pode ser expandida para outros elementos ou exceções apenas adicionando outro modelo correspondente. Programação sem if-branches .

Nota: não existe nullXML. Existe xsi: nil , mas isso raramente é usado, especialmente raramente em cenários sem tipo, sem um esquema de algum tipo.

Como posso verificar se um valor é nulo ou vazio com XSL?

Por exemplo, se categoryNameestá vazio?

Essa é provavelmente a expressão XPath mais simples (a resposta aceita fornece um teste para o oposto e seria mais longo, se negado):

not(string(categoryName))

Explicação :

O argumento para a not()função acima é false()exatamente quando não há categoryNamefilho ("nulo") do item de contexto ou o categoryNamefilho (único) possui valor de sequência - a sequência vazia.

Eu estou usando um ao escolher construir.

Por exemplo:

<xsl:choose>
    <xsl:when test="categoryName !=null">
        <xsl:value-of select="categoryName " />
    </xsl:when>
    <xsl:otherwise>
        <xsl:value-of select="other" />
    </xsl:otherwise>
</xsl:choose>

No XSLT 2.0, use :

<xsl:copy-of select="concat(categoryName,  $vOther[not(string(current()/categoryName))])"/>

Aqui está um exemplo completo :

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
     <xsl:output omit-xml-declaration="yes" indent="yes"/>

 <xsl:variable name="vOther" select="'Other'"/>

 <xsl:template match="/">
  <xsl:copy-of select="concat(categoryName,$vOther[not(string(current()/categoryName))])"/>
 </xsl:template>
</xsl:stylesheet>

Quando essa transformação é aplicada no seguinte documento XML:

<categoryName>X</categoryName>

o resultado desejado e correto é produzido :

X

Quando aplicado neste documento XML :

<categoryName></categoryName>

ou sobre isso:

<categoryName/>

ou sobre isso

<somethingElse>Y</somethingElse>

o resultado correto é produzido :

Other

Da mesma forma, use esta transformação XSLT 1.0 :

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:output omit-xml-declaration="yes" indent="yes"/>

 <xsl:variable name="vOther" select="'Other'"/>

  <xsl:template match="/">
    <xsl:copy-of select=
    "concat(categoryName,  substring($vOther, 1 div not(string(categoryName))))"/>
  </xsl:template>
</xsl:stylesheet>

Observe : nenhum condicional é usado. Aprenda mais sobre a importância de evitar construções condicionais neste belo curso do Pluralsight:

" Padrões de design tático no .NET: fluxo de controle "

Se houver a possibilidade de o elemento não existir no XML, eu testaria se o elemento está presente e se o comprimento da string é maior que zero:

<xsl:choose>
    <xsl:when test="categoryName and string-length(categoryName) &gt; 0">
        <xsl:value-of select="categoryName " />
    </xsl:when>
    <xsl:otherwise>
        <xsl:value-of select="other" />
    </xsl:otherwise>
</xsl:choose>

Se um nó não tiver um valor disponível no xml de entrada, como abaixo do xpath,

<node>
    <ErrorCode/>
</node>

A função string () converte em valor vazio. Então, isso funciona bem:

string(/Node/ErrorCode) =''

Algo assim funciona para mim:

<xsl:choose>
  <xsl:when test="string(number(categoryName)) = 'NaN'"> - </xsl:when> 
  <xsl:otherwise> 
    <xsl:number value="categoryName" />
  </xsl:otherwise>
</xsl:choose>

Ou o contrário:

<xsl:choose>
  <xsl:when test="string(number(categoryName)) != 'NaN'">
    <xsl:number value="categoryName" />
  </xsl:when> 
  <xsl:otherwise> - </xsl:otherwise>
</xsl:choose>

Nota: Se você não verificar valores nulos ou manipular valores nulos, o IE7 retornará -2147483648 em vez de NaN.

Na verdade, achei melhor apenas testar o comprimento da string, pois muitas vezes o campo não é nulo, apenas vazio

<xsl: when test = "comprimento da string (campo que você deseja testar) <1">

Pela minha experiência, a melhor maneira é:

<xsl:when test="not(string(categoryName))">
    <xsl:value-of select="other" />
</xsl:when>
<otherwise>
    <xsl:value-of select="categoryName" />
</otherwise>

Use categoryName simples / texto () Esse teste funciona bem <categoryName/>e também <categoryName></categoryName>.

<xsl:choose>
    <xsl:when test="categoryName/text()">
        <xsl:value-of select="categoryName" />
    </xsl:when>
    <xsl:otherwise>
        <xsl:value-of select="other" />
    </xsl:otherwise>
</xsl:choose>