Sprawdź, czy ciąg znaków jest pusty lub pusty w XSLT

Jak mogę sprawdzić, czy wartość jest pusta lub pusta w XSL ?

Na przykład, jeśli categoryNamejest pusty? Używam przy wyborze konstruktu.

Na przykład:

<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 != ''"

Edycja : Obejmuje to, moim zdaniem, najbardziej prawdopodobną interpretację „[nie] zerowy lub pusty”, jak wynika z pytania, w tym pseudokod i moje własne wczesne doświadczenia z XSLT. Tj. „Co jest równoważne z następującą Javą?”:

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

Aby uzyskać więcej informacji, np. Wyraźne identyfikowanie wartości null vs. pusta, zobacz odpowiedź Johnavey poniżej i / lub „skrzypce” XSLT , które dostosowałem z tej odpowiedzi, która obejmuje opcję w komentarzu Michaela Kaya, a także szóstą możliwą interpretację.

Wobec braku innych informacji przyjmuję następujący kod 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>

Przykładowy przypadek użycia wyglądałby następująco:

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

Z pustego elementu :

Aby sprawdzić, czy wartość określonego węzła jest pusta

To zależy od tego, co rozumiesz przez „pusty”.

• Nie zawiera węzłów potomnych: not(node())
• Nie zawiera treści tekstowych: not(string(.))
• Nie zawiera tekstu oprócz białych znaków: not(normalize-space(.))
• Nie zawiera nic oprócz komentarzy: not(node()[not(self::comment())])

Co powiesz na?

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

Pierwsze dwa dotyczą wartości pustej, a drugie dwa pustego ciągu.

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

W niektórych przypadkach możesz chcieć wiedzieć, kiedy wartość jest konkretnie pusta, co jest szczególnie konieczne, gdy używasz XML, który został zserializowany z obiektów .NET. Chociaż zaakceptowana odpowiedź działa w tym przypadku, zwraca ten sam wynik, gdy ciąg znaków jest pusty lub pusty, tj. „”, Więc nie można odróżnić.

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

Możesz więc po prostu przetestować atrybut.

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

Czasami konieczna jest znajomość dokładnego stanu i nie można po prostu sprawdzić, czy wystąpiła instancja CategoryName, ponieważ w przeciwieństwie do Javascript

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

Zwróci wartość true dla elementu zerowego.

Wiem, że to pytanie jest stare, ale między wszystkimi odpowiedziami brakuje mi jednego, które jest powszechnym podejściem do tego przypadku użycia w rozwoju XSLT.

Wyobrażam sobie, że brakujący kod z OP wygląda mniej więcej tak:

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

I że dane wejściowe wyglądają mniej więcej tak:

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

Tzn. Zakładam, że może być zero, pusty, pojedynczy lub wiele categoryNameelementów. Aby poradzić sobie z tymi wszystkimi przypadkami za pomocą xsl:choosekonstruktów-style, lub innymi słowy, koniecznie szybko robi się bałagan (tym bardziej, jeśli elementy mogą znajdować się na różnych poziomach!). Typowym idiomem programistycznym w XSLT jest używanie szablonów (stąd T w XSLT), co jest programowaniem deklaratywnym, a nie koniecznym (nie mówisz procesorowi, co ma robić, po prostu mówisz, co chcesz uzyskać, jeśli spełnione są określone warunki). W tym przypadku użycia może to wyglądać mniej więcej tak:

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

Działa to (z każdą wersją XSLT), ponieważ pierwsza powyżej ma wyższy priorytet (ma predykat). Drugi szablon dopasowania „przechodzący” łapie wszystko, co nie jest prawidłowe. Trzeci zadba następnie categoryNameo prawidłowe wyprowadzenie wartości.

Należy zauważyć, że w tym scenariuszu nie ma potrzeby, aby specifially dopasować categorieslub category, ponieważ procesor będzie automatycznie przetwarzać wszystkie dzieci, chyba że mówimy to inaczej (w tym przykładzie, drugi i trzeci szablon nie dalej przetwarzać dzieci, bo nie ma xsl:apply-templatesw im).

To podejście jest łatwiejsze do rozszerzenia niż podejście imperatywne, ponieważ automatycznie zajmuje się wieloma kategoriami i można je rozszerzyć o inne elementy lub wyjątki, po prostu dodając inny pasujący szablon. Programowanie bez rozgałęzień if .

Uwaga: nie ma czegoś takiego jak nullw XML. Istnieje xsi: zero , ale jest to rzadko używane, szczególnie rzadko w nietypowych scenariuszach bez jakiegoś schematu.

Jak mogę sprawdzić, czy wartość jest pusta lub pusta w XSL?

Na przykład, jeśli categoryNamejest pusty?

Jest to prawdopodobnie najprostsze wyrażenie XPath (to w zaakceptowanej odpowiedzi zapewnia test odwrotny i byłoby dłuższe, gdyby było zanegowane):

not(string(categoryName))

Objaśnienie :

Argument not()funkcji powyżej jest false()dokładnie wtedy, gdy nie ma categoryNameelementu podrzędnego („null”) elementu kontekstu lub (jedno takie categoryNamedziecko ) ma wartość ciągu - pusty ciąg.

Używam przy wyborze konstruktu.

Na przykład:

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

W XSLT 2.0 użyj :

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

Oto kompletny przykład :

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

Po zastosowaniu tej transformacji w następującym dokumencie XML:

<categoryName>X</categoryName>

pożądany, poprawny wynik jest generowany :

X

Po zastosowaniu w tym dokumencie XML :

<categoryName></categoryName>

lub na ten temat:

<categoryName/>

lub w tej sprawie

<somethingElse>Y</somethingElse>

powstaje poprawny wynik :

Other

Podobnie użyj tej transformacji 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>

Uwaga : W ogóle nie są używane warunki warunkowe. Dowiedz się więcej o znaczeniu unikania konstrukcji warunkowych w tym ładnym kursie Pluralsight:

„ Wzorce projektowania taktycznego w .NET: kontrola przepływu ”

Jeśli istnieje możliwość, że element nie istnieje w pliku XML, sprawdziłbym zarówno, czy element jest obecny, jak i długość łańcucha jest większa niż 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>

Jeśli węzeł nie ma dostępnej wartości w wejściowym pliku XML, takim jak poniżej xpath,

<node>
    <ErrorCode/>
</node>

Funkcja string () konwertuje na pustą wartość. To działa dobrze:

string(/Node/ErrorCode) =''

Coś takiego działa dla mnie:

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

Albo na odwrót:

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

Uwaga: Jeśli nie sprawdzisz wartości zerowych lub nie obsłużysz wartości zerowych, IE7 zwróci -2147483648 zamiast NaN.

Właściwie to uważam, że lepiej jest po prostu sprawdzać długość łańcucha, ponieważ wiele razy pole nie jest puste, tylko puste

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

Z mojego doświadczenia wynika, że ​​najlepszym sposobem jest:

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

Użyj prostej categoryName / text () Taki test działa dobrze na <categoryName/>i również <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>