PHP XML Parser

PHP est un langage de script populaire pour le développement web, permettant aux développeurs de créer des sites dynamiques en intégrant du code au sein de HTML. L'une de ses fonctionnalités les plus utiles est sa capacité à travailler avec XML, un langage de balisage conçu pour stocker et transporter des données.

Dans ce guide, nous aborderons les fonctionnalités XML de PHP, notamment ses avantages, sa syntaxe et des exemples d'utilisation. À la fin, vous saurez comment travailler avec XML pour construire de meilleures applications et sites web.

Qu'est-ce que XML ?

XML signifie « eXtensible Markup Language ». C'est un langage de balisage qui permet aux développeurs de définir leurs propres balises et structures de documents, ce qui en fait un langage très flexible et personnalisable. XML est couramment utilisé pour stocker et transporter des données, par exemple dans les services web, les bases de données et les flux RSS.

XML est similaire à HTML, mais alors que HTML définit la manière dont les pages web sont affichées dans un navigateur, XML définit la structure et le contenu des données. Les balises XML permettent d'identifier les éléments de données et leurs relations, facilitant ainsi le transfert de données entre différents systèmes.

Avantages de l'utilisation de XML en PHP

L'utilisation de XML en PHP offre plusieurs avantages, notamment :

• Échange de données : XML est un format idéal pour échanger des données entre différents systèmes et plateformes. Comme XML est indépendant de la plateforme, les données peuvent être facilement transférées entre systèmes, quel que soit le système d'exploitation ou le langage de programmation utilisé.
• Stockage de données : XML est un excellent moyen de stocker et d'organiser des données dans un format structuré. En utilisant XML pour stocker des données, les développeurs peuvent y accéder et les manipuler facilement selon leurs besoins.
• Transformation de données : XML peut être facilement transformé en d'autres formats, tels que HTML, PDF et CSV, à l'aide de XSLT (Extensible Stylesheet Language Transformations).

Syntaxe de XML en PHP

Pour travailler avec XML en PHP, vous devez être familier avec la syntaxe utilisée pour définir les documents XML. Les documents XML sont composés d'éléments, d'attributs et de valeurs.

Les éléments sont définis à l'aide de balises ouvrantes et fermantes, comme <book> et </book>. Les éléments peuvent également contenir des éléments enfants, par exemple :

<book>
  <title>The Great Gatsby</title>
  <author>F. Scott Fitzgerald</author>
</book>

Les attributs sont utilisés pour fournir des informations supplémentaires sur les éléments, par exemple :

<book id="1234">
  <title>The Great Gatsby</title>
  <author>F. Scott Fitzgerald</author>
</book>

Les valeurs sont le contenu d'un élément, comme « The Great Gatsby » ou « F. Scott Fitzgerald ».

Quelle approche XML utiliser ?

PHP propose trois parseurs, et choisir le bon est important :

• SimpleXML — l'API la plus simple. Elle convertit un document XML en un arbre d'objets que l'on parcourt avec la syntaxe de propriété habituelle ($xml->book->title). Idéal pour les documents de petite à moyenne taille avec une structure connue. Ce guide se concentre sur SimpleXML ; consultez PHP SimpleXML pour une référence plus approfondie.
• DOMDocument (l'extension DOM) — une implémentation complète du DOM W3C. Plus verbeuse, mais elle permet de créer, déplacer et supprimer des nœuds avec précision, et elle est requise pour XSLT et la validation. Voir PHP XML DOM.
• XMLReader / XMLWriter — un parseur en flux, basé sur le tirage. Il lit un nœud à la fois au lieu de charger tout l'arbre en mémoire, ce qui en fait le bon choix pour les très grands fichiers (centaines de Mo) où SimpleXML et DOM épuiseraient la mémoire.

Les fonctions SAX historiques xml_parser_create() existent encore mais sont rarement utilisées dans le nouveau code ; SimpleXML couvre le même périmètre avec beaucoup moins de code répétitif.

Lire un document XML avec SimpleXML

Pour charger un fichier XML dans un arbre d'objets, utilisez la fonction simplexml_load_file(). Si la source est une chaîne (par exemple, une réponse d'API) plutôt qu'un fichier, utilisez plutôt simplexml_load_string().

Vérifiez toujours la valeur de retour : en cas de document malformé, les deux fonctions renvoient false au lieu de lever une exception, donc un résultat non vérifié est une source courante de bugs silencieux.

$xml = simplexml_load_file("books.xml");
if ($xml === false) {
    echo "Failed to load XML file.";
    exit;
}

Ce code lit le fichier XML et le convertit en un objet SimpleXMLElement, auquel vous accédez en utilisant la syntaxe orientée objet de PHP. Les éléments enfants deviennent des propriétés, et les éléments répétés (comme plusieurs balises <book>) se comportent comme une liste itérable.

Lire les attributs

Les attributs ne sont pas des propriétés — vous les lisez avec la syntaxe de tableau sur l'élément. Pour <book id="1234">, l'id est $book['id'] :

$xml = simplexml_load_string('<book id="1234"><title>The Great Gatsby</title></book>');
echo $xml['id'];     // 1234
echo $xml->title;    // The Great Gatsby

Notez que les valeurs SimpleXML sont des objets, pas de simples chaînes. Convertissez avec (string) lorsque vous avez besoin d'une vraie chaîne (par exemple, avant une comparaison stricte ou json_encode).

Écrire un document XML avec SimpleXML

Pour construire du XML à partir de zéro, créez un SimpleXMLElement avec un élément racine et ajoutez des enfants avec addChild() :

$xml = new SimpleXMLElement('<books></books>');
$book = $xml->addChild('book');
$book->addChild('title', 'The Great Gatsby');
$book->addChild('author', 'F. Scott Fitzgerald');
$xml->asXML('books.xml');

Ce code crée un SimpleXMLElement avec l'élément racine <books>, ajoute un enfant <book> avec des enfants <title> et <author>, et sauvegarde le document dans books.xml. Appeler asXML() sans argument renvoie le XML sous forme de chaîne au lieu d'écrire un fichier, ce qui est pratique lorsque vous devez l'envoyer dans une réponse HTTP.

Exemples d'utilisation

Examinons quelques exemples pratiques d'utilisation de XML en PHP.

Lire des données XML

Supposons que vous ayez un fichier XML appelé « books.xml » avec les données suivantes :

<books>
  <book>
    <title>The Great Gatsby</title>
    <author>F. Scott Fitzgerald</author>
  </book>
  <book>
    <title>To Kill a Mockingbird</title>
    <author>Harper Lee</author>
  </book>
</books>

Pour lire ces données en PHP, vous pouvez utiliser la fonction simplexml_load_file(), comme ceci :

$xml = simplexml_load_file("books.xml");
if ($xml === false) {
    echo "Failed to load XML file.";
    exit;
}
foreach ($xml->book as $book) {
  echo $book->title . " by " . $book->author . "\n";
}

Ce code charge le fichier XML dans un objet SimpleXMLElement, puis itère sur chaque élément <book> à l'aide d'une boucle foreach. Dans la boucle, il accède aux éléments enfants <title> et <author> en utilisant la syntaxe orientée objet, et les affiche dans la console.

Écrire des données XML

Supposons que vous souhaitiez créer un nouveau fichier XML avec les données suivantes :

<colors>
  <color>
    <name>Red</name>
    <hex>#FF0000</hex>
  </color>
  <color>
    <name>Green</name>
    <hex>#00FF00</hex>
  </color>
  <color>
    <name>Blue</name>
    <hex>#0000FF</hex>
  </color>
</colors>

Pour créer ces données XML en PHP, vous pouvez utiliser la classe SimpleXMLElement, comme ceci :

$xml = new SimpleXMLElement('<colors></colors>');
$red = $xml->addChild('color');
$red->addChild('name', 'Red');
$red->addChild('hex', '#FF0000');
$green = $xml->addChild('color');
$green->addChild('name', 'Green');
$green->addChild('hex', '#00FF00');
$blue = $xml->addChild('color');
$blue->addChild('name', 'Blue');
$blue->addChild('hex', '#0000FF');
$xml->asXML('colors.xml');

Ce code crée un nouvel objet SimpleXMLElement avec l'élément racine <colors>. Il ajoute ensuite trois éléments enfants <color>, chacun avec deux éléments enfants <name> et <hex>, et définit leurs valeurs en conséquence. Enfin, il sauvegarde le document XML dans un fichier appelé « colors.xml ».

Pièges courants

• Résultat de chargement non vérifié. simplexml_load_file() et simplexml_load_string() renvoient false, et non null, en cas d'erreur d'analyse. Testez avec === false avant d'utiliser le résultat.
• Les valeurs sont des objets, pas des chaînes. $xml->title est un SimpleXMLElement. Il fonctionne dans les contextes de chaîne (echo, concaténation) mais échoue lors de comparaisons surprenantes ; convertissez avec (string) en cas de doute.
• Erreurs d'analyse supprimées. Pour inspecter pourquoi l'analyse a échoué, appelez libxml_use_internal_errors(true) avant le chargement, puis lisez libxml_get_errors().
• Espaces de noms. Si votre XML utilise des espaces de noms (ex. xmlns:), l'accès par propriété simple ne trouvera pas les éléments — utilisez children() ou xpath() avec l'espace de noms enregistré.
• Données non fiables. N'analysez pas du XML provenant de sources non fiables sans précaution : les attaques par entité externe (XXE) sont un risque réel. Sur les versions modernes de PHP, le chargement d'entités concerné est désactivé par défaut, mais vérifiez avant de traiter du XML fourni par l'utilisateur.

Sujets connexes

• PHP SimpleXML — référence complète de l'extension SimpleXML.
• simplexml_load_file() et simplexml_load_string() — les deux fonctions de chargement en détail.
• PHP XML DOM — l'API DOMDocument plus puissante.
• PHP JSON — l'alternative plus légère pour l'échange de données.

Conclusion

Dans ce guide, nous avons vu ce qu'est XML, pourquoi il est utile, et comment lire, écrire et manipuler du XML en PHP avec la bibliothèque SimpleXML, ainsi que les pièges courants à surveiller. SimpleXML est le moyen le plus rapide de gérer des données XML structurées en PHP ; optez pour DOMDocument lorsque vous avez besoin d'un contrôle fin des nœuds, et pour XMLReader pour les très grands fichiers. Notez que les fonctions XML de PHP nécessitent l'extension libxml, qui est activée par défaut dans la plupart des installations standard.

Practice