Tekstifunktsioonid XSLis

Asukoha järgi saab andmeid XSLi abil XMList ilusti välja võtta. Et kui soovitakse küsida kolmanda inimese eesnimi, siis kirjutatakse /inimesed/inimene[3]/eesnimi sobivasse kohta, näiteks xsl:value-of elemendi select-parameetriks. 

Kui soovitakse aga nimest vaid esitähte, siis võib kirjutada

        Esitäht: <xsl:value-of select="substring(/inimesed/inimene[1]/eesnimi, 1, 1)" />

Funktsioonile substring tuleb ette anda otsitav tekst ning kaks arvu: mitmendast tähest alates ning mitu tähte väljastada. 

Funktsiooni enese kuju

substring(s1, start, nr?)

Järgnevalt siis mõned levinumad sõnefunktsioonid:

concat(s1, s2, s3*)  

Parameetritena antud tekstid liidetakse. Elementide arv ei ole piiratud. Üldjuhul saab hakkama ka ilma seda funktsioonid kasutamata, pannes lihtsalt järjestikku vajalikke xsl:value-of elemente ning tekste. Aga mõnikord on concati abil andmeid lühem reastada.  Näiteks initsiaalide tarbeks

          <xsl:value-of select="concat(substring(/inimesed/inimene[1]/eesnimi, 1, 1),'.', 
                  substring(/inimesed/inimene[1]/perenimi, 1, 1), '.')" />

Ehk siis concati sees komadega eraldatult eesnime esitäht, punkt (tekstina esitamiseks ülakomade vahel), siis perekonnanime esitäht ning sellele järgnev punkt.


        <xsl:value-of select="substring-before('muna ja kana', 'ja')" />

  annab tulemuseks "muna". Mõlema funktsiooni kujud näevad välja järgnevalt, teine lihtsalt annab välja eraldajale järgneva osa.

substring-before(s1, s2)
substring-after(s1, s2)

Pea igas programmeerimiskeeles on käsklus teksti pikkuse küsimiseks. Nii ka siin.

string-length(s1) 

ehk siis näitena 

<xsl:value-of select="string-length('Mati')" />

annab tulemuseks arvu 4. 

normalize-space(s1)   
Võtab algusest ja otstest tühikud, muud vahed teeb  üheks tühikuks. Kasulik näiteks erikujuliste sisestatud tekstide võrdlemisel või lihtsalt väljundi viisakamaks muutmisel. XMLi andmete juures ei mängi korduvad tühikud rolli, küll aga neist võib tüli tekkida mõnda muusse kohta suunduva väljundi puhul.

translate (s1, algsümbolid, lõppsümbolid)
Tähtede asendamiseks leiab harjumatu kujuga funktsiooni. Näite järgi on aga ehk toimimine mõistetav: translate('pann', 'an', 'ek') -> 'pekk'


Ülesandeid

* Koosta XML-andmefail, kus on kirjas auto registrinumber ning omaniku perekonnanimi
* Trüki välja auto registrinumber
* Trüki välja auto registrinumbri numbrite osa
* Trüki välja auto registrinumbri tähtede osa
* Trüki välja inimese perekonnanime esimene täht
* Trüki välja inimese perekonnanime viimane täht



Loendamine

Vastuse küsimusele, mitu elementi vastab soovitud otsingule, annab funktsioon count. Näiteks inimeste arvu saab kokku järgnevalt:

        Inimeste arv: <xsl:value-of select="count(/inimesed/inimene)" />

Tahtes kokku loendada kõiki inimesi, kelle eesnimi on Juku, tuleb vastav piirang kirjutada inimese taha kandiliste sulgude sisse.

        Jukude arv: <xsl:value-of select="count(/inimesed/inimene[eesnimi='Juku'])" />

Saab võrrelda ka suurem ja väikesem olemist. Vastavad võrdlused aga on viisakas kirjutada XMLi jaoks sobivate märgikombinatsioonidena. "Väiksem kui" oleks siis kujul &lt; (less than) ning "suurem kui" kujul &gt; (greater than).

        Enne Moskva olümpiat sündinud: <xsl:value-of select="count(/inimesed/inimene[synd &lt; 1980])" />

Ülesandeid

* Koosta/otsi XML-andmefail, kus on kirjas auto registrinumber ning omaniku perekonnanimi
* Leia, mitme inimese perekonnanimi on Kaalikas
* Leia, mitme inimese perekonnanimi algab M-tähega
* Leia, mitme auto registrimärgi numbritest viimane on 2
* Leia, mitme auto registrimärgi numbritest viimane on 1 või 2




Tingimused

Programmeerimise juures on võimalik tingimusele vastavalt midagi teha või tegemata jätta. Nii ka siin. Tavalise valiku tarvis on käsklus xsl:if. Näide:

        <xsl:if test="starts-with(/inimesed/inimene[1]/eesnimi, 'J')">
          Esimene nimi algab jotiga
        </xsl:if>

Kui tingimus vastab tõele, siis sealne tekst trükitakse, muidu mitte. Käsu kuju siis
	starts-with(s1, s2)  
ning selgitus
	Kontrollitakse, kas esimesena antud tekst algab teisena antud tekstiga.

Mõnevõrra sarnane funktsioon on 
	contains(s1, s2)
Võrreldes eelmisega ei pruugita alustada algusest, vaid otsitakse lõigu leidmist kogu teksti ulatuses.

Tõeväärtuse saab vastuspidiseks pöörata funktsiooniga not(), eraldi else-lauset ei ole. 

        <xsl:if test="not(starts-with(/inimesed/inimene[1]/eesnimi, 'A'))">
            Esimene nimi ei alga a-ga
        </xsl:if>

Tingimuseks sobivad ka igasugu võrdlused, mille vastuseks on "jah" või "ei". Näiteks, et kas teksti pikkus on väiksem kui viis sümbolit. Märk "on väiksem kui" ehk "<" kirjutatakse kujul &lt; (less than), sest nii vastab see XMLi süntaksile (millele XSL leht peab töötamiseks vastama. Näiteks 

        <xsl:if test="string-length(/inimesed/inimene[1]/eesnimi) &lt; 5">
           Lühike nimi
        </xsl:if>

Ülesandeid

* Koosta/leia XML-andmefail, kus on kirjas auto registrinumber ning omaniku perekonnanimi
* Kui registrimärgi viimane number on 5, siis teata, et ülevaatuse kuu on juuli
* Teata iga registrinumbri puhul, millises kuus auto ülevaatusele peab minema.
* Kui perekonnanimes sisaldub täht x, siis teata, et tegemist on võõrnimega.
* Muul juhul teata, et tegemist pole võõrnimega.


Kordused

Kui samatüübilisi andmeid on palju, siis tulevad appi kordused. Nii ka XSLi juures. Tsükli loomiseks sobib käsklus xsl:for-each, select-parameetrina antakse ette elemendid mille kontekstis ploki sisu korrata. Et tööd alustatakse juurelemendile vastavast mallist 

    <xsl:template match="/">

ning sealt seest küsitakse kõiki elemente, mis vastavad mustrile inimesed/inimene, siis saadakse kätte algsest failist kõik viis inimest, kes on pöördutavad kujul /inimesed/inimene.

Tsükli sees on igal korral jooksvaks elemendiks juba konkreetne inimene. Esimesel korral siis näiteks

    <inimene>
        <eesnimi>Juku</eesnimi>
        <perenimi>Juurikas</perenimi>
        <synd>1963</synd>
    </inimene>

Seal saab juba otse pöörduda alamelementide poole. Ehk siis 

            <xsl:value-of select="eesnimi" />

annab vastuseks Juku. Ning iga järgmise ringi juures juba järgmise inimese eesnime. 



<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <xsl:for-each select="inimesed/inimene">
            <xsl:value-of select="eesnimi" />
        </xsl:for-each>
    </xsl:template>
</xsl:stylesheet>


Käivitades XSL-lehe koos andmefailiga saame tulemuse arvatavasti kujul

JukuJukuKalleMariOskar

Tahtes nimede vahele tühikuid saada, sobib abielemendina xsl:text, mis lubab elemendi alguse ja lõpu vahele kirjutatud teksti otse väljundisse saata. 

        <xsl:for-each select="inimesed/inimene">
            <xsl:value-of select="eesnimi" />
            <xsl:text> </xsl:text>
        </xsl:for-each>

Annab siis tulemuseks

  Juku Juku Kalle Mari Oskar


Kui aga juba HTMLi sisse andmete kirjutamiseks läheb, siis pole otsesed tühikud ja reavahetused kuigi tähtsad - loeb lihtsalt nende olemasolu või puudumine, mitte kogus. Kujundamiseks on aga seal juba omad käsud. Näiteks loetelu jaoks tavapärane komplekt <ul> kogu loetelu tähistamiseks ning <li> üksiku elemendi tarbeks. Need saab rahumeeli XSLi faili sisse panna. 

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <ul>
        <xsl:for-each select="inimesed/inimene">
            <li><xsl:value-of select="eesnimi" /></li>
        </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>

Tulemusena võib ilusti vormindatud tulemust imetleda.

      <ul>
  <li>Juku</li>
  <li>Juku</li>
  <li>Kalle</li>
  <li>Mari</li>
  <li>Oskar</li>
</ul>


Sama tulemuse saab programmide puhul ikka mitmel moel kätte. Eelnenud näites öeldi xsl:for-eachi juures, et läbi tuleb käia kõik elemendid nimega inimene ning xsl:value-ofi juures määrati, et näha soovitakse inimese seest eesnime.

Järgnevas näites saadakse sama tulemus nõnda, et juba xsl:for-eachi juures käiakse läbi kõikide inimeste eesnimed. Ning xsl:value-ofi juures pole muud vaja öelda, kui et tuleb kuvada jooksva elemendi (mida tähistatakse punktiga) väärtus.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <ul>
        <xsl:for-each select="inimesed/inimene/eesnimi">
            <li><xsl:value-of select="." /></li>
        </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>


	Ehkki XSL pole mõeldud suuremamahulisteks arvutusteks ja tekstitöötluseks, õnnestub lihtsamad võrdlused ja kokkuvõtted siin täiesti teha. Järgnevalt siis loetelu nende inimeste perekonnanimedest, kelle eesnimi algab J-iga. Algandmete peale vaadates leiame sealt kaks Jukut: üks Juurikas ning teine Kaalikas. Vastavad perekonnanimed saadakse jätte järgneva avaldise abil.

  <xsl:for-each select="/inimesed/inimene[starts-with(eesnimi, 'J')]/perenimi" >

	Kandiliste sulgude sees määratakse ära, millistele tingimustele vastavaid inimesi loetellu võetakse. Siin juhul siis kontrolliks XSLi funktsioon nimega starts-with, parameetriteks kontrollitav tekst ning otsitav algustekst. Ning nagu muud tõeväärtusfunktsioonid, nii ka siin on väärtuseks jah või ei. Ning loetellu jäävad need inimesed, kel avaldise puhul väärtuseks jah. Ning nõnda saab tsükli sees otsitud tulemused välja kirjutada.


<?xml version="1.0"?>
<xsl:stylesheet 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output encoding="UTF-8" method="html" />

<xsl:template match="/">
  <xsl:for-each select="/inimesed/inimene[starts-with(eesnimi, 'J')]/perenimi" >
     <xsl:value-of select="." />;
  </xsl:for-each>
</xsl:template>
</xsl:stylesheet>

Käivitamine nii nagu eelnenud näite puhul


E:\kasutaja\jaagup\xml>java XSLMuundur inimesed.xml inimesed4.xsl inimesed4.txt

Ning faili sisu piiludes võime just soovitud read selle seest avastada.

E:\kasutaja\jaagup\xml>more inimesed4.txt
Juurikas;
  Kaalikas;


Plokifunktsioone

Kui tsükli abil plokis liikuda, siis tuleb vahel kasuks teada, mitmendal ringil parajasti ollakse ning mitu ringi kokku on. Vastavad abiks olevad funktsioonid on järgnevad:

last()        viimase järjekorranumber
position()    jooksva järjekorranumber

Ehk siis järgnevas näites trükitakse iga eesnime ette tema järjekorranumber. 

            <xsl:value-of select="concat(position(),' - ',eesnimi)" />

Käsklus position() annab järjekorranumbri, concat seob ühte ritta kokku selle numbri, sidekriipsu ning vastava inimese eesnime, kelle juures ollakse. 

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <ul>
        <xsl:for-each select="inimesed/inimene">
            <li><xsl:value-of select="concat(position(),' - ',eesnimi)" /></li>
        </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>


Väljund paistab välja järgnev:

      <ul>

  <li>1 - Juku</li>
  <li>2 - Juku</li>
  <li>3 - Kalle</li>
  <li>4 - Mari</li>
  <li>5 - Oskar</li>
</ul>


Kui tahta juurde määrata, et mitmes nimi mitmest, siis tuleb lisaks viimase järjekorranumbrit näitav last().

        <ul>
        <xsl:for-each select="inimesed/inimene">
            <li><xsl:value-of select="concat(position(),'/',last(),' - ',eesnimi)" /></li>
        </xsl:for-each>
        </ul>
 
Ning tulemus veebilehel järgmine:


    * 1/5 - Juku
    * 2/5 - Juku
    * 3/5 - Kalle
    * 4/5 - Mari
    * 5/5 - Oskar


Ülesandeid

* Koosta/leia XML-andmefail, kus on kirjas autode registrinumbrid ning omaniku perekonnanimed
* Trüki välja kõik perekonnanimed
* Lisa iga perekonnanime ette tema järjekorranumber
* Need read, kus registrinumbri viimane number lõppeb ühe või kahega trüki rasvaselt.



Kujundus korduse sees

Lisaks nimede/andmete ettelugemisele on küllalt sageli vajalik/kasulik neid ka vastavalt juurdekuuluvatele omadustele kujundada, et sobivaid ridu oleks kergem üles leida. Tingimuslauseid, arvutusi ja muid käsklusi saab rahumeeli kasutada ka korduse või korduste sees. Järgnevalt värvitakse hiljem kui 1980ndal aastal sündinud inimeste eesnimed roheliseks. Tehakse eesnimele ümber span-plokk ning sealse stiiliga määratakse nime värv. Ja kui tahta ka ülejäänud nimesid näidata, ainult et tavaliste mustadena, siis üks moodus on loodud plokk lihtsalt kopeerida, tingimusele ümberpöörav not-käsklus ümber panna ning nimele sobiv värv määrata. 

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <ul>
        <xsl:for-each select="inimesed/inimene">
            <li>
                <xsl:if test="synd &gt; 1980">
                    <span style="color:green">
                        <xsl:value-of select="eesnimi" />
                    </span>
                </xsl:if>
                <xsl:if test="not(synd &gt; 1980)">
                    <span style="color:black">
                        <xsl:value-of select="eesnimi" />
                    </span>
                </xsl:if>
            </li>
        </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>

Tulemusena siis loetelu, kus iga nime juures märgitud värv.

      <ul>
  <li>
    <span style="color:black">Juku</span>
  </li>
  <li>
    <span style="color:black">Juku</span>
  </li>
  <li>
    <span style="color:black">Kalle</span>

  </li>
  <li>
    <span style="color:green">Mari</span>
  </li>
  <li>
    <span style="color:black">Oskar</span>
  </li>
</ul>


Sama saab aga ka märgatavalt lühemalt kirja panna. Iseenesest pole ju nime värvimiseks talle vaja eraldi span-elementi ümber panna. Piisab, kui nime näitava elemendi - praegusel juhul li - stiilis on sobiv värv määratud. Käsklus xsl:attribute võimaldabki juba alanud elemendi sisse atribuute lisada. Järgnevas näites siis näha, et noorematele kui 1980ndal sündinutele pannakse loeteluelemendile rohelise värvi atribuut külge.



        <ul>
        <xsl:for-each select="inimesed/inimene">
            <li>
                <xsl:if test="synd &gt; 1980">
                    <xsl:attribute name="style">color:green</xsl:attribute>
                </xsl:if>
                <xsl:value-of select="eesnimi" />
            </li>
        </xsl:for-each>
        </ul>


Ning pärast käivitamist on see ilusti näha ka tulemuse juures.

<ul>
  <li>Juku</li>
  <li>Juku</li>
  <li>Kalle</li>
  <li style="color:green">Mari</li>
  <li>Oskar</li>
</ul>


Pikemate ridade puhul on heaks tavaks mõned read ära värvida, et oleks parem andmeid lugeda ja näpuga järge ajada. Reanumbri saame kätte käsuga position(). Nüüd, kui on tahtmine kindla arvu ridade tagant erivärviline rida luua, siis on heaks abivahendiks jagamise jääk, modulus, ehk siin tehe nimega mod. Näitab, et kui vasakul pool olev kogus jagada paremal pool olevaks arvuks võrdseteks osadeks, mitu siis jääb üle. Kui näiteks kaksteist õuna jagada võrdselt neljale lapsele, siis saab igaüks kolm õuna, ühtegi üle ei jää ehk jääk on null. Kui aga on õunu kolmteist, siis üks õun jääb üle ehk jääk on üks. Neljateistkümne puhul kaks, viieteistkümne puhul kolm ning kuusteist jagub taas neljaga, siis jääk jälle null. Nii et kui tahaks iga neljanda rea teistsuguseks teha, siis piisaks kontrollida, et kas jääk jagamisel neljaga on mingi kindel arv nendest võimalikest jääkidest. Ühe puhul oleks värvitud kohe esimene rida, kahe puhul teine, kolme puhul kolmas. Ning kõigepealt neljanda värvimiseks piisab kontrollimast, kas jääk on null. Iga teise rea värvimiseks näiteks sobib järgnev kood:

            <li>
                <xsl:if test="position() mod 2 =0">
                    <xsl:attribute name="style">background-color:lightgray</xsl:attribute>
                </xsl:if>
                <xsl:value-of select="eesnimi" />
            </li>

Ning tulemus veebilehe koodis on selline.

<ul>
  <li>Juku</li>
  <li style="background-color:lightgray">Juku</li>
  <li>Kalle</li>
  <li style="background-color:lightgray">Mari</li>
  <li>Oskar</li>
</ul>


Ülesandeid

* Koosta/leia XML-andmefail, kus on kirjas autode registrinumbrid ning omaniku perekonnanimed
* Väljasta andmed tabelina: registrinumbrid ühes ning perekonnanimed teises tulbas.
* Värvi ridade taustad üle ühe halliks.
* Värvi taustad nõnda, et järjestikku oleksid värvitu, hall ja kollane.


Mitu kordust samade andmetega

Tavaliselt käiakse andmed ühe korra läbi, näidatakse mis tarvis ja kogu lugu. Aga vahel võib olla põhjust ka mitu korda samu andmeid läbi käia ning elementide vahel seoseid leida ja välja märkida. Järgnevas näites luuakse tabel, kus nii veergudes kui ridades on samad inimesed. Veergude ja ridade ristumiskohal aga nende sünniaastate vahe - siis kohe näha, kes kui palju kellest vanem on. Kui kordus määratakse juurelemendist alates, siis on selline sättimine lihtne - piisab kaks for-each tsüklit üksteise sisse panna ning mõlemale määrata, et tuleb läbi käia elemendid mustriga /inimesed/inimene. Veidi mõtlemist vajab aastate vahe arvutus, sest sisemise inimese sünniaasta varjestab välimise oma ära. Aitab aga, kui välimine element jätta eraldi muutujasse meelde. Siis saab selle andmed ka sisemises plokis kätte ning võib nendega rahus toimetada. 


<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <table>
            <tr>
                <th>Inimeste vanuste vahe</th>
              <xsl:for-each select="/inimesed/inimene">
                  <th>
                      <xsl:value-of select="concat(eesnimi, ', ', synd)"></xsl:value-of>
                  </th>
              </xsl:for-each>
            </tr>
            <xsl:for-each select="/inimesed/inimene">
                <tr>
                    <xsl:variable name="v2limine" select="." />
                    <td>
                        <xsl:value-of select="eesnimi" />
                    </td>
                 <xsl:for-each select="/inimesed/inimene">
                     <td>
                         <xsl:value-of select="number(synd)-number($v2limine/synd)" />
                     </td>
                 </xsl:for-each>
                </tr>
            </xsl:for-each>
        </table>
    </xsl:template>
</xsl:stylesheet>


Veebilehel väljund näha järgmine:


Inimeste vanuste vahe  	Juku, 1963  	Juku, 1961  	Kalle, 1975  	Mari, 1981  	Oskar, 1971
Juku 	0 	-2 	12 	18 	8
Juku 	2 	0 	14 	20 	10
Kalle 	-12 	-14 	0 	6 	-4
Mari 	-18 	-20 	-6 	0 	-10
Oskar 	-8 	-10 	4 	10 	0

Ülesandeid

* Pane näide käima
* Vähem kui viieaastase vanusevahega lahtrid näita teise värviga

* Kirjuta lahtritesse vastavate inimeste perekonnanimed. Nt. Kalle ja Mari ristumiskohale tuleb "Kaalikas ja Maasikas"
* Võrreldes eelmisega jäta tühjaks need lahtrid, kus inimene kohtub iseenesega (kõige viisakam kindlaks teha positsiooni järgi).


XSL eri struktuuriga andmefailidele

Eelnevad näited olid loodud kindlate elemendinimedega andmefaili seest väärtuste kogumiseks ja esitamiseks. Vahel aga võivad andmefailid olla küll mõneti sarnased, aga sugugi mitte samade elemendinimedega ja -kogustega. Tüüpiliseks näiteks on mitmed algselt tabeli kujul olevad andmed, mis XML-i kujule viidud ning mida hiljem sealt soov taas HTML- või mõne muu tabeli kujul esitada. Sellisel juhul osutub kasulikuks käsklus name, mille abil saab etteantud ploki nime küsida. Samuti on kasulik metamärk * (tärn), mis tähistab kõiki vastavas kohas asuvaid alamelemente. Või kui küsida sellise alamelementide ploki nime, siis antakse neist esimese nimi. Siin on allikaks sama inimeste fail. Käsklus name(*) annab vastuseks "inimesed", kuna ollakse  juure juures. Käsklus name(*/*) väljastab "inimene", sest see on eelneva alamelement. Tegelikult mustrile vastavad kõik elemendid "inimene", aga kuna küsitakse nime ainult ühe kohta, siis väljastatakse esimese oma. Tahtes läbi käia esimese inimese kõik alamelemendid, sobib tsükliks

        <xsl:for-each select="*/*[1]/*">

Lahtiseletatult siis esimene tärn tähendab juures asuvat elementi "inimesed". Järgmine *[1] on esimene inimene. Ning viimase tärni alt tulevad välja esimese inimese eesnimi, perenimi ja synd. Tahtes saada elementide nimesid ja mitte väärtusi, siis aitab taas käsklus name, sedakorda kujul

                <xsl:value-of select="name(.)" />

kus trükitakse välja parasjagu jooksva elemendi nimi. Kogu XSLi kood:


<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template match="/">
        <h1>
            Juurelement: <xsl:value-of select="name(*)" />
        </h1>
        <h2>
            Esimene alamelement: <xsl:value-of select="name(*/*)" />
        </h2>
        <h3>Alamelemendi järglased: </h3>
        <ul>
        <xsl:for-each select="*/*[1]/*">
            <li>
                <xsl:value-of select="name(.)" />
            </li>
        </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>


Ning tulemuseks saadi siis järgnev HTML, kus võib veenduda, et kõik elemendid õigesti kätte saadi.

      <h1>Juurelement: inimesed</h1>
<h2>Esimene alamelement: inimene</h2>
<h3>Alamelemendi järglased: </h3>
<ul>
  <li>eesnimi</li>
  <li>perenimi</li>
  <li>synd</li>
</ul>


Edasi tasub mõelda, et millisel kujul on soov andmeid esitada. Kui veebilehel ja tabelina, siis on tabeli HTML-käsud igati asjakohased. Eelneva loetelu saab vormistada tabeli tulpade pealkirjadena.


        <h1><xsl:value-of select="name(*)" /></h1>
        <table>
         <tr>
          <xsl:for-each select="*/*[1]/*">
            <th>
                <xsl:value-of select="name(.)" />
            </th>
          </xsl:for-each>
         </tr>
        </table>

Ning väljund veebilehel on järgnev.


      <h1>inimesed</h1>
<table>
  <tr>
    <th>eesnimi</th>
    <th>perenimi</th>
    <th>synd</th>
  </tr>
</table>


Soovides lisaks pealkirjadele ka tegelikke andmeid sisse panna, tuleb lihtsalt kaks tsüklit juurde panna. Pealkirjad ja lahtrite sisud tuleb eraldi tsüklitesse paigutada lihtsalt HTMLi loogka tõttu, kus tuleb vasakult paremale oma andmeid väljastada. Ehkki vajaduse ja tahtmise korral oleks võimalik ehk ka pealkirjaplokk ja andmete läbikäigu plokk ühendada ning lihtsalt if-iga kontrollida, kas ollakse andmetega esimese rea juures. Kui jah, siis oleks paras aeg lisaks muule ka pealkirjalahtrid kirjutada. Siin näites aga pealkirjaosa ja andmete osa eraldi kirjutatud. Andmete tsüklis siis kõigepealt 

            <xsl:for-each select="*/*">

käib läbi kõik elemendid "inimene". Sealt seest 

                    <xsl:for-each select="*">

võtab kõik, mis ühe inimese seest võtta on. Ning viimaks

                            <xsl:value-of select="." />

annab selle elemendi väärtuse, kus sees parajasti oma läbikäiguga ollakse. 

        <h1><xsl:value-of select="name(*)" /></h1>
        <table>
         <tr>
          <xsl:for-each select="*/*[1]/*">
            <th>
                <xsl:value-of select="name(.)" />
            </th>
          </xsl:for-each>
         </tr>
            <xsl:for-each select="*/*">
                <tr>
                    <xsl:for-each select="*">
                        <td>
                            <xsl:value-of select="." />
                        </td>
                    </xsl:for-each>
                </tr>
            </xsl:for-each>
        </table>


Tulemuseks on viisakas HTML-i tabel. 

      <h1>inimesed</h1>

<table>
  <tr>
    <th>eesnimi</th>
    <th>perenimi</th>
    <th>synd</th>
  </tr>
  <tr>
    <td>Juku</td>
    <td>Juurikas</td>
    <td>1963</td>
  </tr>
  <tr>
    <td>Juku</td>
    <td>Kaalikas</td>
    <td>1961</td>
  </tr>
  <tr>
    <td>Kalle</td>
    <td>Kaalikas</td>
    <td>1975</td>
  </tr>
  <tr>
    <td>Mari</td>
    <td>Maasikas</td>
    <td>1981</td>
  </tr>
  <tr>
    <td>Oskar</td>
    <td>Ohakas</td>
    <td>1971</td>
  </tr>
</table>


Ülesandeid

* Tee näited läbi. Lisa inimesele tunnuseks mass. Veendu, et andmed väljastatakse ka siis tabelina.
* Muuda näidet nõnda, et tabeli asemel genereeritaks loetelu, kus on näha iga elemendi vaid kaks esimest väärtust.
  Näiteks esimese puhul Juku Juurikas
* Muuda näidet nõnda, et tabeli asemel genereeritaks komadega eraldatud loetelu. Nt
  <li>Juku,Juurikas,1963</li>
* Muuda näidet nõnda, et tabeli asemel genereeritaks laused, mille abil vastavaid andmeid SQL-baasi sisestada. Inimeste puhul näeks siis lause välja:
  INSERT INTO inimesed (eesnimi, perenimi, synd) VALUES ('Juku', 'Juurikas', '1963');
* Koosta/leia XML-andmefail, kus on kirjas autode registrinumbrid ning omaniku perekonnanimed
* Veendu, et eelnevalt koostatud XSL-lehed töötavad ka uue andmefailiga.


 Parameetrid

	Kui samade algandmete põhjal tahetakse kokku panna märgatavalt erinevaid tulemusi, siis tuleb üldjuhul igaks muundamiseks valmis kirjutada omaette XSL-leht. Näiteks HTML- ja WAP-väljund näevad nõnda erinevad välja, et ühist muundajat kirjutada oleks raske. Kui aga valida lihtsalt eri resolutsioonidele arvestatud HTML-i vahel, siis võib XSLi parameetri abil kord rohkem, kord vähem lähteandmeid sisse võtta. Samuti, kui näiteks soovitakse näidata lehel inimeste vanuseid, salvestatud on aga sünniaastad, siis parameetrina antud praeguse aastaarvu järgi saab vähemalt ligikaudugi tulemuse parajaks sättida.
	Parameetri väärtus tuleb määrata eraldi elemendina enne mallikirjelduste algust. Nagu näha, tuleb parameetri nimi atribuudina, väärtus aga elemendi väärtusena. 
<xsl:param name="pikkus">5</xsl:param>

	Hiljem atribuudi väärtust küsides tuleb avaldises selle nimele dollarimärk ette panna. Ilma dollarita tähendaks see vastavanimelist XML-elementi. 

<xsl:value-of select="$pikkus" />

	Andmete sortimiseks tuleb tsükli sisse paigutada alamelement nimega xsl:sort ning parameetrina määrata, millise elemendi väärtuse järgi sorteeritakse. Nagu mujal, nii ka siin oleks võimalik parameetriks koostada avaldis, mis järjestamise peenemalt ette määraks. 

    <xsl:sort select="eesnimi" order="descending" />

	Soovides väljatrüki abil tühikuga eraldatud ees- ja perekonnanime, aitab funktsioon concat. Muul juhul tuleks sama tulemuse saavutamiseks xsl:value-of element mitmel korral välja kutsuda. 

     <xsl:value-of select="concat(eesnimi, ' ', perenimi)" />;

	Ning näide tervikuna.

<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output encoding="UTF-8" method="html" />

<xsl:param name="otsing">ar</xsl:param>
<xsl:param name="pikkus">5</xsl:param>

<xsl:template match="/">
  Nimed, mis sisaldavad kombinatsiooni <xsl:value-of select="$otsing" />:
  <xsl:for-each select="/inimesed/inimene[contains(eesnimi, $otsing)]">
    <xsl:sort select="eesnimi" order="descending" />
     <xsl:value-of select="concat(eesnimi, ' ', perenimi)" />;
  </xsl:for-each>

  Nimed pikkusega <xsl:value-of select="$pikkus" /> ja rohkem:
  <xsl:for-each select="/inimesed/inimene[string-length(eesnimi)>=$pikkus]" >
     <xsl:value-of select="concat(eesnimi, ' ', perenimi, 
          ' varuks ', string-length(eesnimi)-$pikkus)" />;
  </xsl:for-each>
</xsl:template>
</xsl:stylesheet>

Käivitus

E:\kasutaja\jaagup\xml>java XSLMuundur inimesed.xml inimesed4a.xsl inimesed4a.txt

ja tulemus

E:\kasutaja\jaagup\xml>more inimesed4a.txt

  Nimed, mis sisaldavad kombinatsiooni ar:
  Oskar Ohakas;
  Mari Maasikas;


  Nimed pikkusega 5 ja rohkem:
  Kalle Kaalikas varuks 0;
  Oskar Ohakas varuks 0;

	Parameetrite väärtuste muutmiseks ei pea alati tekstiredaktoriga muutma XSLi faili sisu. Neid saab sättida ka otse XMLi ja XSLi kokkusiduvas koodis ning ka ühendava programmi väljakutsel. Nõnda on ka siin näha, kus pikkusele antakse väärtuseks neli.

    tolkija.setParameter("pikkus", "4");

	Muus osas näeb faile ühendav käivitusprogramm eelnenuga sarnane välja.

import javax.xml.transform.*;
import javax.xml.transform.stream.*;
import java.io.*;
public class XSLParameetrid{
  public static void main(String argumendid[]) throws Exception{
    Transformer tolkija=TransformerFactory.newInstance().
      newTransformer(new StreamSource("inimesed4a.xsl"));
    tolkija.setParameter("pikkus", "4");
    tolkija.transform(
      new StreamSource("inimesed.xml"), 
      new StreamResult(new FileOutputStream("inimesed4a.txt"))    
    );    
  }
}

Ka käivitamine sarnane

E:\kasutaja\jaagup\xml>java XSLParameetrid

	Ning tulemusena näeb siis nelja tähe pikkusi ja pikemaid nimesid.

E:\kasutaja\jaagup\xml>more inimesed4a.txt

  Nimed, mis sisaldavad kombinatsiooni ar:
  Oskar Ohakas;
  Mari Maasikas;


  Nimed pikkusega 4 ja rohkem:
  Juku Juurikas varuks 0;
  Juku Kaalikas varuks 0;
  Kalle Kaalikas varuks 1;
  Mari Maasikas varuks 0;
  Oskar Ohakas varuks 1;


ASP.NET vahenditega sama XSL-lehte käivitades on põhjust veebilehele luua kohad parameetrite väärtuste sisestamiseks. Siinses näites kasutatakse selle tarbeks tekstivälju. Pöörates tähelepanu lehekülje päisele näeb, et sedakorda on põhjust eraldi koodifaili loomiseks, millest siis veebileht päritakse. 


<%@ Page Language="C#" AutoEventWireup="true" CodeFile="parameetrid.aspx.cs" Inherits="parameetrid" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Parameetritega leht</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
      <pre>
        <asp:Xml ID="xml1" runat="server" DocumentSource="~/inimesed1.xml" TransformSource="~/inimesed4a.xslt" />
       </pre>
        <br />
        Otsitav tekst: <asp:TextBox ID="kast1" runat="server" /><br />
        Miinimumpikkus: <asp:TextBox ID="kast2" runat="server" /><br />
        <asp:Button runat="server" text="Sisesta"  />
    </div>
    </form>
</body>
</html>


Eraldi koodifailis, lehe laadimisel käivituvas meetodis nimega Page_Load on kirjas, et millised parameetrite väärtused tuleb XSL-failile edasi anda. Eelnevast XSL-failis on näha, et selle algusosas on defineeritud kaks parameetrit. Parameeter nimega otsing vaikeväärtusega "ar" ning parameeter pikkus väärtusega 5. Siinses näites kirjutatakse otsinguparameeter alati üle tekstiväljast tuleva väärtusega. Pikkus asendatakse aga vaid juhul, kui selle jaoks mõeldud tekstiväljas nimega kast2 oli väärtus, mida on võimalik arvuks teisendada. XsltArgumentList-tüüpi muutujasse kogutakse parameetrid ja nende väärtused kokku ning siis pannakse vastav parameetrite loetelu transformatsiooni eest hoolitseva elemendi külge. 



using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Web;
using System.Web.Security;
using System.Xml.Xsl;

public partial class parameetrid : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        XsltArgumentList p = new XsltArgumentList();
        p.AddParam("otsing", "", kast1.Text);
        int abi;
        if(int.TryParse(kast2.Text, out abi)){
            p.AddParam("pikkus", "", kast2.Text);
        }
        xml1.TransformArgumentList = p;
    }
}

Nulemusena võib siis näha sisestatud andmetele vastavat tulemust veebilehel. Element pre aitas tekstina tulnud andmed viisakalt eraldi ridadele joondada.

        
        Nimed, mis sisaldavad kombinatsiooni M:
        Mari Maasikas;
        

        Nimed pikkusega 2 ja rohkem:
        Juku Juurikas varuks 2;
        Juku Kaalikas varuks 2;
        Kalle Kaalikas varuks 3;
        Mari Maasikas varuks 2;
        Oskar Ohakas varuks 3;
        
      

Otsitav tekst:M
Miinimumpikkus:2

Ülesandeid

* Koosta tervitav XSL-leht, mille pealkiri antakse ette parameetriga
* Anna parameetrina ette praeguse aasta number. Väljasta iga inimese vanus selle aasta lõpuks.
* Lase kasutajal tekstiväljast anda ette vähim ja suurim sünniaasta, mille vahel olevate inimeste andmeid näidatakse.



Mallid, alamprogrammid

Enamikes enesest lugu pidavates programmeerimiskeeltes on eraldiseisvate ning korduvalt ettevõetavate toimingute tarbeks olemas alamprogrammid või midagi sarnast. XSLis on selleks tarbeks mallid. Kirjeldatakse ära, kuidas mingeid andmeid väljundis näidata ning hiljem saab selle malli sobivas kohas välja kutsuda. Järgnevas näiteks on omaette malliks tehtud saatja aadress. Et kui seda vaja kuhugi kirjale lisada, siis piisab vaid vastavast väljakutsest. Defineerimise kohal siis

       <xsl:template name="saatjaaadress">

ning väljakutsel

       <xsl:call-template name="saatjaaadress" />

Kogu kood tervikuna:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template name="saatjaaadress">
      Tallinna Ülikooli Informaatika Instituut, Narva maantee 25-419, 10120, Tallinn
    </xsl:template>

    <xsl:template match="/">
       Lugupeetud vilistlane, kutsume teid taas vana kooli vaatama!
       <br />
       <xsl:call-template name="saatjaaadress" />
    </xsl:template>
</xsl:stylesheet>

Ja nagu koodi lugedes aimata võib, tulemuseks on teade koos sinna lõppu lisatud saatja aadressiga.


Lugupeetud vilistlane, kutsume teid taas vana kooli vaatama!
Tallinna Ülikooli Informaatika Instituut, Narva maantee 25-419, 10120, Tallinn


Et malli töö tulemust vastavalt andmetele muuta saaks, selleks tuleb ette anda parameetrid. Malli enese algusesse tuleb kirjutada, et millise nimega parameeter on.

        <xsl:param name="enimi" />

Koodis parameetri väärtuse kasutamiseks tuleb sinna dollarimärk ette panna. 

        Tere, <xsl:value-of select="$enimi" />


Väljakutsel saab temale ette anda tavalise väärtuse. Et Siim on etteantud tekstikonstant, teda ei võeta XML-faili seest, selleks on nimele ülakomad ümber pandud. 

        <xsl:call-template name="tervitus">
            <xsl:with-param name="enimi" select="'Siim'" />
        </xsl:call-template>

XSLi kood tervikuna

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template name="tervitus">
        <xsl:param name="enimi" />
        Tere, <xsl:value-of select="$enimi" />
    </xsl:template>

    <xsl:template match="/">
        <xsl:call-template name="tervitus">
            <xsl:with-param name="enimi" select="'Siim'" />
        </xsl:call-template>
    </xsl:template>
</xsl:stylesheet>


Ning tekkinud väljund:

Tere, Siim

Kui nimi võetakse XMList, siis tuleb määrata asukoht, kust see leida. Praegusel juhul antakse alamprogrammile parameetrina kaasa esimese inimese eesnimi.

    <xsl:template match="/">
        <xsl:call-template name="tervitus">
            <xsl:with-param name="enimi" select="inimesed/inimene[1]/eesnimi" />
        </xsl:call-template>
    </xsl:template>

Käivitamisel tervitatakse teda rõõmsasti.

Tere, Juku


Malli parameetriks ei pruugi olla üksiks väärtus. Selleks võib olla ka etteantud kohast algav andmepuu (nt. terve inimene kõikide tema juurde kuuluvate andmetega) või siis andmekogum (massiiv). Järgnevas näites pruugitaksegi viimast varianti. Loetelu saamiseks käiakse xsl:for-each tsükliga läbi kõik etteantud andmestiku elemendid. Ning malli väljakutsel olev inimesed/inimene/eesnimi annabki kõikide vastavas XML-failis olevate inimeste eesnimed parameetrina kaasa.


<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" indent="yes"/>
    <xsl:template name="loetelu">
        <xsl:param name="andmestik" />
        <ul>
            <xsl:for-each select="$andmestik">
                <li>
                    <xsl:value-of select="." />
                </li>
            </xsl:for-each>
        </ul>
    </xsl:template>

    <xsl:template match="/">
        <h1>Inimeste eesnimede loetelu</h1>
        <xsl:call-template name="loetelu">
            <xsl:with-param name="andmestik" select="inimesed/inimene/eesnimi" />
        </xsl:call-template>
    </xsl:template>
</xsl:stylesheet>


 
Tulemuseks on viisakas loetelu.

      <h1>Inimeste eesnimede loetelu</h1>

<ul>
  <li>Juku</li>
  <li>Juku</li>
  <li>Kalle</li>
  <li>Mari</li>
  <li>Oskar</li>
</ul>

Ülesandeid

* Koosta mall, mis väljastaks tärnidest rea. Katseta.
* Koosta mall, mis trükiks etteantud teksti välja punaselt.
* Võrreldes eelmisega saab ka värvi anda ette malli väljakutsel

* Koosta mall, mis trükib etteantud elemendist loeteluna välja kõikide alamelementide nimed ja nende väärtused.
* Koosta mall, mis saab etta sarnase struktuuriga elementide (näiteks inimeste) massiivi ning väljastab nende alamelementide tulemused tabelina. Katseta mitmesuguste sisendandmete korral.