1. Web
  2. Web-APIs
  3. XSLTProcessor

Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.

View in English Always switch to English

XSLTProcessor

Deprecated

Avoid using this feature in new projects. XSLT is a candidate for removal from browsers because browser implementations are highly susceptible to memory safety vulnerabilities. This feature may be a candidate for removal from web standards or browsers.

Ein XSLTProcessor wendet eine XSLT Stylesheet-Transformation auf ein XML-Dokument an, um ein neues XML-Dokument als Ausgabe zu erzeugen. Er verfügt über Methoden, um das XSLT-Stylesheet zu laden, um <xsl:param> Parameterwerte zu bearbeiten und um die Transformation auf Dokumente anzuwenden.

Konstruktor

XSLTProcessor()

Erstellt einen neuen XSLTProcessor.

Instanzmethoden

XSLTProcessor.importStylesheet()

Importiert das XSLT-Stylesheet. Wenn der übergebene Knoten ein Dokumentknoten ist, können Sie entweder eine vollständige XSL-Transformation oder eine Literal Result Element Transform übergeben; andernfalls muss es ein <xsl:stylesheet> oder <xsl:transform> Element sein.

XSLTProcessor.transformToFragment()

Transformiert die Quellnode durch Anwendung des mit der Funktion XSLTProcessor.importStylesheet() importierten XSLT-Stylesheets. Das Eigentümerdokument des resultierenden Dokumentfragments ist der Eigentümerknoten.

XSLTProcessor.transformToDocument()

Transformiert die Quellnode durch Anwendung des mit der Funktion XSLTProcessor.importStylesheet() importierten XSLT-Stylesheets.

XSLTProcessor.setParameter()

Setzt einen Wert für einen Parameter (<xsl:param>) im importierten XSLT-Stylesheet.

XSLTProcessor.getParameter()

Ruft den Wert eines Parameters aus dem XSLT-Stylesheet ab.

XSLTProcessor.removeParameter()

Entfernt den Parameter, falls er zuvor gesetzt wurde. Dadurch verwendet der XSLTProcessor den Standardwert für den Parameter, wie er im XSLT-Stylesheet angegeben ist.

XSLTProcessor.clearParameters()

Entfernt alle gesetzten Parameter aus dem XSLTProcessor. Der XSLTProcessor verwendet dann die im XSLT-Stylesheet angegebenen Standardwerte.

XSLTProcessor.reset()

Entfernt alle Parameter und Stylesheets aus dem XSLTProcessor.

Instanzeigenschaften

Es gibt keine Eigenschaften für diese Schnittstelle.

Beispiele

Instanziierung eines XSLTProcessor

js
async function init() {
  const parser = new DOMParser();
  const xsltProcessor = new XSLTProcessor();

  // Load the XSLT file, example1.xsl
  const xslResponse = await fetch("example1.xsl");
  const xslText = await xslResponse.text();
  const xslStylesheet = parser.parseFromString(xslText, "application/xml");
  xsltProcessor.importStylesheet(xslStylesheet);

  // process the file
  // …
}

Erstellen eines XML-Dokuments basierend auf einem Teil des DOM eines Dokuments

Für die eigentliche Transformation benötigt XSLTProcessor ein XML-Dokument, das in Verbindung mit der importierten XSL-Datei verwendet wird, um das endgültige Ergebnis zu produzieren. Das XML-Dokument kann eine separate XML-Datei sein, die mit fetch() geladen wurde, oder es kann Teil der bestehenden Seite sein.

Um einen Teil des DOMs einer Seite zu verarbeiten, muss zunächst ein XML-Dokument im Speicher erstellt werden. Angenommen, das zu verarbeitende DOM wird von einem Element mit der ID example enthalten, kann dieses DOM mit der Methode Document.importNode() des XML-Dokuments im Speicher "geklont" werden. Document.importNode() ermöglicht das Übertragen eines DOM-Fragments zwischen Dokumenten, in diesem Fall von einem HTML-Dokument zu einem XML-Dokument. Der erste Parameter referenziert den zu klonenden DOM-Knoten. Wenn der zweite Parameter "true" ist, werden auch alle Nachkommen geklont (ein tiefes Klonen). Das geklonte DOM kann dann mit Node.appendChild() in das XML-Dokument eingefügt werden, wie unten gezeigt.

js
// Create a new XML document in memory
const xmlRef = document.implementation.createDocument("", "", null);

// We want to move a part of the DOM from an HTML document to an XML document.
// importNode is used to clone the nodes we want to process via XSLT - true makes it do a deep clone
const myNode = document.getElementById("example");
const clonedNode = xmlRef.importNode(myNode, true);

// Add the cloned DOM into the XML document
xmlRef.appendChild(clonedNode);

Sobald das Stylesheet importiert wurde, muss XSLTProcessor zwei Methoden für die eigentliche Transformation ausführen, nämlich XSLTProcessor.transformToDocument() und XSLTProcessor.transformToFragment(). XSLTProcessor.transformToDocument() gibt ein vollständiges XML-Dokument zurück, während XSLTProcessor.transformToFragment() ein Dokumentfragment zurückgibt, das leicht in ein bestehendes Dokument eingefügt werden kann. Beide verwenden das XML-Dokument als ersten Parameter, das transformiert werden soll. XSLTProcessor.transformToFragment() erfordert einen zweiten Parameter, nämlich das Dokumentobjekt, das das erzeugte Fragment besitzen wird. Wenn das erzeugte Fragment in das aktuelle HTML-Dokument eingefügt wird, reicht es aus, document zu übergeben.

Erstellen eines XML-Dokuments aus einem String 'XML Soup'

Sie können den DOMParser verwenden, um ein XML-Dokument aus einem XML-String zu erstellen.

js
const parser = new DOMParser();
const doc = parser.parseFromString(str, "text/xml");

Durchführung der Transformation

js
const fragment = xsltProcessor.transformToFragment(xmlRef, document);

Einfaches Beispiel

Das einfache Beispiel wird eine XML-Datei laden und eine XSL-Transformation darauf anwenden. Es handelt sich um dieselben Dateien, die im Beispiel HTML generieren verwendet werden. Die XML-Datei beschreibt einen Artikel und die XSL-Datei formatiert die Informationen für die Anzeige.

XML

xml
<?xml version="1.0"?>
<myNS:Article xmlns:myNS="http://devedge.netscape.com/2002/de">
  <myNS:Title>My Article</myNS:Title>
  <myNS:Authors>
    <myNS:Author company="Foopy Corp.">Mr. Foo</myNS:Author>
    <myNS:Author>Mr. Bar</myNS:Author>
  </myNS:Authors>
  <myNS:Body>
    The <b>rain</b> in <u>Spain</u> stays mainly in the plains.
  </myNS:Body>
</myNS:Article>

XSLT

xml
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
                   xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                   xmlns:myNS="http://devedge.netscape.com/2002/de">

  <xsl:output method="html" />

  <xsl:template match="/">
    <html>

      <head>

        <title>
          <xsl:value-of select="/myNS:Article/myNS:Title"/>
        </title>

        <style>
          .myBox {margin:10px 155px 0 50px; border: 1px dotted #639ACE; padding:0 5px 0 5px;}
        </style>

      </head>

      <body>
        <p class="myBox">
          <span class="title">
            <xsl:value-of select="/myNS:Article/myNS:Title"/>
          </span> <br />

          Authors:   <br />
            <xsl:apply-templates select="/myNS:Article/myNS:Authors/myNS:Author"/>
          </p>

        <p class="myBox">
          <xsl:apply-templates select="//myNS:Body"/>
        </p>

      </body>

    </html>
  </xsl:template>

  <xsl:template match="myNS:Author">
     --   <xsl:value-of select="." />

    <xsl:if test="@company">
     ::   <b>  <xsl:value-of select="@company" />  </b>
    </xsl:if>

    <br />
  </xsl:template>

  <xsl:template match="myNS:Body">
    <xsl:copy>
      <xsl:apply-templates select="@*|node()"/>
    </xsl:copy>
  </xsl:template>

  <xsl:template match="@*|node()">
      <xsl:copy>
        <xsl:apply-templates select="@*|node()"/>
      </xsl:copy>
  </xsl:template>
</xsl:stylesheet>

Das Beispiel lädt sowohl die .xsl- (xslStylesheet) als auch die .xml-Dateien (xmlDoc) in den Speicher. Die .xsl-Datei wird dann importiert (xsltProcessor.importStylesheet(xslStylesheet)) und die Transformation ausgeführt (xsltProcessor.transformToFragment(xmlDoc, document)). Dadurch können Daten nach dem Laden der Seite abgerufen werden, ohne dass ein neuer Seitenladevorgang gestartet wird.

JavaScript

js
async function init() {
  const parser = new DOMParser();
  const xsltProcessor = new XSLTProcessor();

  // Load the XSLT file, example1.xsl
  const xslResponse = await fetch("example1.xsl");
  const xslText = await xslResponse.text();
  const xslStylesheet = parser.parseFromString(xslText, "application/xml");
  xsltProcessor.importStylesheet(xslStylesheet);

  // Load the XML file, example1.xml
  const xmlResponse = await fetch("example1.xml");
  const xmlText = await xmlResponse.text();
  const xmlDoc = parser.parseFromString(xmlText, "application/xml");

  const fragment = xsltProcessor.transformToFragment(xmlDoc, document);

  document.getElementById("example").textContent = "";
  document.getElementById("example").appendChild(fragment);
}

init();

Fortgeschrittenes Beispiel

Dieses fortgeschrittene Beispiel sortiert mehrere Divs basierend auf ihrem Inhalt. Das Beispiel erlaubt das mehrfache Sortieren des Inhalts, wobei zwischen aufsteigender und absteigender Reihenfolge gewechselt wird. Das JavaScript lädt die .xsl-Datei nur beim ersten Sortieren und setzt die Variable xslLoaded auf true, sobald das Laden der Datei abgeschlossen ist. Mit der Methode XSLTProcessor.getParameter() kann der Code herausfinden, ob in aufsteigender oder absteigender Reihenfolge sortiert werden soll. Es wird standardmäßig aufsteigend sortiert, wenn der Parameter leer ist (das erste Mal, wenn die Sortierung erfolgt, da es keinen Wert dafür in der XSLT-Datei gibt). Der Sortierwert wird mit XSLTProcessor.setParameter() gesetzt.

Die XSLT-Datei hat einen Parameter namens myOrder, den JavaScript setzt, um die Sortiermethode zu ändern. Das order-Attribut des xsl:sort-Elements kann auf den Wert des Parameters über $myOrder zugreifen. Der Wert muss jedoch ein XPATH-Ausdruck und keine Zeichenkette sein, daher wird {$myOrder} verwendet. Die Verwendung von {} wertet den Inhalt als XPath-Ausdruck aus.

Sobald die Transformation abgeschlossen ist, wird das Ergebnis an das Dokument angehängt, wie in diesem Beispiel gezeigt.

XHTML

html
<div id="example">
  <div>1</div>
  <div>2</div>
  <div>3</div>
  <div>4</div>
  <div>5</div>
  <div>6</div>
  <div>7</div>
  <div>8</div>
  <div>9</div>
  <div>10</div>
</div>

JavaScript

js
let xslRef;
let xslLoaded = false;
const parser = new DOMParser();
const xsltProcessor = new XSLTProcessor();
let myDOM;

let xmlRef = document.implementation.createDocument("", "", null);

async function sort() {
  if (!xslLoaded) {
    const response = await fetch("example2.xsl");
    const xslText = await response.text();
    xslRef = parser.parseFromString(xslText, "application/xml");
    xsltProcessor.importStylesheet(xslRef);
    xslLoaded = true;
  }

  // Create a new XML document in memory
  xmlRef = document.implementation.createDocument("", "", null);

  // We want to move a part of the DOM from an HTML document to an XML document.
  // importNode is used to clone the nodes we want to process via XSLT - true makes it do a deep clone
  const myNode = document.getElementById("example");
  const clonedNode = xmlRef.importNode(myNode, true);

  // After cloning, we append
  xmlRef.appendChild(clonedNode);

  // Set the sorting parameter in the XSL file
  const sortVal = xsltProcessor.getParameter(null, "myOrder");

  if (sortVal === "" || sortVal === "descending") {
    xsltProcessor.setParameter(null, "myOrder", "ascending");
  } else {
    xsltProcessor.setParameter(null, "myOrder", "descending");
  }

  // Initiate the transformation
  const fragment = xsltProcessor.transformToFragment(xmlRef, document);

  // Clear the contents
  document.getElementById("example").textContent = "";

  myDOM = fragment;

  // Add the new content from the transformation
  document.getElementById("example").appendChild(fragment);
}

XSLT

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

  <xsl:param name="myOrder" />

  <xsl:template match="/">

    <xsl:apply-templates select="/div//div">
      <xsl:sort select="." data-type="number" order="{$myOrder}" />
    </xsl:apply-templates>
  </xsl:template>

  <xsl:template match="div">
    <xsl:copy-of select="." />
  </xsl:template>
</xsl:stylesheet>

Spezifikationen

Spezifikation
DOM
# interface-xsltprocessor

Browser-Kompatibilität

Siehe auch

Help improve MDN

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.
Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden