XSLT - Using <xsl:element> to Create Dynamic XML Elements

The <xsl:element> instruction in XSLT is used to create an element dynamically in the output document. Unlike normal literal result elements, where the element name is written directly in the stylesheet, <xsl:element> allows the element name to be determined at runtime. This is particularly useful when the name of an output element comes from an XML source value, a variable, or an expression. The basic syntax is <xsl:element name="element-name">...</xsl:element>, where the name attribute specifies the name of the element to be created.

For example, suppose the input XML contains information about products and stores the desired output element name in an attribute:

<products>
    <product type="book">
        <name>XML Basics</name>
    </product>
    <product type="software">
        <name>Web Editor</name>
    </product>
</products>

An XSLT stylesheet can use the type attribute to dynamically determine the output element name:

<xsl:template match="/">
    <catalog>
        <xsl:for-each select="products/product">
            <xsl:element name="{@type}">
                <xsl:value-of select="name"/>
            </xsl:element>
        </xsl:for-each>
    </catalog>
</xsl:template>

The expression {@type} is especially important here. The curly braces indicate that the value of the type attribute should be evaluated and used as the element name. Therefore, when the first product is processed, an element named <book> is generated. When the second product is processed, an element named <software> is generated. The resulting output is:

<catalog>
    <book>XML Basics</book>
    <software>Web Editor</software>
</catalog>

The major advantage of <xsl:element> is that it provides flexibility when the output structure cannot be completely determined when the stylesheet is written. For example, an application may receive XML containing different categories, languages, product types, or report sections. Instead of writing separate templates for every possible element name, <xsl:element> can construct the appropriate element based on the input data. This makes an XSLT transformation more adaptable to changing XML structures.

The name attribute can also use a variable or another expression. For example:

<xsl:variable name="elementName" select="'customer'"/>

<xsl:element name="{$elementName}">
    <xsl:text>John</xsl:text>
</xsl:element>

This produces:

<customer>John</customer>

Here, the variable contains the element name, and {$elementName} tells XSLT to evaluate the variable and use its value as the name of the generated element. This technique is useful when element names are determined by program logic rather than being directly available as attributes in the source XML.

<xsl:element> can also be used to create elements with namespaces. The namespace attribute can specify the namespace URI associated with the dynamically created element. For example:

<xsl:element name="item" namespace="http://example.com/products">
    <xsl:text>Computer</xsl:text>
</xsl:element>

The resulting element belongs to the specified namespace. This is useful when transforming XML documents that follow namespace-based vocabularies or standards.

It is important to understand the difference between a literal element and <xsl:element>. If a stylesheet contains:

<customer>
    <xsl:value-of select="name"/>
</customer>

the output element will always be named <customer>. The element name is fixed when the stylesheet is written. With:

<xsl:element name="{$elementName}">
    <xsl:value-of select="name"/>
</xsl:element>

the element name can change according to the value of $elementName. Therefore, literal result elements are generally preferable when the element name is known, while <xsl:element> is useful when the name must be generated dynamically.

Another important consideration is that the dynamically generated name must be a valid XML element name. If the value used for the name attribute does not represent a valid element name, the transformation can produce an error. Therefore, when element names come from external or unpredictable data, the input should be properly controlled or validated.

In practical applications, <xsl:element> is useful for generating XML reports, converting database-style XML structures, creating category-based documents, producing configurable XML vocabularies, and handling transformations where the output element names depend on source data. It provides a powerful way to make an XSLT stylesheet dynamic without having to know every possible output element name in advance.

Key Points

  • <xsl:element> creates an XML element dynamically.

  • The name attribute determines the name of the generated element.

  • Curly braces such as {@type} allow an XPath expression to determine the element name.

  • Variables can also be used to specify dynamic element names.

  • The namespace attribute can be used when the generated element belongs to a particular namespace.

  • It is especially useful when output element names depend on input data.

  • Literal result elements are generally simpler when the element name is fixed.

  • The generated name must comply with XML naming rules.

Thus, <xsl:element> is an important XSLT feature for situations where the structure of the output XML needs to be determined dynamically during transformation.