Vérifiez si une chaîne est nulle ou vide dans XSLT

Comment puis-je vérifier si une valeur est nulle ou vide avec XSL ?

Par exemple, si categoryNameest vide? J'utilise un lors du choix de la construction.

Par exemple:

<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 : Cela couvre l'interprétation la plus probable, à mon avis, de "[pas] nul ou vide" comme déduit de la question, y compris son pseudo-code et ma propre première expérience avec XSLT. C'est-à-dire, "Quel est l'équivalent du Java suivant?":

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

Pour plus de détails, par exemple, identifier distinctement null vs vide, voir la réponse de johnvey ci - dessous et / ou le `` violon '' XSLT que j'ai adapté de cette réponse, qui inclut l'option dans le commentaire de Michael Kay ainsi que la sixième interprétation possible.

En l'absence de toute autre information, je suppose que le XML suivant:

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

Un exemple d'utilisation ressemblerait à ceci:

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

De l' élément vide :

Pour tester si la valeur d'un certain nœud est vide

Cela dépend de ce que vous entendez par vide.

• Ne contient aucun nœud enfant: not(node())
• Ne contient aucun contenu textuel: not(string(.))
• Ne contient aucun texte autre que des espaces: not(normalize-space(.))
• Ne contient que des commentaires: not(node()[not(self::comment())])

Qu'en est-il de?

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

Les deux premiers traitent avec une valeur nulle et les deux autres traitent avec une chaîne vide.

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

Dans certains cas, vous souhaiterez peut-être savoir quand la valeur est spécifiquement nulle, ce qui est particulièrement nécessaire lors de l'utilisation de XML qui a été sérialisé à partir d'objets .NET. Bien que la réponse acceptée fonctionne pour cela, elle renvoie également le même résultat lorsque la chaîne est vide ou vide, c'est-à-dire '', vous ne pouvez donc pas faire de différence.

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

Vous pouvez donc simplement tester l'attribut.

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

Parfois, il est nécessaire de connaître l'état exact et vous ne pouvez pas simplement vérifier si CategoryName est instancié, car contrairement à dire Javascript

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

Renvoie true pour un élément null.

Je sais que cette question est ancienne, mais entre toutes les réponses, je manque celle qui est une approche courante pour ce cas d'utilisation dans le développement XSLT.

J'imagine que le code manquant de l'OP ressemble à ceci:

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

Et que l'entrée ressemble à ceci:

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

C'est-à-dire que je suppose qu'il peut y avoir zéro, vide, un seul categoryNameélément ou plusieurs éléments. Traiter tous ces cas en utilisant xsl:choosedes constructions -style, ou en d'autres termes, impérativement, devient rapidement compliqué (encore plus si les éléments peuvent être à différents niveaux!). Un idiome de programmation typique dans XSLT utilise des modèles (d'où le T dans XSLT), qui est une programmation déclarative, pas impérative (vous ne dites pas au processeur quoi faire, vous dites simplement ce que vous voulez sortir si certaines conditions sont remplies). Pour ce cas d'utilisation, cela peut ressembler à ceci:

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

Cela fonctionne (avec n'importe quelle version XSLT), car la première ci-dessus a une priorité plus élevée (elle a un prédicat). Le modèle de correspondance "fall-through", le second, capture tout ce qui n'est pas valide. Le troisième se charge ensuite de sortir lecategoryName valeur de manière appropriée.

Notez que dans ce scénario, il n'est pas nécessaire de faire correspondre spécifiquement categoriesou category, car le processeur traitera automatiquement tous les enfants, sauf indication contraire (dans cet exemple, les deuxième et troisième modèles ne traitent pas davantage les enfants, car il n'y a pas xsl:apply-templatesdans leur).

Cette approche est plus facilement extensible que l'approche impérative, car elle traite automatiquement plusieurs catégories et peut être développée pour d'autres éléments ou exceptions en ajoutant simplement un autre modèle correspondant. Programmation sans if-branches .

Remarque: il n'y a rien de tel qu'en nullXML. Il existe xsi: nil , mais il est rarement utilisé, surtout rarement dans des scénarios non typés sans schéma d'aucune sorte.

Comment puis-je vérifier si une valeur est nulle ou vide avec XSL?

Par exemple, si categoryNameest vide?

C'est probablement l'expression XPath la plus simple (celle de la réponse acceptée fournit un test pour le contraire, et serait plus longue si elle était annulée):

not(string(categoryName))

Explication :

L'argument de la not()fonction ci-dessus est false()exactement lorsqu'il n'y a pas d' categoryNameenfant ("null") de l'élément de contexte, ou lorsque l' enfant (unique) categoryNamea une valeur de chaîne - la chaîne vide.

J'utilise un lors du choix de la construction.

Par exemple:

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

Dans XSLT 2.0, utilisez :

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

Voici un exemple complet :

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

Lorsque cette transformation est appliquée sur le document XML suivant:

<categoryName>X</categoryName>

le résultat voulu et correct est produit :

X

Lorsqu'il est appliqué sur ce document XML :

<categoryName></categoryName>

ou sur ceci:

<categoryName/>

ou sur ce

<somethingElse>Y</somethingElse>

le résultat correct est produit :

Other

De même, utilisez cette transformation 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>

Notez : aucun conditionnel n'est utilisé. En savoir plus sur l'importance d'éviter les constructions conditionnelles dans ce joli cours Pluralsight:

" Modèles de conception tactique dans .NET: flux de contrôle "

S'il y a une possibilité que l'élément n'existe pas dans le XML, je testerais à la fois que l'élément est présent et que la longueur de chaîne est supérieure à zéro:

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

Si un nœud n'a aucune valeur disponible dans le xml d'entrée comme ci-dessous xpath,

<node>
    <ErrorCode/>
</node>

La fonction string () est convertie en valeur vide. Donc ça marche bien:

string(/Node/ErrorCode) =''

Quelque chose comme ça fonctionne pour moi:

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

Ou l'inverse:

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

Remarque: Si vous ne vérifiez pas les valeurs nulles ou ne gérez pas les valeurs nulles, IE7 renvoie -2147483648 au lieu de NaN.

J'ai trouvé qu'il valait mieux juste tester la longueur de la chaîne car plusieurs fois le champ n'est pas nul, juste vide

<xsl: when test = "string-length (field-you-want-to-test) <1">

D'après mon expérience, le meilleur moyen est:

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

Utilisez simple categoryName / text () Un tel test fonctionne très bien <categoryName/>aussi <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>