Si vous avez déjà visité cette page, actualisez la (F5) pour avoir les dernières mises à jour.

Utiliser PHP pour transformer du XML à l'aide de XSL

Table des matières

XML et XSL

XML et XSL sont les deux mamelles de la description en matière de documentation électronique. En première approche, XML s'occupe du fond (contenu d'un document) et XSL de la forme (présentation du document). Ce principe recommandé de séparation fond/forme est similaire à la répartition des rôles entre une page HTML et une feuille de style CSS. D'ailleurs, les documents XSL sont couramment appelés "feuilles de style" bien qu'il s'agisse, en fait, de véritables programmes - on y reviendra. De fait, XML et XSL sont des outils très puissants qui sont devenus des standards du web (XHTML est un sous-ensemble de XML) et, au-delà du web, du monde de la documentation électronique.

XML : présentation générale succincte

XML est un acronyme d'origine anglo-saxonne signifiant eXtensible Markup Language, soit "langage de balisage extensible". D'après sa spécification officielle [1], il est un sous-ensemble de SGML (Standard Generalized Markup Language, un langage normalisé ISO en 1986) et compatible avec HTML. Il a fait l'objet d'une recommandation W3C en 1998 [2]. Il a été conçu pour une plus grande facilité d'utilisation sur le web que le SGML et avec l'objectif de pallier les inconvénients du HTML (vocabulaire figé, syntaxe manquant de rigueur). Un sous-produit de cet effort est le XHTML, qui est du HTML rendu correct en en faisant un sous-ensemble du XML (notamment en fermant toutes les balises pour obtenir un document dit "bien formé").

Comme son nom l'indique ("markup"), XML utilise des balises pour représenter la structure du document. Par exemple, le fait qu'un segment de texte soit un chapitre d'un livre peut être indiqué en le plaçant entre deux balises de début et de fin : <chapitre>segment de texte</chapitre>. Il est extensible parce que le nom des balises utilisables n'est pas restreint à l'avance. En revanche la façon de les utiliser obéit à des règles. L'une de ces règles est que toute balise ouverte doit être refermée, soit en lui associant une autre balise de même nom précédé de /, soit en plaçant un / à la fin de la balise (alors dite autofermante). Une autre règle importante est que les balises ne doivent pas se chevaucher et ne peuvent que s'enjamber. Il est ainsi interdit d'écrire : <chapitre>Ceci est une citation : <citation>Je pense donc</chapitre> je suis.</citation> ; la forme correcte est <chapitre>Ceci est une citation : <citation>Je pense donc je suis.</citation></chapitre>. Enfin, il faut comprendre que, en principe, les balises reflètent la structure (sémantique) du document et ne servent pas à spécifier le style de présentation voulu (à la différence de l'ancien temps du HTML où <i>english</i> voulait dire "mettre english en italique" alors qu'aujourd'hui cela signifie "english est un mot étranger").

Un document XML se reconnait par sa première ligne, une déclaration obligatoire qui donne le numéro de la version XML utilisée et le codage des caractères employé. Un document XML codé en UTF-8 a donc la forme suivante.

<?xml version="1.0" encoding="UTF-8"?>
[…]

XML : les espaces de nommage

Il semble nécessaire de dire un mot des espaces de nommage, une notion qui est en général considérée comme trop compliquée pour les débutants. Du coup, les débutants s'arrachent les cheveux quand leur code de mise en forme par XSL ne fonctionne pas... Dans un tel cas, si les règles de base d'écriture de la feuille de style ont bien été vérifiées, les espaces de nommage peuvent être en cause.

Présentation

Il a été dit que les noms des balises dans le document XML ne sont pas imposées : elles peuvent être choisies par l'auteur du document.

Cependant, pour faciliter la coopération entre des entités distinctes partageant des documents, XML permet la mise en place de vocabulaires communs auxquels tous les acteurs peuvent se référer pour "parler le même jargon". De tels vocabulaires sont dits "contrôlés" ; ils jouent le rôle de normes ou de conventions communes pour travailler sur tel ou tel domaine spécialisé.

Un "espace de nommage" n'est alors pas autre chose qu'une nomenclature commune, un système de désignation des entités employées par les utilisateurs - une sorte de dictionnaire.

Exemple Open Office

Par exemple, les documents Open Office reposent sur des documents XML qui font référence à de nombreux espaces de nommage suivant deux méthodes.

Term Name: creator
URI:http://purl.org/dc/elements/1.1/creator
Label:Creator
Definition:An entity primarily responsible for making the resource.
Comment:Examples of a Creator include a person, an organization, or a service. Typically, the name of a Creator should be used to indicate the entity.
Type of Term:Property
Version:http://dublincore.org/usage/terms/history/#creator-006
Note:A second property with the same name as this property has been declared in the dcterms: namespace (http://purl.org/dc/terms/).
See the Introduction to the document "DCMI Metadata Terms" (http://dublincore.org/documents/dcmi-terms/) for an explanation.

Impact

La connaissance de ces faits est essentielle pour la mise en forme car la feuille de style ne pourra pas manipuler une telle balise sans la rattacher explicitement à son espace de nommage.

Enfin, lorsqu'aucun espace de nommage n'est invoqué dans le document XML, les balises appartiennent à l'espace de nommage NULL... et l'on devrait être tranquille pour la mise en forme !

Dans le cas contraire, il faut retenir que, pour mettre en forme un document XML avec XSL, il faut comprendre un minimum les espaces de nommage invoqués.

XSL : présentation générale succincte

Une "feuille de style" XSL (eXtensible StyleSheet Language), ainsi nommée par habitude et par commodité, est en réalité un programme informatique, écrit dans un langage spécialisé pour la transformation de document. Le mot "transformation" désigne aussi bien une simple mise en forme stylistique qu'une complète transformation en un autre document de structure complètement différente.

Le langage de programmation utilisé s'appelle XSLT. Il est ainsi désigné par le nom de la recommandation W3C qui définit les transformations réalisables avec des "feuilles de style" (eXtensible Stylesheet Language Transformations, soit "transformations (réalisables par) du langage extensible des feuilles de style"). Écrite dans ce langage, une feuille de style s'applique à un document XML dit "document source" pour produire un autre document (XML ou autre chose) dit "document résultat".

Il y a deux manières d'appliquer une feuille de style XSL à un document.

XSL : un exemple pas trop simple pour commencer, par la méthode du navigateur

Le tableau suivant présente, sur la première ligne, un document XML bref et la feuille de style XSL associée puis, sur la deuxième ligne, le résultat obtenu en ouvrant le document avec Firefox 47.

Contenu du fichier monXML.xml
(document source)		Contenu du fichier mon_style.xsl
("feuille de style")
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="mon_style.xsl"?>
<fruitsetlegumes>
        <fruits>
                <fruit>
                        <nom>Tomate</nom>
                        <commentaire>Solanum lycopersicum</commentaire>
                </fruit>
                <fruit>
                        <nom>Poire</nom>
                        <commentaire>Pyrus communis</commentaire>
                </fruit>
                <fruit>
                        <nom>Pomme</nom>
                        <commentaire>Malus pumila</commentaire>
                </fruit>
        </fruits>
        <legumes>
                <legume>
                        <nom>Aubergine</nom>
                        <commentaire>Solanum melongena</commentaire>
                </legume>
                <legume>
                        <nom>Haricots</nom>
                        <commentaire>Phaseolus vulgaris</commentaire>
                </legume>
        </legumes>
</fruitsetlegumes>

<?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" encoding="UTF-8" />

<xsl:template match="fruitsetlegumes">                                        
        <h1>Commentaires sur les fruits et les légumes</h1>
        <table>
                <tr><th>Nom</th><th>Commentaire</th></tr>
                <tr><td colspan="2"><strong>Fruits</strong></td></tr>
                <xsl:apply-templates select="fruits"/>
                <tr><td colspan="2"><strong>Légumes</strong></td></tr>
                <xsl:apply-templates select="legumes"/>
        </table>

</xsl:template>

<xsl:template match="fruits">
     <xsl:for-each select="fruit">
        <tr><td><xsl:value-of select="nom"/></td><td><xsl:value-of select="commentaire"/></td></tr>
     </xsl:for-each>
</xsl:template>

<xsl:template match="legumes">
     <xsl:for-each select="legume">
        <tr><td><xsl:value-of select="nom"/></td><td><xsl:value-of select="commentaire"/></td></tr>
     </xsl:for-each>
</xsl:template>

</xsl:stylesheet>
Document résultat (vu dans Firefox 47)Code source du résultat (fourni par Firefox 47)
resultat sous firefox <transformiix:result><h1>Commentaires sur les fruits et les légumes</h1><table><tbody><tr>
<th>Nom</th><th>Commentaire</th></tr><tr><td colspan="2"><strong>Fruits</strong>
</td></tr><tr><td>Tomate</td><td>Solanum lycopersicum</td></tr><tr>
<td>Poire</td><td>Pyrus communis</td></tr><tr><td>Pomme</td>
<td>Malus pumila</td></tr><tr><td colspan="2"><strong>Légumes</strong></td></tr>
<tr><td>Aubergine</td><td>Solanum melongena</td></tr><tr><td>Haricots</td>
<td>Phaseolus vulgaris</td></tr></tbody></table></transformiix:result>

Quelques commentaires, sans trop détailler à ce stade :

XSL : anatomie d'une feuille de style et fonctionnement de l'interpréteur

L'anatomie de la feuille de style répond au fonctionnement de l'interpréteur. Lorsque ce dernier reçoit le document source, il en parcourt tous les nœuds dans l'ordre SANS QU'IL SOIT NECESSAIRE DE LUI DEMANDER CETTE OPERATION DANS LE PROGRAMME. Pour chaque nœud, il regarde s'il existe un modèle (<xsl:template match=…>) qui lui soit applicable :

En particulier, si la feuille de style ne contient aucun modèle (c'est-à-dire qu'elle se réduit aux deux déclarations obligatoires ?xml et xsl:stylesheet, éventuellement suivies de l'instruction xsl:output), bien que le programme paraisse "vide", l'interpréteur fournit quand même en résultat une copie intégrale de l'ensemble du document. A MEDITER...

Il faut donc bien comprendre que les modèles éventuellement présents dans la feuille de style sont simplement mis à disposition de l'interpréteur, qui exécute un modèle lorsqu'il rencontre un nœud concordant avec lui dans son parcours de l'arbre source.

L'ordre dans lequel sont inscrits les modèles importe peu ; il est laissé au choix de l'auteur de la feuille de style.

Parmi les modèles, il y en a un plus important que les autres : c'est celui qui définit la structure du document résultat. En général, c'est celui qui concorde avec le nœud racine du document source et, donc, embrasse l'ensemble du document source.

Enfin, si des balises du document source sont des mots réservés par un espace de nommage, deux cas peuvent se présenter:

D'après ce qui précède, l'instruction <xsl:template match="…"> joue un rôle majeur dans XSLT. L'autre incontournable est <xsl:apply-templates select="…"/>. Ces deux instructions et d'autres fréquemment utilisées sont détaillées ci-dessous.

XSL : quelques instructions indispensables

XSLT est un langage puissant, trop riche pour être couvert ici en profondeur. La présente page s'en tient donc à quelques notions fondamentales. Pour aller plus loin, il existe sur le web des sources détaillées [5],[6],[7].

XSL : <xsl:template match="expression XPath">…</xsl:template> (instruction à deux balises, ouvrante et fermante)

Entre les guillemets de l'attribut match figure une expression XPath, c'est-à-dire, sans entrer dans le détail, une expression caractérisant le chemin d'accès au nœud voulu dans l'arborescence du fichier source. En fait, pour cette instruction (en l'absence d'ambiguité dans l'arbre source), il suffit de donner le nom de la balise, comme dans l'exemple vu plus haut. Si ce nom appartient à un espace de nommage (explicite ou par défaut, dans le document source), il faut le faire précéder d'un préfixe introduit au début de la feuille de style. Exemple :

<xsl:stylesheet version="1.0"
      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

      xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/"
      xmlns:dc="http://purl.org/dc/elements/1.1/"
      xmlns:oai="http://www.openarchives.org/OAI/2.0/">

[…]
<xsl:template match="oai_dc:dc">…</xsl:template>

En ce qui concerne le nœud racine, il y a deux expressions qui permettent d'obtenir des effets comparables :

Ces deux méthodes ne sont pas équivalentes.

XSL : <xsl:apply-templates select="expression XPath"/> (instruction à une balise, autofermante)

Lorque l'interpréteur entre dans un modèle pour l'appliquer au nœud courant, c'est qu'il a abandonné, pour ce nœud, l'option par défaut consistant à en copier le contenu intégral dans le document résultat. En conséquence, s'il est nécessaire de réaliser une copie de tout ou partie du nœud courant dans le cadre de la mise en forme, il faut commander cette opération à l'interpréteur. C'est à cela que sert cette instruction, qui peut être utilisée sans attribut ou avec.

Sans attribut, l'instruction <apply-templates/> signifie :
"copier le contenu du nœud courant et de tous ces enfants en appliquant les modèles éventuellement disponibles dans cette feuille ou, à défaut, le modèle par défaut (copie intégrale sans mise en forme)".

Avec l'attribut, l'instruction <apply-templates select="bidule"/> signifie :
"copier le contenu du nœud bidule et de tous ces enfants en appliquant les modèles éventuellement disponibles dans cette feuille ou, à défaut, le modèle par défaut (copie intégrale sans mise en forme)".
Le nœud bidule n'est sélectionnable par cette notation que s'il est un enfant du nœud courant. S'il en est un descendant plus lointain, il faut utiliser une double barre oblique : <apply-templates select="//bidule"/>. En cas d'ambiguité, il faut développer le chemin d'accès.

XSL : <xsl:value-of select="expression XPath"/> (instruction à une balise, autofermante)

Si, au lieu de copier le contenu du nœud courant et de tous ces enfants, le besoin est de copier un seul nœud, la solution est cette instruction. Il peut s'agir du nœud courant, d'un de ces enfants ou de l'un de ces descendants plus lointains. L'interpréteur copie le contenu du premier nœud conforme à l'expresion Xpath qu'il rencontre.

Par exemple, dans le cas de l'exemple encadré, si le seul modèle fourni dans la feuille de style est :

<xsl:template match="fruitsetlegumes"> <strong><xsl:value-of select="legumes/legume/nom"/></strong> </xsl:template>

seuls des nœuds nommés "nom" du sous-arbre "légumes" peuvent être conformes, donc le résultat obtenu (en méthode de sortie html) est :

Aubergine

ou bien, si le seul modèle fourni est :

<xsl:template match="fruitsetlegumes"> <strong><xsl:value-of select="//nom"/></strong> </xsl:template>

tout descendant nommé "nom" peut être conforme donc le résultat obtenu (en méthode de sortie html) est :

Tomate

XSL : <xsl:for-each select="expression XPath">…</xsl:for-each> (instruction à deux balises, ouvrante et fermante)

Pour obtenir tous les nœuds conformes à l'expression Xpath et non seulement le premier comme dans le paragraphe précédent, il est possible de faire une boucle. Cette instruction parcourt tous les nœuds conformes à l'expression Xpath et, pour chacun, exécute les instructions comprises entre sa balise ouvrante et sa balise fermante. Ainsi, toujours dans le cas de l'exemple encadré, un modèle unique :

<xsl:template match="fruitsetlegumes">
   <xsl:for-each select="//nom">
      <strong><xsl:value-of select="."/></strong>
   </xsl:for-each>
</xsl:template>

produit le résultat :

TomatePoirePommeAubergineHaricots

XSL : <xsl:text>Un texte quelconque</xsl:text> (instruction à deux balises, ouvrante et fermante)

Il a été vu plus haut qu'il était possible d'écrire directement des balises de mise en forme dans la feuille de style pour les insérer dans le document résultat. Au contraire, injecter du simple texte ne conduit pas à un résultat satisfaisant car les espaces ne sont pas prises en compte, l'interpréteur n'ayant pas moyen de les distinguer des espaces présentes dans le programme. Il faut donc utiliser cette instruction qui recopie, à l'endroit où elle est placée, le texte compris entre ses deux balises.

XSL : <xsl:if test="expression logique">…</xsl:if> (instruction à deux balises, ouvrante et fermante)

Comme tout langage informatique digne de ce nom, XSLT possède une expression d'exécution conditionnelle dépendant de la valeur logique du résultat d'un test. Si l'expression logique inscrite entre les guillemets de l'attribut test est vraie, alors l'instruction xsl:if exécute toutes les instructions comprises entre ses deux balises.
Il est à noter que XSLT (au moins dans sa version 1.0) ne propose pas d'instruction "if then else". Pour pallier ce manque, plusieurs méthodes existent, la plus simple consistant à enchaîner deux instructions if testant des conditions exactement contraires.

La condition de test peut être variée. Elle peut notamment utiliser des fonctions disponibles dans le langage. Deux exemples suivent pour illustrer la méthode. Le premier exemple complète l'exemple précédent en utilisant if pour insérer une ponctuation : une virgule et une espace après chaque nom sauf pour le dernier qui doit être suivie d'un point. À cet effet, deux fonctions sont utilisées : position(), qui donne le rang du nœud courant dans la liste des nœuds sélectionnés par l'expression for-each, et last(), qui donne le rang du dernier élément de cette liste.

<xsl:template match="fruitsetlegumes">
   <xsl:for-each select="//nom">
      <strong><xsl:value-of select="."/></strong>
      <xsl:if test="not(position()=last())"><xsl:text>, </xsl:text></xsl:if>
      <xsl:if test="position()=last()"><xsl:text>.</xsl:text></xsl:if>
   </xsl:for-each>
</xsl:template>

produit le résultat :

Tomate, Poire, Pomme, Aubergine, Haricots.

Un deuxième exemple n'écrit que les valeurs des nœuds nommés "nom" qui contiennent la lettre m, séparés par des espaces.

<xsl:template match="fruitsetlegumes">
   <xsl:for-each select="//nom">
      <xsl:if test="contains(.,'m')">
      <strong><xsl:value-of select="."/><xsl:text> </xsl:text></strong>
      </xsl:if>
   </xsl:for-each>
</xsl:template>

produit le résultat :

Tomate Pomme

Une liste des fonctions XSLT est disponible notamment sur w3schools [8].

XSL: les attributs

Pour clore cette brève introduction à XSL, il faut encore mentionner un aspect qui n'a pas encore été évoqué malgré son importance : chaque nœud XML peut être doté d'attributs et ceux-ci peuvent être utilisés pour les sélections et les tests de nœuds. Ils peuvent aussi être restitués en résultat.

Un attribut est un couple identifiant/valeur inscrit à l'intérieur de la balise ouvrante d'un nœud sous la forme identifiant="valeur".

Par exemple, une variante de l'exemple utilisé plus haut peut être construite en donnant pour chaque fruit ou légume son nom en français, son nom en anglais et son pays d'origine, puis en ajoutant à chaque nœud terminal "nom" un attribut langue précisant dans quelle langue est exprimé le nom (fr ou uk).

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="mon_style.xsl"?>
<fruitsetlegumes>
        <fruits>
                <fruit>
                        <nom langue="fr">Tomate</nom>
                        <nom langue="uk">Tomato</nom>
                        <origine>France</origine>
                </fruit>
                <fruit>
                        <nom langue="fr">Poire</nom>
                        <nom langue="uk">Pear</nom>
                        <origine>Espagne</origine>
                </fruit>
                <fruit>
                        <nom langue="fr">Pomme</nom>
                        <nom langue="uk">Apple</nom>
                        <origine>Portugal</origine>
                </fruit>
        </fruits>
        <legumes>
                <legume>
                        <nom langue="fr">Aubergine</nom>
                        <nom langue="uk">Eggplant</nom>
                        <origine>Grèce</origine>
                </legume>
                <legume>
                        <nom langue="fr">Haricots</nom>
                        <nom langue="uk">Beans</nom>
                        <origine>France</origine>
                </legume>
        </legumes>
</fruitsetlegumes>

L'accès à l'attribut se fait en préfixant son identifiant par un caractère @, ici : @langue. La table suivante montre quelques feuilles de style et le document résultat produit par chacune. Ces résultats sont obtenus rapidement en utilisant l'interpréteur en ligne de w3schools et donc le lien au fichier mon-style.xsl ne figure pas dans le XML source.

Feuille de styleRésultatCommentaire
<?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" encoding="UTF-8" />
</xsl:stylesheet>
 Tomate Tomato France Poire Pear Espagne Pomme Apple Portugal Aubergine Eggplant Grèce Haricots Beans France Pas de modèle fourni. Recopie les valeurs de tous les nœuds.
<?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" encoding="UTF-8" />
<xsl:template match="fruitsetlegumes">
<xsl:for-each select="//nom">
<xsl:value-of select="."/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
 TomateTomatoPoirePearPommeAppleAubergineEggplantHaricotsBeans Un seul modèle fourni (pour la racine).

Recopie les valeurs de tous les nœuds "nom".
<?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" encoding="UTF-8" />
<xsl:template match="fruitsetlegumes">
<xsl:for-each select="//nom">
<xsl:value-of select=".[@langue='fr']"/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
 TomatePoirePommeAubergineHaricots Un seul modèle fourni (pour la racine).

Noter le "." (nœud courant) entre les guillemets du select de l'instruction value-of.


Recopie tous les nœuds "nom" dont la langue est "fr".
<?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" encoding="UTF-8" />
<xsl:template match="fruitsetlegumes">
<xsl:for-each select="//nom[@langue='uk']">
<xsl:value-of select=".[contains(.,'t')]"/>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
 TomatoEggplant Un seul modèle fourni (pour la racine).

Recopie les valeurs de tous les nœuds "nom" dont la valeur en langue anglaise contient la lettre "t".
<?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" encoding="UTF-8" />
<xsl:template match="fruitsetlegumes">
   <xsl:for-each select="//nom[@langue='uk' and contains(.,'t')]">
         <xsl:value-of select="."/>
         <xsl:text> (</xsl:text>
         <xsl:value-of select="./@langue"/>
         <xsl:text>) </xsl:text>
   </xsl:for-each>
</xsl:template>
</xsl:stylesheet>
 Tomato (uk) Eggplant (uk) Un seul modèle fourni (pour la racine).

Recopie les valeurs de tous les nœuds "nom" dont la valeur en langue anglaise contient la lettre "t". Chaque nœud est suivi de l'indication de la langue (attribut) entre parenthèses.

Ces quelques exemples suffisent à montrer la flexibilité que donnent à Xpath les extensions par des expressions de test.

XML et XSL en PHP

Depuis sa version 5, php offre une prise en compte complète de la "programmation orientée objet" (POO). Dans cette approche, les programmes manipulent des objets qui possèdent des propriétés et des méthodes. Il est parfois commode de créer des objets en décalquant un modèle puis en le personnalisant pour l'usage voulu. En PHP, ces modèles sont appelés des classes. D'une certaine façon, le concept de classe généralise la notion de type utilisée dans certains langages. Créer un objet structuré selon une classe s'appelle "créer une instance de la classe" ; l'instance en question est l'objet créé. Une classe peut être vue comme un conteneur dans lequel se trouvent la structure commune de toutes ces instances, avec toutes les méthodes et propriétés (variables, constantes) nécessaires pour utiliser une instance. A sa création, une instance est dotée de cette structure complète.

Compte tenu de l'économie d'énergie représentée par l'emploi des classes, les langages POO en général et PHP en particulier proposent des classes pré-définies (ça dépend un peu de l'installation...). Notamment, pour la mise en œuvre de XSLT, PHP propose une classe nommée XSLTProcessor. Cette classe est un opérateur qui transforme un document XML en un autre document (par exemple du XML aussi) en utilisant des règles de transformation définies par une feuille de style (document XSL). Comme cela a été vu plus haut, le nom "feuille de style" donne une image limitée de la chose : il s'agit d'un véritable programme écrit en langage XSLT. De ce point de vue, la classe XSLTProcessor implémente en fait un interpréteur pour ce langage. La classe fournit les outils pour mettre en œuvre l'interpréteur : charger le programme XSLT, lire le document source XML, produire le document résultat...

D'après la rubrique "classe XSLTProcessor" de php.net, les méthodes de XSLTProcessor sont les fonctions suivantes (les paramètres évoqués sont ceux éventuellement utilisés par la "feuille de style") :

A part __construct, une méthode method d'une instance $monProc de XSLTProcessor s'utilise par la notation $monProc->method(…) .

Dans une utilisation simple transformant du XML en HTML, il faudra simplement créer une instance de XSLTProcessor, importer dedans une feuille de style (importStylesheet) précisant que la sortie doit être du HTML et définissant la structure HTML voulue, puis appeler la méthode de transformation en XML (transformToXML) en lui fournissant le XML source.

Les entrées/sorties "naturelles" de XSLTProcessor sont des objets de la classe DOMDocument. Cette classe représente tout document XML ou HTML mais elle ne se réduit pas au contenu textuel du document. Puisque c'est une classe, elle comporte toutes les propriétés et méthodes permettant de manipuler ce texte : par exemple, elle permet de gérer son encodage, de créer un nœud ou un commentaire, etc. La longue liste des propriétés et méthodes est donnée par la page "classe DOMDocument de php.net. Pour la sortie, cependant, il ne faut pas hésiter à employer la transformation directe en XML ; si elle répond au besoin, c'est plus simple.

La programmation en php de la transformation simple du contenu d'un fichier XML source en une chaîne de caractères contenant une structure XML résultat délivrée dans une variable tient donc en 7 instructions (la gestion d'erreur étant ici laissée de côté dans un objectif de lisibilité), plus une instruction pour visualiser le résultat :

<?php

$feuilleDeStyle = new DOMDocument(); // Création d'un objet DOMDocument pour recevoir la "feuille de style"...
$feuilleDeStyle->load($nom_du_fichier_style); // ... et chargement de cette feuille de style dans cet objet

$xmlSource = new DOMDocument(); // Création d'un objet DOMDocument pour recevoir le XML source...
$xmlSource->load($nom_du_fichier_XML_source); // ... et chargement de ce XML source dans cet objet

$monProc = new XSLTProcessor(); // Création d'une instance de XSLTProcessor...
$monProc->importStyleSheet($feuilleDeStyle); // ... et importation dedans de l'objet DOMDocument contenant la feuille de style
$xmlResultat=$monProc->transformToXML($xmlSource); // ... et application de la transformation pour passer du XML source au résultat.

echo $xmlResultat ;
?>

Le travail productif de l'utilisateur est donc l'écriture du programme XSLT de transformation.

Conclusion

Le lecteur parvenu à ce stade non épuisé
... et qui brûle d'en savoir plus
... ... peut lire la deuxième partie de ce petit guide introductif.

Références

© Sellig Zed, août 2016. Texte et illustrations diffusés sous licence Creative Commons "Attribution - Pas d'utilisation commerciale" 4.0 International (cf. http://creativecommons.org/licenses/by-nc/4.0/).

logo html 5 Validé avec le vérificateur du W3C