Definition von XML und wichtige Schlagworte: Unterschied zwischen den Versionen
K (→Einführung) |
|||
| Zeile 1: | Zeile 1: | ||
= Einführung = | = Einführung = | ||
Siehe auch das [https://de.wikipedia.org/wiki/Document_Object_Model Wiki zum DOM]. | |||
{| class="wikitable" | {| class="wikitable" | ||
|- | |- | ||
Version vom 2. Januar 2023, 14:42 Uhr
Einführung
Siehe auch das Wiki zum DOM.
| Schlagwort | Info |
|---|---|
| Titel | XML1.1 Grundlagen (15.10.2003) |
| Author | - |
| Verlag | - |
| ISBN | 30-0-14-41-01 |
XML hat keine vordefinierte DTD, sondern ist nur eine Untermenge von SGML. Daher ist die Sprache nicht abgeschlossen sondern erweiterbar. Mit der entsprechenden DTD werden konkrete Sprachen definiert wie:
| Sprache | Beschreibung | Adresse |
|---|---|---|
| CML | Chemische Strukturen darstellen | http://www.xml-cml.org |
| MathML | Darstellung mathematischer Strukturen | http://www.w3org/Math |
| SVG | Grafikobjekte (auch bewegt) | http://www.w3org/Graphics/SVG |
| WML | Datenübertragung über WAP (veraltet) | http://xml.coverpages.org/wap-wml.html |
| XHTML | HTML 4.0 auf Basis von XML | http://www.w3org/TR/xhtml1 |
| XLink | Extensible Linking Language. Hyperlinks in XML-Dokumenten. Baut auf XPointer auf. | - |
| XPath | Extensible Path Language. Damit können Teile eines XML-Dokuments adressiert werden. Kann von XSLT und XPointer verwendet werden. | - |
| XPointer | Extensible Pointer Language. Beschreibt, wie Adressen in XLink-Ausdrücken verwendet werden sollen. | - |
| XQL | Extensible Query Language ist eine Abfragesprache, welche XML als Datenmodell verwendet. | - |
| XSL | Extensible Stylesheet Language. Beschreibt, wie die XML-Daten dem Benutzer angezeigt werden. Dient daher dem Erstellen von Stylesheets | - |
| XSLT | Extensible Stylesheet Transformation Language. Transformiert XML-Dokumente in andere XML-Dokumente oder andere Sprachen. Die Sprache definiert, wie die Dokumente schlussendlich umgewandelt werden. | - |
XHTML 1.1
Dateien müssen wohl geformt sein. Das heisst, sie dürfen keine syntaktischen Fehler aufweisen.
- Tags werden immer komplett klein geschrieben <klein></klein>
- Jedes Tag muss beendet werden. Ist dies nicht möglich, so wird dieses in sich abgeschlossen: <ende></ende> oder <anfang />
- Verschachtelte Tags müssen korrekt gegliedert sein <aussen><innen></innen></aussen>
- Inline-Tags dürfen keine Blockelemente umschliessen, da sie in einen Block hineingehören <block-p><inline-span></inline-span></block-p>
- Falsche Kombinationen wie ein Button, der ein Select enthält, sind verboten
- Alle Attribute müssen einen Wert besitzen und in Anführungszeichen stehen <tag selected = "selected" height = "99%" />
- Eine Referenzierung über den Namen ist veraltet und sollte von der id abgelöst werden, da das Attribut name auch entfallen kann, die id aber zur Referenzierung enthalten sein muss <tag id = "23" />
- Das Attribut "lang" entfällt und wird zentral als Attribut "xml:lang" festgelegt
- Die Angabe des Doctyps und des Zeichensatzes (falls nicht im Header) ist zwingend. Dazu muss der Namensraum beim html-Tag mitgegeben werden.
<!DOCTYPE html
PUBLIC "-//W3C/DTD XHTML 1.1//EN"
"http://www.w3org/TR/xhtml1/DTD/xhtml11.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title></title>
</head>
<body>
</body>
</html>
Javascript und Stylesheets werden am Besten extern eingebunden. Möchte man diese trotzdem inline verwenden, müssen diese als CDATA erfasst werden, damit der Parser diese überspringt. Der Ort der Einbindung ist egal. Am Besten im Header, so dass diese im Body zur Verfügung stehen.
<style type="text/css">
<![CDATA[
... Hier kommen die Style-Definitionen
]]>
</style>
<style type="text/javascript">
<![CDATA[
... Hier kommen die JavaScript-Anweisungen
]]>
</style>
XML-Dokument Aufbau
Es gelten ähnliche Regeln wie bei XHTML, doch die Elemente sind nicht festgelegt. Folgendes muss man aber einhalten:
- Es braucht am Anfang immer den Header
- Zum parsen braucht es eine DTD, auf die verwiesen werden muss
- Man kann die Elemente (Tags) auch gross schreiben, sollte sich aber auf ein Prinzip festlegen (am Besten alles klein)
- die erlaubten Attribute muss man selber definieren
- Der Zeichensatz muss angegeben werden, wenn man sich nicht auf ASCII beschränken will
- Um Spezialzeichen wie < > " ' und & auch verwenden zu können, müssen sie durch ihre Entities ersetzt werden: < > " &apos und & jeweils mit ; am Ende.
- Das Dokument darf nur ein Hauptelement enthalten. Die weitere Gliederstruktur ist der DTD zu entnehmen.
- Attribute können mit "" oder umschlossen werden
- Namensräume werden über eine (fiktive) URL vergeben, welche auch von einzelnen Elementen eingebunden werden können (falls man in einem Dokument mehrere Namensräume braucht). Wird hier aber nicht gezeigt.
<?xml version = "1.0" encoding = "UTF-8"?>
<doku xmlns = "http://virtuelleURI.XML">
<testelement>Hallölchen mit "!</testelement>
<!-- Kommentare sind auch möglich -->
<autor photo = "image/ich.jpeg">
<vor land = "CH">Vorname</vor>
<nach>Nachname</nach>
<bild quelle = "test.jpeg" />
<bild extern = "pngdatei" />
&text1;
</autor>
</doku>
DTD für XML erstellen
Damit das obige Dokument geparst werden kann, braucht es eine entsprechende DTD, welche dann mit dem entsprechenden Link ins XML eingebunden wird. Sie beschreibt den strukturellen Aufbau der Dokumente. Im Header einer HTML-Datei wird die entsprechende dtd meist angegeben. Im Link sollte diese dann abrufbar sein (z.B.: http://www.w3.org/TR/REC-html40/strict.dtd). Folgendes wird festgelegt:
- Welche Tags verwendet werden können
- Welche Attribute angewendet werden müssen
- Welche optionalen Attribute es gibt
Bei HTML kommt noch js und css dazu.
Elemente definieren
- !ELEMENT steht vor jedem Element, welches im XML verwendet wird
- In Klammern stehen alle Unterelemente. Will man aus einer Liste auswählen, so kann man diese mit Klammern und | auflisten -> element1, (element2 | element3) -> bedeutet: e1 muss eingegeben werden. Dann kann man entweder e2 oder e3 wählen.
- Tags, welche keine Unterelemente mehr enthalten, werden mit #PCDATA gefüllt
- Folgende Zeichen regeln, wie oft ein Element vorkommen darf, wenn es in der DTD definiert wurde: ? = 0 oder 1 Mal, * = beliebig oft, auch 0 Mal, + = beliebig oft, doch mindestens 1 Mal, kein Zeichen = genau einmal.
- Will man alle Elemente einer Gruppe gleich behandeln, kann man diese auch in Klammern setzen und das Zeichen ausserhalb verwenden (test1, test2)+
- Enthält ein Element keinen Inhalt (wie etwa br oder img), so wird es mit EMPTY festgelegt
<!ELEMENT doku (testelement+, autor)> <!ELEMENT testelement (#PCDATA)> <!ELEMENT autor (vor+, nach, bild?)>
Attribute definieren
- !ATTLIST startet einen Attributeintrag -> <!ATTLIST Element AttributName (AttributTyp)>
- Man kann für den Typ folgende Gruppen festlegen: Eine beliebige Zeichenkette, welche mit CDATA angezeigt wird (bild -> src), Eine Aufzählung, welche man direkt eingibt (bild -> align) und Schlüsselwörter, welche definiert sind (autor -> ID)
- Als Schlüsselwörter gelten:
- ID für die Kennzeichnung
- IDREF für einen Verweis auf die ID
- IDREFS für Verweise auf mehrere IDs (autor -> kennt -> die ID-Liste, welche hier mitgegeben werden kann, zeigt, welcher autor welche anderen Autoren kennt an Hand ihrer ID)
- NMTOKEN schränkt die Auswahl auf Buchstaben und "." ":" "-" "_" ein
- NMTOKENS kann mehrere Eigenschaften festlegen
- NOTATION verweist auf ein externes Dokument, welches dann von einem Programm verarbeitet werden kann (autor -> photo)
- Gibt es für ein Attribut eine Auswahlliste, wird diese in Klammern angegeben. Der Vorgabewert kommt anschliessend in Anführungszeichen dahinter (bild -> align)
- Man kann angeben, ob ein Attribut angegeben werden muss (#REQUIRED) oder ob man darf (#IMPLIED). Ohne Angabe gilt #IMPLIED.
- Zusätzlich existiert noch #FIXED. Hier muss der Wert in der DTD angegeben werden und anschliessend ist nur dieser Wert als Angabe erlaubt und wird auch übernommen, wenn man nichts mitgibt.
- Die Attribute können an beliebiger Stelle in der DTD stehen. Der Übersicht halber aber am Besten direkt hinter dem Element
- Bei mehreren Deklarationen des gleichen Attributes für ein Element wird nur das Erste ausgewertet
<!ELEMENT autor (vor+, nach, bild?)> <!ATTLIST autor kennung ID #REQUIRED -- Eindeutige Kennzeichnung kennt IDREFS #IMPLIED -- Verweis auf die IDs photo NOTATION -- Externe Quelle (z.B. image/max.jpeg) > <!ELEMENT bild EMPTY> <!ATTLIST bild src CDATA #REQUIRED -- Beliebige Zeichenkette ist erlaubt. quelle %URI; #REQUIRED -- URI prüft hier, ob Auswahl gültig -> Auswahl über Entity definiert align (left|center|right) "left" -- Aufzählungsliste, rechts die Standardvorgabe, wenn nichts ausgewählt wurde extern ENTITY -- extern ist eine Entity, welche im XML eingebunden wird >
Entity definieren
ENTITY verweist auf Dateien oder andere Objekte. Dazu müssen gewisse Sonderzeichen je nachdem als Entity eingegeben werden (< ; <- ohne Abstand). Allgemein handelt es sich um eine Ersetzung von langen Ausdrücken. Es wird zwischen Allgemeinen Entities unterschieden, welche mit & eingebunden werden und Parameter Entities, welche man mit % einsetzt. Eine Entity kann auch in einer Attributliste selbst definiert werden, doch hier wird nur das eigenständige Entity angegeben. Da die Entities auch in der DTD selber verwendet werden können, sollte man dies der Übersicht halber, gleich am Anfang definieren.
- Eigenständig: &y; -> (text1)
- Parameter: %x; -> (URI)
- Extern, nicht interpretierbar: SYSTEM, NDATA
<!ENTITY text1 "Dies ist ein langer Text, welcher ersetzt werden kann"> -- Allgemeines Entity <!ENTITY %URI "URI (file:// | http:// | ftp://) #REQUIRED"> -- Parameter Entity <!ENTITY pngdatei SYSTEM "bilder/test.png" NDATA png> -- Externe Entity
Notation definieren
Verweist auf externe Programme zur Verarbeitung von Entities.
<!NOTATION tif SYSTEM "file://tiefviewer.exe"> -- Externes Programm <!ELEMENT IMG IMPTY> <!ATTLIST IMG typ NOTATION (tif) #IMPLIED quelle CDATA #IMPLIED >
XML-Anweisung, bei welcher dann das externe Programm automatisch aufgerufen werden kann:
<IMG typ = "tif" quelle = "images/bild.tif" />
Beispiel DTD aus obigen Angaben
<!ENTITY text1 "Dies ist ein langer Text, welcher ersetzt werden kann"> -- Allgemeines Entity <!ENTITY %URI "URI (file:// | http:// | ftp://) #REQUIRED"> -- Parameter Entity <!ENTITY pngdatei SYSTEM "bilder/test.png" NDATA png> -- Externe Entity <!ELEMENT doku (testelement+, autor)> <!ELEMENT testelement (#PCDATA)> <!ELEMENT autor (vor+, nach, bild?)> <!ATTLIST autor kennung ID #REQUIRED -- Eindeutige Kennzeichnung kennt IDREFS #IMPLIED -- Verweis auf die IDs photo NOTATION -- Externe Quelle (z.B. image/max.jpeg) > <!ELEMENT vor (#PCDATA)> <!ELEMENT nach (#PCDATA)> <!ELEMENT bild EMPTY> <!ATTLIST bild src CDATA #REQUIRED -- Beliebige Zeichenkette ist erlaubt. quelle %URI; #REQUIRED -- URI prüft hier, ob Auswahl gültig -> Auswahl über Entity definiert align (left|center|right) "left" -- Aufzählungsliste, rechts die Standardvorgabe, wenn nichts ausgewählt wurde extern ENTITY -- extern ist eine Entity, welche im XML eingebunden wird >
Damit diese Datei vom XML-Dokument gefunden werden kann, wird dort der Link folgendermassen eingebunden:
<!DOCTYPE name SYSTEM "datei.dtd">
"name" muss mit dem ersten Element (Hauptelement) der Doctype übereinstimmen. Die Datei kann lokal oder mittels URI auf einem anderen Server liegen. Dazu sollte beim xml Tag die Angabe standalone = "no" angegeben werden, damit die dtd auch sicher extern gesucht wird.
Wie man sieht, gibt es hier keine Attribute für den Vornamen. Will man dieses aber trotzdem verwenden und kann die DTD nicht anpassen, so muss man im XML einen eigenen Namensraum für dieses Element definieren und auf diesen verweisen.
Hier daher ein Beispiel aus einer DTD für XHTML1.1 für das Element img (Bild).
<!--=================== Images ===========================================-->
<!-- Length defined in strict DTD for cellpadding/cellspacing -->
<!ENTITY % Length "CDATA" -- nn for pixels or nn% for percentage length -->
<!ENTITY % MultiLength "CDATA" -- pixel, percentage, or relative -->
<![ %HTML.Frameset; [
<!ENTITY % MultiLengths "CDATA" -- comma-separated list of MultiLength -->
]]>
<!ENTITY % Pixels "CDATA" -- integer representing length in pixels -->
<!-- To avoid problems with text-only UAs as well as
to make image content understandable and navigable
to users of non-visual UAs, you need to provide
a description with ALT, and avoid server-side image maps -->
<!ELEMENT IMG - O EMPTY -- Embedded image -->
<!ATTLIST IMG
%attrs; -- %coreattrs, %i18n, %events --
src %URI; #REQUIRED -- URI of image to embed --
alt %Text; #REQUIRED -- short description --
longdesc %URI; #IMPLIED -- link to long description
(complements alt) --
name CDATA #IMPLIED -- name of image for scripting --
height %Length; #IMPLIED -- override height --
width %Length; #IMPLIED -- override width --
usemap %URI; #IMPLIED -- use client-side image map --
ismap (ismap) #IMPLIED -- use server-side image map --
>
<!-- USEMAP points to a MAP element which may be in this document
or an external document, although the latter is not widely supported -->
Eigenen Namensraum definieren, wenn DTD nicht anpassbar
Es soll das oben selbst definierte Beispiel verwendet und angepasst werden, damit ein XML-Dokument mit zusätzlichen Angaben trotzdem gültig ist, auch wenn die DTD dies im Original nicht vorsieht. Dies ermöglicht die Erweiterung der Dokumente, ohne Anpassung der DTD, auf die man nicht in jedem Fall Zugriff hat.
<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<!DOCTYPE doku PUBLIC "//Meine DTD" "test.dtd" [
<!ATTLIST autor xmlns:extra CDATA #FIXED "http://www.virtuelleURI.XML">
<!ATTLIST vor extra:land (CH|DE|FR) #IMPLIED>
]> <!-- in test.dtd muss obige dtd auffindbar sein. -->
<doku xmlns = "http://virtuelleURI.XML">
<testelement>Hallölchen mit "!</testelement>
<autor xmls:extra = "http://www.virtuelleURI.XML">
<vor extra:land = "CH">Vorname</vor>
<nach>Nachname</nach>
<bild quelle = "test.jpeg" />
</autor>
</doku>
Wie man sieht, wird hier im Dokument definiert, dass das Attribut lang möglich, doch nicht notwendig ist und auch, welche Werte es enthalten darf.
XML Schema (Erweiterung von DTD)
Die DTD ist in gewissen Bereichen eingeschränkt, wie etwa beim festlegen von Wertebereichen und vordefinierten Datentypen. Daher wurde als Erweiterung XML Schema vom W3C entwickelt: http://www.w3.org/XML/Schema Folgende zusätzliche Angaben sind nun zusätzlich zur DTD machbar:
- Reihenfolge der Elemente
- Anzahl möglicher Elemente
- Datantyp der Elemente
- Datentyp der Attribute
- eigene Datentypen
Die Verwendung der DTD ist aber weiterhin möglich, da es sehr einfach ist, wenn man einmal die DTD erstellt hat und genaue Werte nicht kritisch sind. Das XML Schema wird vor allem dann verwendet, wenn die Datentypen und der Wertebereich nicht extern überprüft werden kann und daher kritisch ist.
Unterschied DTD und XML Schema
folgendes XML sei gegeben:
<?xml version = "1.0" encoding = "UTF-8"?>
<adresse xmlns = "http://virtuelleURI.XML">
<name>Max Müller</name>
<strasse>Srassenweg 11</strasse>
<ort>Stadt</ort>
<plz>1234</plz>
</adresse>
Die entsprechende DTD:
<!ELEMENT adresse (name, strasse, ort, plz)> <!ELEMENT name (#PCDATA)> <!ELEMENT strasse (#PCDATA)> <!ELEMENT ort (#PCDATA)> <!ELEMENT plz (#PCDATA)>
Und nun das XML Schema. Die Datei wird als xsd gespeichert (adresse.xsd) und ist auch eine XML Datei:
<?xml version = "1.0" encoding = "UTF-8"?>
<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema"
targetNamespace = "http://www.ZielNamespace.url"
xmlns = "http://www.ZielNamespace.url"
elementFormDefault = "qualified">
<xs:element name = "adresse">
<xs:complexType>
<xs:sequence>
<xs:element name = "name" type = "xs:string" />
<xs:element name = "strasse" type = "xs:string" />
<xs:element name = "ort" type = "xs:string" />
<xs:element name = "plz" type = "xs:string" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Zuerst kommt der Header, danach das Element Adresse, welches complex ist, da es weitere Elemente enthält. Die Unterelemente werden als reine Textelemente erfasst.
Attribute des Elementes Schema
Das Element schema hat folgende Attribute:
- xmlns:xs -> Die Elemente entstammen dem nachfolgenden Namensraum der angegebenen Adresse (XMLSchema).
Zusätzlich wird festgelegt, dass die Elemente mit dem Präfix xs beginnen müssen (dieses kann frei gewählt werden) - xmlns -> legt den standardmässigen Namespace fest (Phantasie-URL)
- targetNamespace gibt an, in welchem Namespace sich die Elemente befinden müssen, damit die Definition auf sie angewendet wird
- elementFormDefault mit qualified erzwingt das Präfix vor jedem Element. Standardmässig ist es ausgeschaltet
- attributeFormDefault macht das Gleiche mit den Attributen
XML mit Schema verknüpfen
Damit das korrekte Schema verwendet wird, muss folgende Angabe in der xml-Datei gemacht werden:
xmlns = "URI" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation = "Namensraum Schema-Datei"
Der Parser kann nun die Schema Datei am Ort des Namensraumes suchen, ist aber nicht an die Datei dort gebunden. sonst:
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation = "Schema-Datei"
Hier sucht nun der Parser die entsprechende Datei (relativ oder direkt angegeben).
Schema Parser (Validieren)
Es gibt freie Parser im Internet (http://www.corefiling.com/opensource/schemaValidate.html), welche an Hand des Schemas und einer XML-Datei prüfen können, ob ein Fehler vorliegt. über die MSXML kann man auch lokal über eine Schnittstelle mit dem IE und Active-X die Dateien prüfen lassen. Daher hier ein Beispiel für den IE mit Javascript:
<script language = "JavaScript">
function validate() {
var xmlSchema = new ActiveXObject("MSXML2.XMLSchemaCache.4.0");
xmlSchema.add("", document.schemaTest.schemaURI.value);
var xmlDoc = new ActiveXObject("MSXML2.DOMDocument.4.0");
xmlDoc.schemas = XMLSchema;
xmlDoc.async = false;
xmlDoc.load(document.schemaTest.documentURI.value);
if (xmlDoc.parseError.errorCode != 0) {
alert("FEHLERCODE: \\n" + xmlDoc.parseError.errorCode + "\\n\\nGrund: \\n" + xmlCode.parseError.reason);
} // end if
else {
alert("Kein Fehler gefunden.");
} // end else
} // end function validate()
</script>
Die Datei muss noch um das Formular erweitert werden, mit dem man die zwei Dateien hochladen und dann der Routine übergeben kann. Leider findet sich die Seite nicht in den Dokumenten zum Buch. Falls erweitert, abspeichern und mit dem IE ausführen.
XML Schema Attribute
Um die ganze Vielfalt der Attribute zu zeigen, wird die XML-Datei erweitert und das entsprechende Schema auch.
<?xml version = "1.0" encoding = "UTF-8"?>
<Bestellung bestelldatum = "2003-05-26">
<Adresse>
<Name>Max Müller</Name>
<Strasse>Srassenweg 11</Strasse>
<Ort>Stadt</Ort>
<PLZ>1234</PLZ>
</Adresse>
<Ware>
<Buch BestellNr = "0123456789">
<Titel>Die Bibel</Titel>
<Autor>Gott></Autor>
<Anzahl>12</Anzahl>
<Preis Währung = "CHF">9.90<Preis>
</Buch>
</Ware>
</Bestellung>
<?xml version = "1.0" encoding = "UTF-8"?>
<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema">
<xs:element name = "Bestellung">
<xs:complexType>
<xs:sequence>
<xs:element name = "Adresse" type = "BestellAdresse" />
<xs:element name = Ware type = "WarenTyp" />
</xs:sequence>
<xs:attribute name = "bestelldatum" type = "xs:date" />
</xs:complexType>
<xs:element>
<xs:complexType name = "BestellAdresse">
<xs:sequence>
<xs:element name = "Name" type = "xs:string" />
<xs:element name = "Strasse" type = "xs:string" />
<xs:element name = "Ort" type = "xs:string" />
<xs:element name = "PLZ" type = "PLZTyp" />
<xs:simpleTyp name = "PLZTyp">
<xs:restriction base = "xs:positiveInteger">
<xs:minLength = "4" /> <!-- z.B. Schweiz -->
<xs:maxLength = "5" /> <!-- z.B. Deutschland -->
</xs:restriction>
</xs:simpleTyp>
</xs:sequence>
</xs:complexType>
<xs:complexType name = "WarenTyp">
<xs:sequence>
<xs:element name = "Buch" minOccurs = "0" maxOccurs = "unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name = "Titel" type = "xs:string" />
<xs:element name = "Autor" type = "xs:string" />
<xs:element name = "Anzahl">
<xs:simpleType>
<xs:restriction base = "xs:positiveInteger">
<xs:maxExclusive value = "100" />
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name = "Preis">
<xs:complexType>
<xs:attribute name = "Währung" type = "WährungsTyp" use = "required" default = "CHF"/>
</xs:complexType>
</xs:element>
<xs:simpleTyp>
<xs:restriction base = "xs:positiveInteger">
<xs:fractionDigits = "2" /> <!-- Nachkommastellen -->
<xs:totalDigits = "8" /> <!-- Gesamtstellen -->
</xs:restriction>
</xs:simpleTyp>
</xs:sequence>
<xs:attribute name = "bestellNr" type = "BestellNrTyp" use = "required" /> <!-- optional and prohibited are also possible -->
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:simpleType name = "WährungsTyp">
<xs:restriction base = "xs:string">
<xs:enumeration value = "CHF" />
<xs:enumeration value = "EUR" />
<xs:enumeration value = "USD" />
</xs:restriction>
</xs:simpleTyp>
<xs:simpleType name = "BestellNrTyp">
<xs:restriction base = "xs:string">
<xs:pattern value = "\\d{10}" />
</xs:restriction>
</xs:simpleTyp>
</xs:schema>
- Ein einfaches Element kann keine Attribute oder Unterelemente besitzen
- Mittels type wird festgelegt, welche Werte das Element enthalten kann (z.B.: string, decimal, integer, boolean, date (englischsprachig), time (12:34:56))
- default legt den Standardwert fest, wenn keiner vorgegeben wird
- Bei der Angabe von fixed ist nur dieser Wert erlaubt
- Mit restriction kann man einen Wertebereich eingrenzen. Mit base legt man den Wert fest. Daher wird dieser beim Element selber weggelassen. Die Wertebereiche legt man mit minInclusive/maxInclusive oder minExplusive/maxExclusive fest. Der Unterschied liegt darin, dass die Grenzwerte bei Inclusive mitgelten und sonst nicht mehr erlaubt sind.
- Mit einer enumeration kann man die erlaubten Werte der restriction festlegen. Andere Werte sind dann automatisch ungültig
- Mit einem Muster (pattern) wird ein regulärer Ausdruck zur Analyse verwendet
- Nichtdruckbare Zeichen (Tabulatoren, Zeilenumbrühe, Leerzeichen) werden in der restriction mit dem Schlüsselwort whitespace behandelt (preserve macht nichts, replace ersetzt mit Leerzeichen und collapse ersetzt zusätzlich mehrere Zeichen mit einem und entfernt Leerräume am Anfang und Ende)
- Mit length legt man die Zeichenlänge fest. Will man variabel sein, so benutzt man minLength und maxLength
- Die Nachkommastellen legt man mit fractionDigits und die Gesamtanzahl mit totalDigits fest
XML Schema Indikatoren (Verwendung der Elemente festlegen)
- Reihenfolge -> all, choice, sequence
- Vorkommen -> maxOccurs, minOccurs
- Gruppen -> group, attributeGroup
Reihenfolge
Verwendet man sequence, so muss die Reihenfolge unbedingt eingehalten werden. Bei all muss jedes Element genau einmal auftreten, doch die Reihenfolge ist egal. Bei choice muss man eines der angegebenen Elemente nehmen, doch man darf nicht mehrere wählen.
Vorkommen
Die Werte werden direkt beim Element vergeben. Benutzt man sie nicht, wird 1 angenommen. Will man die Obergrenze nicht festlegen, so wird als Schlüsselwort unbounded verwendet.
<xs:element name = "Test" maxOccurs = "unbounded" />
Gruppen
Dient dazu. Elemente zu bündeln, um diese dann an einer Stelle einzusetzen. Etwa Adresse, welche für eine Lieferadresse oder eine Rechnungsadresse verwendet werden kann. Damit können Verdoppelungen vermieden werden. Elementgruppen können keine komplexen Typen enthalten.
<xs:group name = "AdressGruppe">
<xs:sequence>
<xs:element name = "Strasse" type = "xs:string" />
<xs:element name = "Hausnummer" type = "xs:string" />
<xs:element name = "Ort" type = "xs:string" />
<xs:element name = "PLZ" type = "xs:string" />
</xs:sequence>
</xs:group>
Diese Definition kann man nun mehrfach verwenden:
<xs:element name = "Lieferadresse">
<xs:complexType>
<xs:group ref = "AdressGruppe" />
</xs:complexType>
</xs:element>
Das Gleiche ist auch mit Attributen möglich. Diese werden dann mit attributeGroup definiert und genau gleich referenziert.
XML Schema beliebig erweitern
Mit dem any Element kann man beliebige Erweiterungen an dessen Stelle einfügen. Dies bedingt aber, dass man weiss, dass dort noch weitere Elemente eingefügt werden sollen. Es kann auch als Platzhalter für beliebige Attribute (anyAttribute) eingesetzt werden. Es wird folgendermassen verwendet:
<xs:any minOccurs = "0" />
Da es allerdings weitere xml braucht, welche schliesslich den Platzhalter füllen, ist es doch recht aufwendig und meist sollte man in der Praxis direkt das verwendete dtd anpassen können, so dass diese Sonderform hier nicht weiter behandelt wird.
XSL - Elemente formatiert darstellen
XSL besteht aus Elementen von DSSSL (Formatierungsspreche), HTML und CSS. Mit Hilfe von XSL können Daten in HTML oder ein anderes Textformat transformiert werden. Man kann XML-Daten filtern und sortieren und abhängig vom Wert formatieren.
XML mit CSS formatieren
Hier werden die Elemente einfach über eine css-Datei formatiert. Dazu muss man alle Elemente entsprechend kennzeichnen:
adresse {
disply: block;
font-family: Arial, helvetica, sans-serif;
font-size: 10pt;
color: #00;
}
name {
font-size: 14pt;
font-weight: bold;
}
strasse, ort {
font-size: 12pt;
}
plz {
color: #dd;
}
Auf den Stylesheet wird in der XML-Datei folgendermassen verwiesen:
<?xml-stylesheet href = "datei" type = "text/css"?>
XPath
Bei XPath wird über die Baumstruktur des XML auf einzelne Elemente zugegriffen. Es braucht folgende Angaben, um ein Element korrekt zu verarbeiten:
- Eine Achse zum navigieren im XML-Baum
- Eine Knotenprüfung (node test), um über diese Kriterien bestimmte Elemente zu selektieren
- Prädikate, um die Auswahl zu filtern
Die Achse und die Knotenprüfung sind notwendig, während das Prädikat optional ist.
achse::knotenprüfung[prädikat]
Es wird folgendes XML als Beispiel verwendet:
<musiksammlung>
<album>
<interpret>Moby</interpret>
<titel stil = "Pop">Play</titel>
<lied>Anfang</lied>
<lied>Mitte</lied>
<lied>Ende</lied>
</album>
</musiksammlung>
Achsen
Die Achse wird relativ vom aktuellen Knoten aus bestimmt oder absolut von der Wurzel her.
|---- vorherige Elemente (Geschwister) ---- Kind
|
Wurzel - Grosseltern - Eltern - Element ----------------------------- Kind - Enkel
| |
| |---- nachfolgende Elemente (Geschwister) - Kind - Enkel
|
|------ Eltern - anderes Element --------------------- Kind
| Achse | Abkürzung | Erklärung |
|---|---|---|
| self | Das aktuelle Element. | |
| ancestor | Vorfahre -> Kann das Elternelement sein, doch man kann bis zur Wurzel hoch navigieren | |
| ancestor-or-self | Vorfahre oder das aktuelle Element -> Achse enthält immer noch das eigene Element | |
| attribute | Attribute des Knotens bestimmen | |
| child | Kindelement ansprechen | |
| descendent | Nachfahre -> Kind oder auch weitere Unterelemente | |
| descendent-or-self | Nachfahre oder das aktuelle Element -> Achse enthält immer noch das eigene Element | |
| following | Nachfolgende Knoten (gleiche Ebene) mit deren Kindern (Geschwister) -> Attribute und Namensräume werden ignoriert. | |
| following-sibling | Nachfolgende Knoten der gleichen Ebene (Geschwister) -> Ist der Knoten ein Attribut- oder Namensraumknoten, ist die folgende Geschwisteranzahl 0. | |
| namespace | Namensraum des Knotens ansprechen | |
| parent | Elternelement ansprechen | |
| preceding | Vorherige Knoten (gleiche Ebene) mit deren Kindern (Geschwister) -> Attribute und Namensräume werden ignoriert. | |
| preceding-sibling | Vorherige Knoten der gleichen Ebene (Geschwister) -> Ist der Knoten ein Attribut- oder Namensraumknoten, ist die folgende Geschwisteranzahl 0. | |
| Beliebige Knoten auswählen. | ||
| Wurzelelement auswählen. |
Auswertung an Hand der Achsen
Alle Lieder -> Kinder von album
<xsl:for-each select = "//child::album/child::lied"> <!-- die Angabe child:: kann weggelassen werden, da die Kindachse des selektierten Knotens immer angesprochen wird --> <xsl:value-of select = "." /> </xsl:for-each>
Albumtitel, welche Attribut stil gesetzt haben
<xsl:for-each select = "//titel/attribute::stil"> <xsl:value-of select = "./parent::titel" /> </xsl:for-each>
Albumtitel, welche Attribut stil auf 'Pop' gesetzt haben
<xsl:for-each select = "//album/titel[@stil = 'Pop']"> <!-- attribute wird mit @ abgekürzt --> <xsl:value-of select = "./parent::titel" /> </xsl:for-each>
Alle Interperterangaben des Album ausgehend vom titel-Element, welches ein Nachfahre vom album ist.
<xsl:for-each select = "//titel/ancestor::*"> <xsl:value-of select = "./interpret" /> </xsl:for-each>
Knotentypen
Bei der Auswahl kann man auch die Art der Knotentypen eingrenzen:
| Knotentyp | Erklärung |
|---|---|
| node() | Alle Knoten, welche über die gewählte Achse erreichbar sind (auch Namensräume und Attribute) |
| comment() | Kommentarknoten |
| text() | Alle Knoten entlang der Achse, welche einen Inhalt (Text) haben |
| processing-instruction() | Alle Verarbeitungsanweisungen im xml-Dokument (?xml-stylesheet... ?> |
| processing-instruction("xyz") | Nur Anweisungen im Format (xyz... ?> |
| last() | Position des letzten Knotens der Ebene und damit die Gesamtzahl der Knoten dieser Ebene |
| position() | Aktuelle Position des Knotens in der selektierten Ebene |
Alle Textknoten wählen, welche direkte Nachfahren sind.
<xsl:for-each select = "//album/child::*/text()"> <xsl:value-of select = "./interpret" /> </xsl:for-each>
Prädikate
Einschränkung der Auswahl mit Hilfe von Vergleichen oder logischen Ausdrücken:
- Textvergleiche
- Logik (or, and, !, <, >, <=, =>, =, !=)
- Arithmetik (+, -, *, div, mod)
Um die < oder > verarbeiten zu können, muss man die entsprechenden Entities > ; verwenden.
Alle Elemente 'album' selektieren und 'interpret' ausgeben. Das letzte Element wird ignoriert.
<xsl:for-each select = "//album[position() != last()]"> <xsl:value-of select = ".interpret" /> </xsl:for-each>
Das dritte Lied wählen und seinen Inhalt ausgeben.
<xsl:for-each select = "//lied[position() = 3]"> <xsl:value-of select = "." /> </xsl:for-each>
XSL-Transformation (XSLT)
In einem ersten Schritt wird mittels Vorlagen das XML in FO, XHTML, HTML oder WML transformiert. Die Vorlagen bestehen aus Selektoren, welche die Daten auswählen. Die Formatierungen werden im ersten Schritt noch nicht berücksichtigt. Mit Hilfe eines XSLT-Prozessers können dann aber auch Sachen wie Tabellen, Seiten, Absätze, Farben usw. generiert werden. Dies geschieht mit Hilfe einer zusätzlichen Software wie etwa FOP (Format Object Processor). Es wurde für pdf entwickelt, doch kann es auch SVG, PostScript oder normalen Text erzeugen.
Das Einbinden der XSL-Vorlage geschieht wie bei css über eine Präprozessor Anweisung nach der Startzeile im XML-Dokument.
<xsl:stylesheet xmlns:xsl = "http://www.w3.org/1999/XSL/Transform" version = "1.0">
Das xsl für den Namensraum ist nicht zwingend, doch damit erkennt man gleich, worum es sich handelt. Tags, welche nicht diesem Namensraum entsprechen (etwa html), werden ignoriert.
Ein xsl-Stylesheet wird wie das css-Stylesheet eingebunden.
<?xml-stylesheet href = "datei" type = "text/xsl"?>
Templates anlegen
Die Templates legen fest, welche Elemente für die weitere Verarbeitung genutzt werden sollen.
<xsl:template match = "Pattern" name = "foo"> <!-- Verarbeitung --> <xsl:template>
Zuerst wird im xml das Pattern gesucht. Wird es gefunden, so wird damit das gemacht, was in der Verarbeitung beschrieben steht. Das Argument name ist optional
Auf andere Templates zugreifen
Da die XML-Elemente verschachtelt sind, muss man von einem Element (Pattern) auf das nächste zugreifen können.
<xsl:apply-templates select = "Pattern" />
Die Verzweigung findet statt, wenn das Element existiert. Sonst wird die Anweisung ignoriert. Wählt man diese Anweisung ohne select, so wird zum Kindelement gesprungen, wenn ein solches existiert.
Beispiel einer Templateverwendung
Zuerst ein Test-xml.
<?xml version = "1.0" encoding = "UTF-8" standalone = "yes"?> <?xml-stylesheet href = "test.xsl" type = "text/xsl"?> <haupt> <unter1>Unterelement 1</unter1> <unter2>Unterelement 2</unter2> </haupt>
Eine xsl-Datei dazu könnte folgendermassen aussehen.
<?xml version = "1.0" encoding = "UTF-8"?>
<xsl:stylesheet version = "1.0" xmlns:xs = "http://www.w3.org/1999/XSL/Transform">
<xsl:template match = "/">
<html>
<head><title>Beispiel</title></head>
<body>
<h3>xml-Elemente ansprechen</h3>
<xsl:apply-templates /><!-- springt zum nächsten Unterelement, da ohne Namen -->
</body>
</html>
</xsl:template>
<xsl:template match = "haupt">
<p>Hauptelement</p>
<xsl:apply-templates select = "unter2"/><!-- springt zum Element unter2 -->
</xsl:template>
<xsl:template match = "unter1">
<p>Unterelement 1</p>
</xsl:template>
<xsl:template match = "unter2">
<p>Unterelement 2</p>
</xsl:template>
</xsl:stylesheet>
Durch den Sprung zu "unter2" wird Element unter1 ausgelassen und nicht ausgegeben. Will man nicht einfach auf eine nächste Vorlage "springen", kann man mit call-template auch zu einem beliebigen Ort springen.
<xsl:call-template name = "gewünschtes Element"></xsl:call-template>
Auswahl mit Filtern
Mittels XPath wird das Filterkriterium definiert. Damit kann nicht einfach nur ein Name ausgewählt werden, sondern der Filter bestimmt, ob das gefundene Kriterium (Element) auch genommen wird, weil es der Anfrage entspricht (Nur bestimmte Bereiche usw.).
<xsl:template match = "">
| Filter | sucht |
|---|---|
| album | Alle Elemente album |
| album/interpret | Alle Elemente interpret, wenn diese direkte Unterelemente von album sind |
| album//titelzeit | Alle Elemente titelzeit, wenn diese Nachfahren von album sind (hier müssen es nicht direkt Kinder sein) |
| album/lied[1] | Das erste Elemente lied, das direktes Unterelement von album ist |
| //lied | Alle Elemente lied, egal wo im dokument |
| .//lied | Alle Elemente lied unterhalb vom Suchstandort aus gesehen |
| album/*/titelzeit | Alle Elemente titelzeit, welche irgendwo einen Vorfahren Album haben |
| album/titel/@stil | Alle Elemente titel, welche ein Attribut stil besitzen und direkte Nachfahren (Kinder) von Album sind |
| album/titel/[@stil='Pop'] | Wie vorher, doch hier muss der stil Pop sein |
| album/interpret|sänger|gruppe | Alle Elemente interpret, sänger oder gruppe, welche Kinder von album sind |
Ausgabe
Während xsl:template dem Knoten auswählt, wird er schlussendlich mit xsl:value-of select = "Muster" ausgegeben.
<xsl:template> <!-- Ohne Namenswahl wird das Hauptelement aktiviert --> <xsl:value-of select = "//lied" /> <!-- Alle Elemente 'lied' werden ausgegeben --> </xsl:template>
XSLT - Elemente
Möchte man mehrere Elemente mit gleichem Namen verarbeiten, so wählt man diese mit einer Schleife aus. Zum sortieren der Ausgabe kann auf sort zurückgegriffen werden.
for-each
<xsl:template match = "/">
<xsl:for-each select = "//album"> <!-- Jedes Album verarbeiten -->
<xsl:value-of select = "./interpret" /> <!-- Interpret ausgeben -->
<xsl:value-of select = "./titel" />
<xsl:for-each select = "//lied"> <!-- Jedes Lied verarbeiten -->
<xsl:value-of select = "." /> <!-- Lied ausgeben -->
</xsl:for-each> <!-- end Jedes Lied verarbeiten -->
</xsl:for-each> <!-- end Jedes Album verarbeiten -->
</xsl:template>
sort
<xsl:sort select = "Element" [order = "" data-type = "" case-order = ""]>
Das angewählte Element wird sortiert. Bei Order gibt man ascending oder descending an. Asc ist Standard. Mit dem Datentyp legt man die Sortierreihenfolge fest für text (Standard) oder number (Zahl). Bei Texten kann mir lower-first (Standard) oder upper-first festgelegt werden, ob zuerst Gross- oder Kleinbuchstaben kommen.
<xsl:template match = "/">
<xsl:for-each select = "//album">
<xsl:sort select = "./interpret" order = "descending" /> <!-- Interpreten absteigend sortieren -->
<xsl:value-of select = "./interpret" />
<xsl:value-of select = "./titel" />
<xsl:for-each select = "//lied">
<xsl:sort select = "." case-order = "upper-first" /> <!-- zuerst Grossbuchstaben ausgeben (alphabetisch ist implizit). -->
<xsl:value-of select = "." />
</xsl:for-each>
</xsl:for-each>
</xsl:template>
Wie man sieht, kann man für die Sortierung auch Unterelemente verwenden.
if
Prüfen, ob das angewählte Element einer Bedingung entspricht.
<xsl:template match = "/">
<xsl:for-each select = "//album">
<xsl:if test = "interpret = 'Abba'"> <!-- Nur wenn interpret = Abba ausführen -->
<xsl:value-of select = "./interpret" />
<xsl:value-of select = "./titel" />
<xsl:if test = "titel/@stil = 'Pop' or titel/@stil = 'p'"> <!-- Nur wenn titelattribut Pop oder p ausführen -->
<xsl:value-of select = "." />
</xsl:if>
</xsl:if>
</xsl:for-each>
</xsl:template>
choose-when-otherwise
Möchte man nicht nur bei einer erfüllten Bedingung etwas ausführen, so wird eine angepasste if then else verwendet.
<xsl:choose>
<xsl:when test = "Mustervergleich">
<!-- Ausführen, wenn Bedingung erfüllt -->
</xsl:when>
<xsl:when test = "Mustervergleich2">
<!-- Ausführen, wenn Bedingung2 erfüllt -->
</xsl:when>
<xsl:otherwise>
<!-- Ausführen, wenn keine Bedingung erfüllt -->
</xsl:otherwise>
</xsl:choose>
Achtung, nach ausführen einer Bedingung wird die Anweisung verlassen. Es lassen sich also nicht mehrere Anweisungen abarbeiten. Bei Zahlen kann man auch mit grösser und kleiner Vergleichen arbeiten.
DOM und SAX
Da HTML auch eine Auszeichnungssprache ist, kann man natürlich auch dort das DOM verwenden. Im verlinkten Artikel wird direkt mit den Möglichkeiten der HTML5-Browser gearbeitet.
DOM
Das DOM bildet die XML-Datei im Arbeitsspeicher ab. Über eine API kann dann mit einer beliebigen Programmiersprache darauf zugegriffen werden. Da das gesamte Dokument im Arbeitsspeicher gehalten wird, kann der Zugriff mit SAX besser sein. Der Zugriff erlaubt die beliebige Manipulation des Dokuments lokal ohne Serverzugriff. Das Problem zwischen den Browsern besteht im unterschiedlichen Zugriff auf die Elemente.
Zugriff über ActiveX mit IE
Zuerst das Objekt erstellen und danach den Inhalt der Datei einfügen.
<script language = "JavaScript">
var ObjektName = new ActiveXObject("microsoft.xmldom");
ObjektName.load("XML-Datei");
</script>
Knotenauswahl
Hat man folgende Angabe <p align = "center">Dies ist<i>fett</i>.</p>, so besitzt <p> 4 Knoten:
- align = "center" -> Attributknoten
- Dies ist -> Inhaltsknoten 1
- <i>fett</i> -> Kindknoten i
- . -> Inhaltsknoten 2
Der Zugriff geschieht wie bei XML über Schlüsselworte, wobei es hier keine Abkürzungen gibt.
| Element | Erklärung |
|---|---|
| documentElement | Wurzel |
| parentNode | Elternelement des selektierten Elements |
| childNodes | Alle Unterknoten des selektierten Elements |
| firstChild | Erstes Kindelement |
| lastChild | Letztes Kindelement |
| nodeName | Name des selektierten Elements |
| item() | Ein bestimmtes untergeordnetes Element wählen (Zählung beginnt bei 0) |
| attributes() | Attributwerte wählen (Zählung beginnt bei 0) |
| text | Inhalt des gewählten Elements/Attributs ausgeben |
Ein Element auswählen:
documentElement.childNodes.item(3).text; // Inhalt des 4.Elements ausgeben -> Hier der Punkt "."
Ein Attribut ausgeben:
documentElement.childNodes.item(0).attribut(0).text; // 1. Attribut des 1.Elements ausgeben -> Hier "center"
Knoten verarbeiten
Mit dem Attribut length stellt man fest, wie viele Elemente ein Knoten besitzt. Anschliessend können diese mit einer Schlaufe durchlaufen werden.
element = XMLObjekt.documentElement.childNodes; // Elemente zählen und speichern
for (i = 0; i < element.length; i++) { // Durch alle Elemente durchgehen
document.write('element.item(i).nodeName + ' ' + 'element.item(i).text'); // Name des Elementes und dessen Inhalt ausgeben
} // end for
Knoten direkt ansprechen
Möchte man Elemente ansprechen und weiss deren Namen, so geht dies mit:
document.getElementsByTagName('Name'); // Inhalt des Elementes mit Namen 'Name' holen
Da es natürlich mehrere Elemente mit dem Namen geben kann, werden diese in einem Array gespeichert und können über den Index angesprochen werden. Weiss man, dass ein Element einmalig ist, genügt der Zugriff aufs Element 0, für Prüfungen sollte aber die Länge getestet werden.
ausgabe = document.getElementsByTagName('Test');
document.write('ausgabe.item(0).text');
Will man alle Elemente behandeln, braucht es halt wieder eine Schleife über die Arraylänge, wie im oberen Kapitel beschrieben.
SAX
SAX heisst Simple API for XML. Hier wird nicht alles in den Speicher geschaufelt, sondern es gibt einen Ereignis gesteuerten Mechanismus zum Lesen der Elemente. Zuerst wird das XML geparst. Je nach Element werden die entsprechenden Ereignisse generiert:
- Anfang eines Elements (Start-Tag)
- Inhalt eines Elements
- Ende eines Elements (Ende-Tag)
- Kommentar
- Entity-Definition
- Fehler / Warnungen
Da der Parser die Ereignisse nur einmal durchläuft, muss man die Struktur intern abspeichern, womit man wieder beim DOM landet, oder das Dokument nochmals parsen. Aus diesem Grund wird es meist zum einmaligen Einlesen eines XML verwendet.
XLink
Dieses Kapitel behandelt Links in XML-Dokumenten. Interne Verweise werden mit XPath realisiert, während externe Verweise (Ressourcen) mittels XLink adressiert werden.
Verwendung
Zuerst muss ein Namensraum festgelegt werden. Dieser ist entweder direkt mit dem Element verbunden:
<element xmlns:xlink = "http://www.w3.org/1999/xlink" xlink:type = "simple" xlink:href = "datei.xml" > Inhalt des Elements </element>
oder es gibt einen Bereich, in dem der Link gültig ist:
<xlink:simple xmlns:xlink = "http://www.w3.org/1999/xlink" xlink:href = "datei.xml"> </element>Inhalt des Elements</element> </xlink:simple>
Das bedeutet, dass jedes Element zu einem XLink werden kann. Es muss einfach die entsprechenden globalen Attribute verwenden:
<?xml version = "1.0" encoding = "ISO-8859-1" standalone = "yes" ?>
<xlink:simple xmlns:xlink = "http://www.w3.org/1999/xlink">
<a xlink:type = "simple"
xlink:actuate = "onRequest"
xlink:show = "replace"
xlink:href = "datei.xml"
>
Das ist ein Link
</a>
</xlink:simple>
Dieser Link wird erst auf Anfrage (Klick) ausgeführt und ersetzt die aktuelle Seite.
Will man ein Bild einbinden, so geht dies folgendermassen:
<?xml version = "1.0" encoding = "ISO-8859-1" standalone = "yes" ?>
<xlink:simple xmlns:xlink = "http://www.w3.org/1999/xlink">
<img xlink:type = "simple"
xlink:actuate = "onLoad"
xlink:show = "embed"
xlink:href = "bild.jpeg"
>
Ein integriertes Bild.
</img>
</xlink:simple>
Attribute
Folgende Attribute stehen für die Links zur Verfügung:
| Attribut | Bedeutung |
|---|---|
| type | Bezeichnet XML-Elemente, welche als Link behandelt werden sollen. Dieses Attribut kann die Werte simple, extended, locator, arc, resource oder title annehmen. |
| href | Adresse oder Ressource. Es muss sich um eine absoulte oder relative URL handeln. Besitzt das Attribut type den Wert simple oder locator, so muss href auch angegeben werden. |
| role | Bezeichnet die Quelle von der aus man verlinkt. |
| arcrole | Bemerkung zum XLink-Element. |
| title | Bezeichnet die Funktion des Elements. |
| show | Legt fest, wie der Link angezeigt werden soll. embed zeigt die externe Ressource direkt dar. new verwendet für die Anzeige ein neues Fenster und replace ersetzt das aktuelle Dokument mit der verlinkten Ressource. |
| actuate | Legt fest, wann der Link aktiviert werden soll. Möglich ist: onLoad, onRequest, other und none. |
| label, from, to | Eindeutige Bezeichnung des Elementes, auf das man sich mit from und to direkt beziehen kann. |
Erweiterte Links
Werden mit extended aufgebaut. Zuerst werden die möglichen Ziele mit Labeln erstellt. Anschliessend fügt man hinzu, welche lokalen Ressourcen an den Links beteiligt sind und anschliessend werden die Label miteinander verknüpft. Der href wird mit der entsprechenden URL ersetzt, die man dann braucht.
<?xml version = "1.0" encoding = "ISO-8859-1" standalone = "yes" ?> <xlink:extended xmlns:xlink = "http://www.w3.org/1999/xlink"> <wo xlink:type = "locator" xlink:href = "..." xlink:label = "link1" /> <wo xlink:type = "locator" xlink:href = "..." xlink:label = "link2" /> <wo xlink:type = "locator" xlink:href = "..." xlink:label = "link3" /> <was xlink:type = "resource" xlink:label = "Attributswert">lokale Ressource</was> <was xlink:type = "resource" xlink:label = "Bild">bild.jpeg</was> <wie xlink:type = "arc" xlink:from = "link1" xlink:to = "link2" /> <wie xlink:type = "arc" xlink:from = "link3" xlink:to = "link1" /> <wie xlink:type = "arc" xlink:from = "link2" xlink:to = "link3" /> </xlink:extended>
Diese Elemente können auch mit dem title-Element beschriftet werden, damit der Benutzer sieht, was mit dem Element genau gemacht werden kann. Das Element kann auch mehrfach verwendet werden, falls man mehrere Sprachen unterstützen muss.