XSLT 学习记录（一些语法和知识，备忘）

Enjoy ^_^

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:fo="http://www.w3.org/1999/XSL/Format">
    <xsl:output method="html"/>
    <xsl:template match="/">
        <xsl:apply-templates select="//CCC"/>
    </xsl:template>
    <xsl:template match="CCC" priority="4">
        <div style="color: green">
            <!-- node name -->
            <xsl:value-of select="name()"/>
            <!-- text -->
            <xsl:text> id=</xsl:text>
            <!-- attribute -->
            <xsl:value-of select="@id"/>
            <xsl:value-of select="data/@color"/>
        </div>
    </xsl:template>
    <!--match attribute-->
    <xsl:template match="@id">
        <b>
            <i>
                <xsl:value-of select="."/>
            </i>
        </b>
    </xsl:template>
    <!--hava attribute or not-->
    <xsl:template match="car[@checked]">
        <p>
            <xsl:text>Car: </xsl:text>
            <xsl:value-of select="@id"/>
        </p>
    </xsl:template>
    <xsl:template match="car[not(@checked)]">
        <p style="color: red;">
            <xsl:text>Car: </xsl:text>
            <xsl:value-of select="@id"/>
        </p>
    </xsl:template>
    <!--any child -->
    <!-- xsl:for-each -->
    <xsl:for-each select="/source//*">
        <!-- call template not apply-template-->
        <xsl:call-template name="print"/>
    </xsl:for-each>
    <!-- called template-->
    <xsl:template name="print">
        <xsl:value-of select="./@id"/>
        <!-- for each child -->
        <xsl:for-each select="child::*">
            <xsl:value-of select="./@id"/>
        </xsl:for-each>
        <!-- for each descendant -->
        <xsl:for-each select="descendant::*">
               </xsl:for-each>
        <!-- xsl:for-each parent -->
        <xsl:for-each select="parent::*">
            <!--xsl:if test="not(@id)"-->
            <xsl:if test="not(@id)">
                <xsl:value-of select="name()"/>
            </xsl:if>
            <xsl:value-of select="./@id"/>
        </xsl:for-each>
        <!-- xsl:for-each ancester -->
        <xsl:for-each select="ancestor::*">
               </xsl:for-each>
        <!-- xsl:for-each following-sibling-->
        <xsl:for-each select="following-sibling::*">
               </xsl:for-each>
        <!-- xsl:for-each preceding-sibling -->
        <xsl:for-each select="preceding-sibling::*">
               </xsl:for-each>
        <!--xsl:following-->
        <xsl:for-each select="following::*">
               </xsl:for-each>
        <!-- preceding -->
        <xsl:for-each select="preceding::*">
               </xsl:for-each>
        <!-- attribute -->
        <xsl:for-each select="attribute::*">
        </xsl:for-each>
        <!-- namespace -->
        <xsl:for-each select="namespace::*">
        </xsl:for-each>
        <!-- self -->
        <xsl:for-each select="self::*">
        </xsl:for-each>
        <!-- descendant-or-self -->
        <xsl:for-each select="descendant-or-self::*">
        </xsl:for-each>
        <!-- ancestor-or-self -->
        <xsl:for-each select="ancestor-or-self ::*">
        </xsl:for-each>
        <!-- abbreviated -->
        <xsl:value-of select="child::BBB"/>
        <xsl:value-of select="BBB"/>
        <xsl:value-of select="attribute::id"/>
        <xsl:value-of select="@id"/>
        <xsl:value-of select="parent::BBB"/>
        <xsl:value-of select="../BBB"/>
        <xsl:value-of select="name(/descendant-or-self::*)"/>
        <xsl:value-of select="name(//*)"/>
        <!-- The xsl:for-each instruction contains a template, 
        which is applied to each node selected with select attribute. -->
        <xsl:for-each select="//BBB">
        </xsl:for-each>
        <!-- Nodes selected with xsl:for-each or xsl:apply-templates 
        can be sorted.  -->
        <xsl:for-each select="//name">
            <xsl:sort order="ascending" select="."/>
            <xsl:value-of select="."/>
        </xsl:for-each>
        <xsl:for-each select="//name">
            <xsl:sort order="descending" select="."/>
        </xsl:for-each>
        <xsl:apply-templates select="//name">
            <xsl:sort order="descending" select="."/>
        </xsl:apply-templates>
        <!-- sorts can be in text and in numeric mode. -->
        <xsl:sort data-type="text" select="@id"/>
        <xsl:sort data-type="number" select="@id"/>
        <!-- sorts upercase and lowercase letters firs -->
        <xsl:sort case-order="upper-first" select="@id"/>
        <xsl:sort case-order="lower-first" select="@id"/>
        <!-- xsl:element generates elements in time of processing. -->
        <!-- there are new element created around the value-->
        <xsl:for-each select="//text">
            <xsl:element name="{@size}">
                <xsl:value-of select="."/>
            </xsl:element>
        </xsl:for-each>
        <!-- xsl:attribute generates elements in time of processing. 
        It creates attribute in the element in which it is enclosed.  -->
        <!-- result is <TD style="color:green">green</TD>
        attribute is created dynamicly-->
        <TD>
            <xsl:attribute name="style">
                <xsl:text>color:</xsl:text>
                <xsl:value-of select="."/>
            </xsl:attribute>
            <xsl:value-of select="."/>
        </TD>
        <!-- Copy and copy-of constructs are used for nodes copying. 
        Copy element copies only the current node without children and attributes, 
        while copy-of copies everything. -->
        <xsl:copy-of select="."/>
        <xsl:copy/>
        <!-- The xsl:copy element may have a use-attribute-sets attribute. 
        In this way attributes for copied element can be specified. -->
        <!-- result is <h1 align="center" style="color:red">GREETING</h1> 
        add attributes-->
        <xsl:copy use-attribute-sets="H1">
            <xsl:value-of select="."/>
        </xsl:copy>
        <xsl:attribute-set name="H1">
            <xsl:attribute name="align">center</xsl:attribute>
            <xsl:attribute name="style">color:red</xsl:attribute>
        </xsl:attribute-set>
        <!-- xsl:if instruction enables conditional processing.-->
        <!-- position function and last function -->
        <xsl:for-each select="entry">
            <xsl:value-of select="@name"/>
            <xsl:if test="not (position()=last())">
                <xsl:text>, </xsl:text>
            </xsl:if>
        </xsl:for-each>
        <!-- xsl:choose element is used for selection between several possibilities.  -->
        <xsl:choose>
            <xsl:when test="SUMMARY">
          </xsl:when>
            <xsl:otherwise>
          </xsl:otherwise>
        </xsl:choose>
        <!-- How to find out that some text starts with a number.  -->
        <xsl:if test="starts-with(translate(., '0123456789', '9999999999'), '9')">  
        </xsl:if>
        <!-- demonstrates the default behaviour of xsl:number element -->
        <!-- Numbering of individual chapter elements depends on position of the chapter element.  -->
        <!-- Each level of chapters is numbered independently. -->
        <xsl:for-each select="//chapter">
            <TR>
                <TD>
                    <xsl:number/>
                    <!-- using level="multiple" will result a more reasonalbe answer -->
                    <xsl:number level="multiple"/>
                </TD>
                <TD>
                    <xsl:value-of select="./text()"/>
                </TD>
            </TR>
        </xsl:for-each>
        <!-- xsl:number inserts formated numbers into output.  -->
        <!-- The format is given with format attribute. -->
        <!-- The attribute starts with format identificator followed by separator characters. -->
        <xsl:number value="position()" format="1. "/>
        <xsl:number value="position()" format="001. "/>
        <xsl:number value="position()" format="a# "/>
        <xsl:number value="position()" format="i: "/>
        <xsl:number value="position()" format="I... "/>
        <!-- examples of formatting of multilevel numbers. -->
        <xsl:number level="multiple" format="1.A.a "/>
        <xsl:number level="multiple" format="I-1-a:"/>
        <!-- different ways of setting xsl:variable -->
        <!-- setting xsl:variable -->
        <!-- call the variable -->
        <xsl:variable name="totalChapters">
            <xsl:value-of select="count(//chapter)"/>
        </xsl:variable>
        <xsl:value-of select="$totalChapters"/>
        <!-- or -->
        <xsl:variable name="totalChapters" select="count(//chapter)"/>
        <xsl:value-of select="$totalChapters"/>
        <!-- setting xsl:param. -->
        <xsl:param name="totalChapters">
            <xsl:value-of select="count(//chapter)"/>
        </xsl:param>
        <xsl:value-of select="$totalChapters"/>
        <!-- or -->
        <xsl:param name="totalChapters" select="count(//chapter)"/>
        <xsl:value-of select="$totalChapters"/>
        <!-- A stylesheet can contain several variables of the same name. -->
        <!-- demonstrates a way how to recover the value of global variable which has the same name as a local one. -->
        <xsl:variable name="text">Chapter</xsl:variable>
        <xsl:for-each select="//chapter">
            <TR>
                <TD>
                    <xsl:variable name="text">
                        <xsl:choose>
                            <xsl:when test="position() = 1">First chapter</xsl:when>
                            <xsl:when test="position()=last()">Last chapter</xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="$text"/>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:value-of select="$text"/>
                </TD>
            </TR>
        </xsl:for-each>
        <!-- Parameters for a template can be passed with xsl:with-param element. -->
        <!-- If the template contains a xsl:param element with the same name as name attribute of xsl:with-param, 
        this value is used.  -->
        <xsl:apply-templates select=".">
            <!-- this param will be passed -->
            <xsl:with-param name="type">odd</xsl:with-param>
        </xsl:apply-templates>
        <xsl:apply-templates select="."/>
        <xsl:template match="number">
            <xsl:param name="type">even</xsl:param>
            <xsl:value-of select="."/>
            <xsl:text> (</xsl:text>
            <xsl:value-of select="$type"/>
            <xsl:text>)</xsl:text>
        </xsl:template>
        <!-- A variable can hold a result tree fragment. -->
        <!-- The operations permitted on a result tree fragment are a subset of those permitted on a node-set. -->
        <!-- An operation is permitted on a result tree fragment only if that operation would be permitted on a string 
        (the operation on the string may involve first converting the string to a number or boolean).  -->
        <!-- In particular, it is not permitted to use the /, //, and [] operators on result tree fragments. 
        When a permitted operation is performed on a result tree fragment, 
        it is performed exactly as it would be on the equivalent node-set. -->
        <xsl:variable name="A1">
            <xsl:copy-of select="//TABLE[1]"/>
        </xsl:variable>
        <xsl:variable name="A2">
            <xsl:copy-of select="//TABLE[2]"/>
        </xsl:variable>
        <xsl:template match="/">
            <xsl:copy-of select="$A2"/>
            <xsl:copy-of select="$A1"/>
            <xsl:copy-of select="$A2"/>
        </xsl:template>
        <!-- important difference in variable value specification -->
        <!-- 1st and 3rd are valued first, 2nd and 4th are text -->
        <xsl:with-param name="path1" select="//AAA/CCC/DDD"/>
        <xsl:with-param name="path2">//AAA/CCC/DDD</xsl:with-param> 
        <xsl:variable name="var1" select="//AAA/CCC/text()"/>
        <xsl:variable name="var2">//AAA/CCC/text()</xsl:variable> 
        <!-- Functions number transforms its argument into a number -->
        <!-- string conversion -->
        <!-- conversion of boolean values true and false. -->
        <xsl:value-of select="number()"/>  
        <xsl:value-of select="number(false())"/>  
        <xsl:value-of select="number(true())"/>  
        <xsl:value-of select="number(5 > 7)"/>  
        <!-- subtraction and multiplication uses common syntax -->
        <!-- Division syntax is less usual. Slash / is used in patterns 
        and so keyword div is used instead -->
        <!-- Operator mod returns the remainder from a truncating division. -->
        <xsl:value-of select="//number[1] + //number[2]"/>  
        <xsl:value-of select="//number[3] - //number[4]"/>  
        <xsl:value-of select="//number[5] * //number[6]"/>  
        <xsl:value-of select="//number[5] div //number[6]"/>  
        <xsl:value-of select="//number[5] mod //number[6]"/>  
        <!-- Function sum() sums all numbers in selected nodes -->
        <xsl:value-of select="sum(//number)"/>  
        <!-- only odd ones -->
        <xsl:value-of select="sum(//number[text() mod 2 = 1])"/>  
        <!-- Functions ceilng(), floor() and round() transform floating point 
        numbers into integers in the specified way. -->
        <xsl:value-of select="floor(.)"/>  
        <xsl:value-of select="ceiling(.)"/>  
        <xsl:value-of select="round(.)"/>  
        <!-- Function string() transforms its argument into string.
        This function is not usualy directly used in stylesheets as it is in most cases called by default -->
        <xsl:value-of select="string(number($A))"/>  
        <!-- Test, if element value is a number -->
        <xsl:if test="string(number(.))='NaN'"> is not a number</xsl:if>  
        <!-- strings are arguments of boolean() function. 
        A string is true if and only if its length is non-zero. 
        node-sets as arguments for boolean() function.  -->
        <xsl:value-of select="boolean(text())"/>  
        <!-- text transformed into numbers and then subjected to boolean() function.  -->
        <xsl:value-of select="boolean(number(text()))"/>  
        <!-- The boolean value of "0" is true if "0" is a string, but false if "0" is a number. -->
        <xsl:value-of select="boolean(//text[text()='0'])"/>
        <xsl:value-of select="boolean(number((//text[text()='0'])))"/>  
        <!-- compares "0" as a string and as a number.  -->
        <xsl:value-of select="boolean(/)"/>  
        <xsl:value-of select="boolean(//text)"/>  
        <xsl:value-of select="boolean(//text[23])"/>  
        <!-- The not function returns true if its argument is false, and false otherwise.  -->
        <xsl:value-of select="car[not(@checked)]"/>  
        <xsl:value-of select="car[@checked]"/>  
        <!-- Functions true() and false() are useful, 
        when some conditions are tested during programming. -->
        <xsl:if test="true()">
            <xsl:text>true </xsl:text>
        </xsl:if>
        <xsl:if test="not(false())">
            <xsl:text>not false</xsl:text>
           </xsl:if> 
           <!-- The lang function returns true or false depending on 
           whether the language of the context node as specified by xml:lang attributes 
           is the same as or is a sublanguage of the language specified by the argument string. -->
           <P xml:lang="de">
             <text xml:lang="cs">a</text>
             <text xml:lang="en">and</text>
             <text>und</text>
           </P>
           <xsl:choose>
               <xsl:when test='lang("cs")'>
                <xsl:text>Czech: </xsl:text>
               </xsl:when>
               <xsl:when test='lang("en")'>
                <xsl:text>English: </xsl:text>
               </xsl:when>
               <xsl:when test='lang("de")'>
                <xsl:text>German: </xsl:text>
               </xsl:when>
            </xsl:choose> 
        <!-- The string-length function returns the number of characters in the string. -->
        <xsl:value-of select="string-length(.)"/>  
        <!-- The normalize-space function returns the argument string with white space normalized 
        by stripping leading and trailing whitespace 
        and replacing sequences of whitespace characters by a single space. -->
        <xsl:value-of select="string-length(normalize-space(.))"/>  
        <!-- The translate function returns the first argument string with occurrences of characters 
        in the second argument string replaced by the character at the corresponding position 
        in the third argument string. -->
        <xsl:value-of select="translate(//text,'egos','EGOS')"/>
        <xsl:value-of select="translate(//text,'se','d')"/>  
        <!-- The position function returns a number equal to the context position and 
        the last function returns a number equal to the context size from the expression evaluation context. -->
        <xsl:if test="position()=1">
              <xsl:value-of select="name()"/>
        </xsl:if> 
        <xsl:apply-templates select="//AAA[last()]//CCC"/>
        <xsl:value-of select="last()"/>  
        <!-- The count function returns the number of nodes in the argument node-set. -->
        <xsl:value-of select="count(//AAA)"/>  
        <xsl:value-of select="count(//CCC[text()])"/> 
        <xsl:value-of select="count(//doc/*) - count(following::ref)"/>  
        <!-- The id function selects elements by their unique ID -->
        <xsl:value-of select="id('body')/text"/>  
        <xsl:value-of select="id('text1')"/>  
        <xsl:for-each select="//*[@*]">  
        </xsl:for-each>
        <!-- Several id's can be provided at once -->
        <xsl:apply-templates select="id('intro body end')"/>
        <xsl:value-of select="id('intro body end')"/>  
        <xsl:value-of select="id('in bod end')"/>  
        <!-- An example of id function usage.  -->
        <xsl:apply-templates select="id(@id)">
               <xsl:with-param name="nmbr">
                <xsl:value-of select="position()"/>
               </xsl:with-param>
            </xsl:apply-templates> 
        <!-- Functions name, local-name, and namespace-uri() are used to 
        get informations about element and attribute names and namespaces.  -->
        <!-- xml source is on: http://www.zvon.org/xxl/XSLTutorial/Output/example53_ch13.html -->
        <xsl:value-of select="name()"/>  
        <xsl:value-of select="local-name()"/>  
        <xsl:value-of select="namespace-uri()"/>  
        <!-- The xsl:output element allows stylesheet authors to specify how they wish the result tree to be output.-->
        <!-- The html output method should not perform escaping for the content of the script and style elements  -->
        <xsl:output method="html"/>  
        <xsl:output method="xml"/>  
        <!-- The encoding attribute specifies the preferred encoding to be used. --> 
        <xsl:output method="html" encoding="UTF-8"/>  
        <xsl:output method="html" encoding="ISO-8859-1"/> 
        <!-- The text output method outputs the result tree by 
        outputting the string-value of every text node in the result tree in document order 
        without any escaping. Look at the source in your browser to see the output.  -->
        <xsl:output method="text"/>  
        <!-- The current function returns a node-set that has the current node as its only member. -->
        <!-- For an outermost expression (an expression not occurring within another expression), 
        the current node is always the same as the context node.  -->
        <xsl:value-of select="./@name"/>  
        <xsl:value-of select="current()/@name"/>
        <!-- However, within square brackets the current node is usually different from the context node. -->
        <xsl:apply-templates select="BBB[./@name='first']"/>  
        <xsl:apply-templates select="BBB[current()/@name='first']"/>  
        <!-- Function generate-id generates id conforming to XML spec. -->
        <xsl:value-of select="generate-id(//AAA) "/>  
        <xsl:value-of select="generate-id(//*[1]) "/>  
        <xsl:value-of select="generate-id(//AAA[1]) "/>  
        <xsl:attribute name="id">
               <xsl:value-of select="generate-id()"/>
        </xsl:attribute> 
        <xsl:attribute name="{name()}">
                    <xsl:value-of select="."/>
               </xsl:attribute> 
           <!-- Other stylesheets can be imported (xsl:import) or included (xsl:include) into a stylesheet.. 
           Importing a stylesheet is the same as including it except that definitions and template rules 
           in the importing stylesheet take precedence over template rules and definitions in the imported stylesheet. -->
           <!-- included xsl could be included in other xsl -->
           <xsl:import href="id3.xsl"/>
           <xsl:include href="id2.xsl"/> 
           <xsl:value-of select="$id2"/>  
           <xsl:value-of select="$id3"/>  
           <!-- pay attention to how to add value to html attribute -->
           <!-- result is <h3 style="color:red">red</h3> -->
           <xsl:template match="AAA">
             <h3 style="color:{.}">
              <xsl:value-of select="."/>
             </h3>
           </xsl:template>
          <!-- always finish xsl analyze, then match in xml, so when include or import the sequence may result 
          overite rules -->
          <!-- You can use xsl:apply-imports element to get information from an imported template, 
          whose behaviour you are changing. -->
          <!-- xsl-apply-imports works only for templates imported with xsl:import, 
          not for templates included with xsl:include  -->
          <!-- works -->
          <xsl:import href="id2.xsl"/>
        <xsl:template match="/*/*">
             <EM>
              <xsl:apply-imports/>
             </EM>
        </xsl:template>
          <!-- not work -->
          <xsl:include href="id2.xsl"/>
        <xsl:template match="/*/*">
             <EM>
              <xsl:apply-imports/>
             </EM>
        </xsl:template>
          <!-- overwrite -->
          <xsl:import href="id2.xsl"/>
        <xsl:template match="/*/*">
             <EM>
              <xsl:value-of select="name()"/>
             </EM>
        </xsl:template>
          <!-- Import precedence is more important than priority precedence.  -->
          <!-- overwrite still work first, although included things maybe have higher priority,
          but it could be overwrite by who include it. -->
    </xsl:template>
</xsl:stylesheet>