Verifica se una stringa è nullo o vuota in XSLT

Question

Come posso verificare se un valore è nullo o vuoto con XSL?

Ad esempio, se categoryName è vuoto? Sto usando un quando si sceglie il costrutto.

Ad esempio:

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

Answer 1

test="categoryName != ''" 

Edit: Questo copre l'interpretazione più probabile, a mio parere, di "[non] nullo o vuoto", come dedotto dalla questione, tra cui è pseudo -code e la mia esperienza iniziale con XSLT. Per esempio, "Che è l'equivalente dei seguenti Java?":

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

Per ulteriori dettagli EG, distintamente identificando nullo vs. vuoto, vedi johnvey's answer below e/o the XSLT 'fiddle' Ho adattato da quella risposta, che comprende la opzione nel commento di Michael Kay e nella sesta interpretazione possibile.

Answer 2

Da Empty Element:

Per testare se il valore di un certo nodo è vuoto

Dipende cosa si intende per vuoto.

• Non contiene nodi figlio: not(node())
• non contiene alcun contenuto testuale: not(string(.))
• non contiene alcun testo diverso dallo spazio: not(normalize-space(.))
• non contiene nulla, tranne commenti: not(node()[not(self::comment())])

Answer 3

Assente di qualsiasi altre informazioni, assumerò il seguente codice 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> 

Un caso d'uso del campione sarebbe simile:

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

Answer 4

In alcuni casi, si potrebbe desiderare di sapere quando il valore è specificamente nullo, che è particolarmente necessario quando si utilizza XML che è stato serializzato dal .NET oggetti. Sebbene la risposta accettata funzioni per questo, restituisce lo stesso risultato anche quando la stringa è vuota o vuota, cioè "", quindi non è possibile differenziare.

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

Così si può semplicemente provare l'attributo.

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

A volte è necessario conoscere l'esatto stato e non si può semplicemente verificare se NomeCategoria è istanziato, perché a differenza di dire Javascript

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

restituirà true per un elemento nullo.

Answer 5

Qualcosa di simile a questo funziona per me:

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

O viceversa:

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

Nota: se non si seleziona i valori nulli o gestire i valori nulli, IE7 restituisce -2147483648 invece di NaN.

Answer 6

Che dire?

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

Answer 7

Primi due accordi con valore null e secondo due con stringa vuota.

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

Answer 8

Se c'è una possibilità che l'elemento non esiste nel codice XML ho iniziato ad esaminare sia che l'elemento è presente e che la stringa di lunghezza è maggiore di 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> 

Answer 9

Con la mia sperimentare il modo migliore è:

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

Answer 10

so che questa domanda è vecchio, ma tra tutte le risposte, mi manca uno che è un approccio comune per questo caso d'uso in fase di sviluppo XSLT.

sto immaginando che il codice mancante dalla OP simile a questa:

<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 che l'ingresso simile a questa:

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

Ie, suppongo non ci può essere pari a zero , vuoto, singolo o multiplo categoryName elementi. Affrontare tutti questi casi usando i costrutti dello stile xsl:choose o, in altre parole, imperativamente, diventa rapidamente disordinato (ancor più se gli elementi possono essere a livelli diversi!). Un tipico linguaggio di programmazione in XSLT è l'uso di modelli (da cui la T in XSLT), che è una programmazione dichiarativa, non imperativa (non si dice al processore cosa fare, basta dire quello che si vuole produrre se sono soddisfatte determinate condizioni). Per questo caso d'uso, che può essere simile a quanto segue:

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

questo funziona (con qualsiasi versione XSLT), perché il primo ha una precedenza più alta (ha un predicato) di cui sopra. Il modello di corrispondenza "fall-through", il secondo, prende tutto ciò che non è valido. Il terzo quindi si occupa di emettere il valore categoryName in modo corretto.

Si noti che in questo scenario non v'è alcuna necessità di abbinare specifially categories o category, perché il processore elabora automaticamente tutti i bambini, a meno che non diciamo altrimenti (in questo esempio, il secondo e il terzo modello di non elaborare ulteriormente i bambini , perché non c'è xsl:apply-templates in loro).

Questo approccio è più facilmente estendibile dell'approccio imperativo, poiché gestisce automaticamente più categorie e può essere espanso per altri elementi o eccezioni semplicemente aggiungendo un altro modello corrispondente. Programmazione senza if-branches.

Nota: non esiste una cosa come null in XML.C'è xsi:nil, ma questo è usato raramente, specialmente raramente in scenari non tipizzati senza uno schema di qualche tipo.

Answer 11

Se un nodo non ha alcun valore disponibile nel XML di input come sotto xpath, funzione

<node> 
    <ErrorCode/> 
</node> 

stringa() converte in valore vuoto. Quindi, questo funziona bene:

string(/Node/ErrorCode) ='' 

Answer 12

Utilizzo semplice categoryName/text() Tale test funziona bene su <categoryName/> e anche <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> 

Answer 13

Come si può verificare se un valore è nullo o vuoto con XSL?

Ad esempio, se categoryName è vuoto?

Questo è probabilmente l'espressione XPath più semplice (quello in risposta accettata prevede un test per l'opposto, e sarebbe più lungo, se negato):

not(string(categoryName)) 

Spiegazione:

L'argomento della funzione not() in alto è false() esattamente quando non c'è categoryName figlio ("null") dell'elemento di contesto o (singolo) categoryName figlio ha valore stringa - la stringa vuota.

sto usando un quando si sceglie costrutto.

Ad esempio:

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

In XSLT 2.0 uso:

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

Ecco un esempio 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 questa trasformazione viene applicata sul seguente documento XML:

<categoryName>X</categoryName> 

The Wanted, il risultato corretto viene prodotto:

X 

Quando applicato su questo documento XML:

<categoryName></categoryName> 

o su questo:

<categoryName/> 

o su questo

<somethingElse>Y</somethingElse> 

t egli risultato corretto è prodotto:

Other 

---

Allo stesso modo, utilizzare questo XSLT 1.0 trasformazione:

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

Do atto: Nessun condizionali vengono utilizzati affatto. Per saperne di più circa l'importanza di evitare costrutti condizionali in questo bel corso Pluralsight:

"Tactical Design Patterns in .NET: Control Flow"

Answer 14

in realtà ho trovato meglio solo test per la lunghezza della corda dal momento che molte volte il campo non è nulla, solo vuoto

< xsl: quando la prova = "stringa di lunghezza (campo-you-want-to-test) < 1">