Analyse XML. Analyse de données XML Analyse d'une chaîne XML

Ainsi, par parties comme vous le souhaitez, vous pouvez envoyer un gros fichier au gestionnaire.

Voyons maintenant comment ces données sont traitées et comment les obtenir.

Commençons par la fonction d'ouverture des balises startElement ($ parser, $ name, $ attrs)
Supposons que le traitement ait atteint la ligne
< ingredient amount = "3" unit = "стакан" >Farine
Ensuite, à l'intérieur de la fonction, la variable $ name sera égale à ingrédient c'est-à-dire le nom de la balise ouverte (il n'est pas encore venu à la fermeture de la balise).
Dans ce cas également, un tableau d'attributs de cette balise $ attrs sera disponible, dans lequel il y aura des données montant = "3" et unité = "verre".

Après cela, le traitement des données de la balise ouverte avec la fonction données ($ parseur, $ données)
La variable de données $ contiendra tout entre les balises d'ouverture et de fermeture, dans notre cas il s'agit du texte Flour

Et le traitement de notre chaîne est complété par la fonction endElement (analyseur $, nom $)
C'est le nom de la balise fermée, dans notre cas $ name sera égal à ingrédient

Et après cela, tout est redevenu un cercle.

L'exemple ci-dessus ne montre que le principe du traitement XML, mais pour une application réelle, il doit être amélioré.
Habituellement, vous devez analyser un XML volumineux pour entrer des données dans la base de données, et pour un traitement correct des données, vous devez savoir à quelle balise ouverte les données appartiennent, à quel niveau d'imbrication de balises et quelles balises sont ouvertes dans la hiérarchie supérieure. Avec ces informations, vous pouvez traiter correctement le fichier sans aucun problème.
Pour ce faire, vous devez saisir plusieurs variables globales qui collecteront des informations sur les balises ouvertes, l'imbrication et les données.
Voici un exemple que vous pouvez utiliser

Fonction webi_xml (fichier $)
{
global $ webi_depth; // compteur pour suivre la profondeur d'imbrication
$ webi_depth = 0;
global $ webi_tag_open ; // contiendra un tableau de balises actuellement ouvertes
$ webi_tag_open = tableau ();
global $ webi_data_temp; // ce tableau contiendra les données d'une balise

####################################################
### fonction pour travailler avec des données
données de fonction (analyseur $, données $)
{
global $ webi_depth;
global $ webi_tag_open ;
global $ webi_data_temp;
// ajoute des données au tableau indiquant l'imbrication et la balise actuellement ouverte
$ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["données"]. = $ données;
}
############################################

####################################################
### fonction d'ouverture des balises
fonction startElement ($ parser, $ name, $ attrs)
{
global $ webi_depth;
global $ webi_tag_open ;
global $ webi_data_temp;

// si le niveau d'imbrication n'est plus nul, alors une balise est déjà ouverte
// et les données de celui-ci sont déjà dans le tableau, vous pouvez le traiter
si ($ webi_depth)
{

" ;

imprimer "
" ;
print_r ($ webi_tag_open); // tableau de balises ouvertes
imprimer "

// après avoir traité les données, supprimez-les pour libérer de la mémoire
unset ($ GLOBALS ["webi_data_temp"] [$ webi_depth]);
}

// maintenant l'ouverture de la balise suivante a commencé et le traitement ultérieur aura lieu à l'étape suivante
$ webi_depth ++; // augmenter l'imbrication

$ webi_tag_open [$ webi_depth] = $ nom; // ajoute la balise open au tableau d'informations
$ webi_data_temp [$ webi_depth] [$ nom] ["attrs"] = $ attrs; // maintenant ajouter les attributs de balise

}
###############################################

#################################################
## fonction de balise de fin
fonction endElement ($ parser, $ nom) (
global $ webi_depth;
global $ webi_tag_open ;
global $ webi_data_temp;

// c'est ici que commence le traitement des données, par exemple, l'ajout à la base de données, l'enregistrement dans un fichier, etc.
// $ webi_tag_open contient une chaîne de balises ouvertes par niveau d'imbrication
// par exemple $ webi_tag_open [$ webi_depth] contient le nom de la balise ouverte dont les informations sont en cours de traitement
// niveau d'imbrication de la balise $ webi_depth
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"] tableau d'attributs de balise
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"] données de balise

Imprimer "données". $ webi_tag_open [$ webi_depth]. "-". ($ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"]). "
" ;
print_r ($ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"]);
imprimer "
" ;
print_r ($ webi_tag_open);
imprimer "

Non défini ($ GLOBALS ["webi_data_temp"]); // après avoir traité les données, supprimez l'intégralité du tableau de données, car la balise a été fermée
unset ($ GLOBALS ["webi_tag_open"] [$ webi_depth]); // supprime les informations sur cette balise ouverte ... depuis sa fermeture

$ webi_depth -; // diminue l'imbrication
}
############################################

$ xml_parser = xml_parser_create ();
xml_parser_set_option ($ xml_parser, XML_OPTION_CASE_FOLDING, true);

// spécifie quelles fonctions fonctionneront lors de l'ouverture et de la fermeture des balises
xml_set_element_handler ($ xml_parser, "startElement", "endElement");

// spécifie une fonction pour travailler avec des données
xml_set_character_data_handler($ xml_parser, "données");

// ouvre le fichier
$ fp = fopen ($ file, "r");

$ perviy_vxod = 1; // indicateur de vérification de la première entrée de fichier
$ données = "" ; // ici, nous collectons les données du fichier en plusieurs parties et les envoyons à l'analyseur XML

// boucle jusqu'à ce que la fin du fichier soit trouvée
while (! feof ($ fp) et $ fp)
{
$ simvol = fgetc ($ fp); // lit un caractère du fichier
$ données. = $ simvol; // ajoute ce symbole aux données à envoyer

// si le caractère n'est pas une balise de fin, alors on revient au début de la boucle et on ajoute un autre caractère aux données, et ainsi de suite jusqu'à ce que la balise de fin soit trouvée
if ($ simvol! = ">") (continuer;)
// si une balise de fermeture a été trouvée, envoyez maintenant ces données collectées pour traitement

// vérifie s'il s'agit de la première entrée dans le fichier, puis supprime tout ce qui se trouve avant la balise// car parfois des ordures peuvent être rencontrées avant le début de XML (éditeurs maladroits, ou le fichier est reçu par un script d'un autre serveur)
if ($ perviy_vxod) ($ data = strstr ($ data, "

// maintenant nous jetons les données dans l'analyseur XML
if (! xml_parse ($ xml_parser, $ data, feof ($ fp))) (

// ici, vous pouvez traiter et obtenir des erreurs de validité ...
// dès qu'une erreur est rencontrée, l'analyse s'arrête
écho "
Erreur XML : ". Xml_error_string (xml_get_error_code ($ xml_parser));
echo "à la ligne". xml_get_current_line_number ($ xml_parser);
Pause;
}

// après l'analyse, supprime les données collectées pour la prochaine étape du cycle.
$ données = "" ;
}
fclose ($ fp);
xml_parser_free ($ xml_parser);
// supprime les variables globales
unset ($ GLOBALS ["webi_depth"]);
unset ($ GLOBALS ["webi_tag_open"]);
unset ($ GLOBALS ["webi_data_temp"]);

Webi_xml ("1.xml");

?>

L'ensemble de l'exemple était accompagné de commentaires, maintenant testez et expérimentez.
Veuillez noter que dans la fonction de travail avec des données, les données ne sont pas simplement insérées dans un tableau, mais sont ajoutées à l'aide de " .=" étant donné que les données peuvent ne pas être complètes, et si vous effectuez une simple affectation, vous recevrez de temps en temps des données en morceaux.

Eh bien, c'est tout, il y aura désormais suffisamment de mémoire lors du traitement d'un fichier de n'importe quelle taille, mais le temps d'exécution du script peut être augmenté de plusieurs manières.
Au début du script, insérez la fonction
set_time_limit (6000);
ou
ini_set ("max_execution_time", "6000");

Ou ajoutez le texte à votre fichier .htaccess
php_value max_execution_time 6000

Ces exemples augmenteront le temps d'exécution du script à 6000 secondes.
Vous ne pouvez augmenter le temps de cette manière qu'en mode sans échec désactivé.

Si vous avez accès à l'édition de php.ini, vous pouvez augmenter le temps avec
max_execution_time = 6000

Par exemple, sur l'hébergement masterhost au moment d'écrire ces lignes, augmenter le temps du script est interdit, malgré le mode sans échec désactivé, mais si vous êtes un pro, vous pouvez faire votre propre assembly php sur le masterhost, mais il ne s'agit pas de que dans cet article.

Étape 1. Passage de test (interaction avec le contour de test du SIG GMP) # L'adresse du service de test du SIG GMP :
gisgmp.wsdlLocation = http: //213.59.255.182:7777/passerelle/services/SID0003663?wsdl
gisgmp.wsdlLocation.endPoint = http: //213.59.255.182: 7777/passerelle/services/SID0003663
Cette adresse est enregistrée dans les paramètres de la joint-venture. De plus, il est nécessaire de s'inscrire dans le fichier des paramètres de journalisation, en précisant la valeur TRACE... Après avoir entré les valeurs spécifiées, il est nécessaire de lancer la JV et le client ACC (redémarrer s'il a déjà été lancé) Ensuite, depuis le CDR ou la BU / AC Application pour le paiement des fonds, il est nécessaire d'effectuer l'action « Créer les détails du paiement », si les contrôles du système sont passés, les informations concernant le paiement seront créées. Qui devra plus tard être déchargé.
Après le déchargement, vous devez vérifier l'état à l'aide de l'action "Demander l'état du traitement". Après cela, les détails ED du paiement passent au statut "Accepté par GIS GMP" - ...

Étant donné: Table MSG (messages) avec de nombreuses entrées.
CREATETABLEmsg (idINTEGERNOTNULLPRIMARYKEY, descriptionCHAR (50) NOTNULL, date_createDATE);
Tâche:
Il faut vider la table des données /
Solution: Il existe plusieurs façons de résoudre ce problème. Vous trouverez ci-dessous une description et un exemple de chacun d'eux.
Le moyen le plus simple ( première option) - exécution de l'opérateur de suppression d'enregistrement. Lorsque vous l'exécutez, vous verrez le résultat (combien d'enregistrements ont été supprimés). Une chose pratique lorsque vous avez besoin de savoir avec certitude et de comprendre si les données correctes ont été supprimées. MAIS présente des inconvénients par rapport aux autres options pour résoudre le problème.

DELETE FROMmsg ; - Supprimer toutes les lignes de la table - Supprimer toutes les lignes avec la date de création "2019.02.01" DELETE FROMmsg WHEREdate_create = "2019.02.01";

Deuxième option... Utilisation d'une instruction DML pour effacer toutes les lignes d'une table.
TRUNCATETABLEmsg;
En même temps, l'utilisation de cet opérateur présente plusieurs fonctionnalités :
Ce n'est pas dans Firebird, nous utilisons donc les première et troisième options. Après avoir terminé ...

Adresses pertinentes pour se référer à ESMEV 3.0 Nous vous rappelons que conformément aux informations précédemment publiées sur le Portail Technologique SMEV 3.0, vous devez utiliser les adresses actuelles du Service Electronique Unifié :
l'adresse du service électronique unifié de l'environnement de développement SMEV 3.0 correspondant au schéma 1.1 - http://smev3-d.test.gosuslugi.ru:7500/smev/v1.1/ws?wsdl, tandis que le service sera également disponible à

Nous allons maintenant étudier le travail avec XML. XML est un format d'échange de données entre sites. Il est très similaire au HTML, seul XML autorise ses propres balises et attributs.

Pourquoi avez-vous besoin de XML lors de l'analyse ? Parfois, il arrive que le site que vous devez analyser dispose d'une API avec laquelle vous pouvez obtenir ce que vous voulez sans trop de contrainte. Par conséquent, un conseil immédiat - avant d'analyser le site, vérifiez s'il dispose d'une API.

Qu'est-ce qu'une API ? Il s'agit d'un ensemble de fonctions avec lesquelles vous pouvez envoyer une demande à ce site et recevoir la réponse souhaitée. Cette réponse est le plus souvent au format XML. Alors allons-y pour l'étudier.

Travailler avec XML en PHP

Supposons que vous ayez XML. Il peut être dans une chaîne, ou stocké dans un fichier, ou renvoyé sur demande à une URL spécifique.

Laissez XML être stocké dans une chaîne. Dans ce cas, vous devez créer un objet à partir de cette ligne en utilisant nouvel élément SimpleXMLE:

$ str = " Kolia 25 1000 "; $ xml = new SimpleXMLElement ($ str);

On a maintenant dans une variable $ xml un objet avec XML analysé est stocké. En accédant aux propriétés de cet objet, vous pouvez accéder au contenu des balises XML. Comment exactement - nous analyserons un peu ci-dessous.

Si XML est stocké dans un fichier ou est renvoyé en accédant à une URL (ce qui est le plus souvent le cas), alors vous devez utiliser la fonction simplexml_load_file qui fait le même objet $ xml:

Kolia 25 1000

$ xml = simplexml_load_file (chemin vers le fichier ou l'url);

Comment travailler

Dans les exemples ci-dessous, notre XML est stocké dans un fichier ou une URL.

Soit le XML suivant :

Kolia 25 1000

Récupérons le nom, l'âge et le salaire de l'employé :

$ xml = simplexml_load_file (chemin vers le fichier ou l'url); echo $ xml-> nom ; // affiche "Kolya" echo $ xml-> age; // affiche 25 echo $ xml-> salaire ; // affichera 1000

Comme vous pouvez le voir, l'objet $ xml a des propriétés correspondant aux balises.

Vous avez peut-être remarqué que la balise n'apparaît nulle part dans l'adresse. C'est parce que c'est la balise racine. Vous pouvez le renommer, par exemple, en - et rien ne changera :

Kolia 25 1000

$ xml = simplexml_load_file (chemin vers le fichier ou l'url); echo $ xml-> nom ; // affiche "Kolya" echo $ xml-> age; // affiche 25 echo $ xml-> salaire ; // affichera 1000

Il ne peut y avoir qu'une seule balise racine en XML, tout comme une balise en HTML simple.

Modifions un peu notre XML :

Kolia 25 1000

Dans ce cas, nous obtiendrons une chaîne d'appels :

$ xml = simplexml_load_file (chemin vers le fichier ou l'url); echo $ xml-> travailleur-> nom ; // affiche "Kolya" echo $ xml-> worker-> age; // affiche 25 echo $ xml-> travailleur-> salaire ; // affichera 1000

Travailler avec des attributs

Laissez certaines données être stockées dans des attributs :

Numéro 1

$ xml = simplexml_load_file (chemin vers le fichier ou l'url); echo $ xml-> worker ["nom"] ; // affiche "Kolya" echo $ xml-> worker ["age"]; // affiche 25 echo $ xml-> worker ["salaire"]; // imprime 1000 echo $ xml-> worker; // affiche "Numéro 1"

Balises avec trait d'union

Les balises (et attributs) avec un trait d'union sont autorisées en XML. Dans ce cas, ces balises sont accessibles comme ceci :

Kolia Ivanov

$ xml = simplexml_load_file (chemin vers le fichier ou l'url); echo $ xml-> worker -> (prénom); // affiche "Kolya" echo $ xml-> worker -> (nom); // affiche "Ivanov"

Itération sur une boucle

Disons maintenant que nous n'avons pas un employé, mais plusieurs. Dans ce cas, nous pouvons parcourir notre objet en utilisant une boucle foreach :

Kolia 25 1000 Vassia 26 2000 Pierre 27 3000

$ xml = simplexml_load_file (chemin vers le fichier ou l'url); foreach ($ xml as $ worker) (echo $ worker-> name; // affiche "Kolya", "Vasya", "Petya")

De l'objet au tableau normal

Si vous n'êtes pas à l'aise avec un objet, vous pouvez le convertir en un tableau PHP normal en utilisant l'astuce suivante :

$ xml = simplexml_load_file (chemin vers le fichier ou l'url); var_dump (json_decode (json_encode ($ xml), true));

Plus d'information

Analyse basée sur sitemap.xml

Souvent, le site a un fichier sitemap.xml. Ce fichier stocke des liens vers toutes les pages du site pour la commodité de leur indexation par les moteurs de recherche (l'indexation est en fait l'analyse du site par Yandex et Google).

En général, nous ne devrions pas nous soucier beaucoup de la raison pour laquelle ce fichier est nécessaire, l'essentiel est que s'il existe, vous ne pouvez pas gravir les pages du site en utilisant des méthodes astucieuses, mais simplement utiliser ce fichier.

Comment vérifier la présence de ce fichier : analysons le site site.ru, puis accédez à site.ru/sitemap.xml dans votre navigateur - si vous voyez quelque chose, alors il est là, et si vous ne le voyez pas il, alors hélas.

S'il existe un plan du site, il contient des liens vers toutes les pages du site au format XML. Prenez calmement ce XML, analysez-le, séparez les liens vers les pages dont vous avez besoin de la manière qui vous convient (par exemple, en analysant l'URL, qui a été décrite dans la méthode spider).

En conséquence, vous obtenez une liste de liens pour l'analyse, il vous suffit de vous y rendre et d'analyser le contenu dont vous avez besoin.

En savoir plus sur le périphérique sitemap.xml dans Wikipedia.

Que faire ensuite:

Commencez à résoudre des problèmes sur le lien suivant : tâches pour la leçon.

Lorsque vous avez tout décidé, passez à l'étude d'un nouveau sujet.

L'analyse XML signifie essentiellement parcourir un document XML et renvoyer les données appropriées. Alors qu'un nombre croissant de services Web renvoient des données au format JSON, la plupart utilisent encore XML, il est donc important de maîtriser l'analyse XML si vous souhaitez utiliser la gamme complète des API disponibles.

Utilisation de l'extension XML simple en PHP, qui a été ajouté en PHP 5.0, travailler avec XML est très simple et direct. Dans cet article, je vais vous montrer comment faire cela.

Bases d'utilisation

Commençons par l'exemple suivant langues.xml:

>

> 1972>
> Dennis Ritchie >
>

> 1995>
> Rasmus Lerdorf >
>

> 1995>
> James Gosling >
>
>

Ce document XML contient une liste de langages de programmation avec quelques informations sur chaque langage : l'année de sa mise en œuvre et le nom de son créateur.

La première étape consiste à charger XML à l'aide de fonctions soit simplexml_load_file () ou simplexml_load_string ()... Comme le nom des fonctions l'indique, la première chargera XML à partir d'un fichier et la seconde chargera XML à partir d'une chaîne.

Les deux fonctions lisent l'intégralité de l'arbre DOM en mémoire et renvoient un objet ÉlémentXMLE simple... Dans l'exemple ci-dessus, l'objet est stocké dans la variable $ languages. Vous pouvez utiliser des fonctions var_dump () ou print_r () pour obtenir des informations détaillées sur l'objet renvoyé, si vous le souhaitez.

Objet SimpleXMLElement
[lang] => Tableau
[0] => Objet SimpleXMLElement
[@attributs] => Tableau
[nom] => C
[apparu] => 1972
[créateur] => Dennis Ritchie
[1] => Objet SimpleXMLElement
[@attributs] => Tableau
[nom] => PHP
[apparu] => 1995
[créateur] => Rasmus Lerdorf
[2] => Objet SimpleXMLElement
[@attributs] => Tableau
[nom] => Java
[apparu] => 1995
[créateur] => James Gosling
)
)

Ce XML contient l'élément racine langues, à l'intérieur duquel se trouvent trois éléments lang. Chaque élément du tableau correspond à un élément langue dans le document XML.

Vous pouvez accéder aux propriétés d'un objet à l'aide de l'opérateur -> ... Par exemple, $ languages-> lang vous renverra un objet SimpleXMLElement qui correspond au premier élément langue... Cet objet contient deux propriétés : apparu et créateur.

$ langues -> lang [0] -> est apparu ;
$ langues -> lang [0] -> créateur ;

Il est très facile d'afficher une liste de langages et de montrer leurs propriétés à l'aide d'une boucle standard telle que pour chaque.

foreach ($ langues -> lang as $ lang) (
printf (
"" ,
$ lang ["nom"],
$ lang -> est apparu,
$ lang -> créateur
) ;
}

Remarquez comment j'ai accédé au nom d'attribut de l'élément lang pour obtenir le nom de la langue. De cette façon, vous pouvez accéder à n'importe quel attribut d'un élément représenté comme un objet SimpleXMLElement.

Travailler avec des espaces de noms

Lorsque vous travaillez avec le XML de divers services Web, vous rencontrerez plusieurs fois des espaces de noms d'éléments. Changeons notre langues.xml pour montrer un exemple d'utilisation de l'espace de noms :

xmlns : dc =>

> 1972>
> Dennis Ritchie >
>

> 1995>
> Rasmus Lerdorf >
>

> 1995>
> James Gosling >
>
>

Maintenant l'élément créateur placé dans l'espace de nom courant continu qui pointe vers http://purl.org/dc/elements/1.1/. Si vous essayez d'imprimer les créateurs de langage à l'aide de notre code précédent, cela ne fonctionnera pas. Pour lire les espaces de noms des éléments, vous devez utiliser l'une des approches suivantes.

La première approche consiste à utiliser les URI directement dans le code en faisant référence à l'espace de noms de l'élément. L'exemple suivant montre comment cela est fait :

$ dc = $ langues -> lang [1] -> enfants ( "http://purl.org/dc/elements/1.1/") ;
echo $ dc -> créateur;

Méthode enfants () prend un espace de noms et renvoie les éléments enfants qui commencent par un préfixe. Il prend deux arguments, le premier étant un espace de noms XML et le second argument facultatif, qui est par défaut faux... Si le deuxième argument est TRUE, l'espace de noms sera traité comme un préfixe. Si FALSE, l'espace de noms sera traité comme un espace de noms d'URL.

La deuxième approche consiste à lire les noms d'URI à partir du document et à les utiliser pour faire référence à l'espace de noms de l'élément. C'est en fait le meilleur moyen d'accéder aux éléments car vous n'avez pas à coder en dur l'URI.

$ namespaces = $ language -> getNamespaces (true);
$ dc = $ language -> lang [1] -> children ($ namespaces ["dc"]);

echo $ dc -> créateur;

Méthode Obtenir des espaces de noms () renvoie un tableau de noms de préfixes et d'URI associés. Il prend un paramètre supplémentaire, qui par défaut est faux... Si vous le définissez comme vrai alors cette méthode renverra les noms utilisés dans les nœuds parent et enfant. Sinon, il trouve les espaces de noms qui sont utilisés uniquement dans le nœud parent.

Vous pouvez maintenant parcourir la liste des langues comme suit :

$ langues = simplexml_load_file ("languages.xml");
$ ns = $ langues -> getNamespaces (true);

foreach ($ langues -> lang as $ lang) (
$ dc = $ lang -> enfants ($ ns ["dc"]);
printf (
"

% s est apparu dans % d et a été créé par % s.

Étude de cas - Analyse d'une chaîne vidéo YouTube

Jetons un coup d'œil à un exemple qui reçoit un flux RSS d'une chaîne YouTube et affiche des liens vers toutes les vidéos de celle-ci. Pour ce faire, vous devez contacter l'adresse suivante :

http://gdata.youtube.com/feeds/api/users/xxx/uploads

L'URL renvoie une liste des dernières vidéos de la chaîne donnée au format XML. Nous allons analyser le XML et obtenir les informations suivantes pour chaque vidéo :

• Lien vers la vidéo
• Miniature
• Nom

Nous allons commencer par rechercher et charger XML :

$ canal = "Nom du canal" ;
$ url = "http://gdata.youtube.com/feeds/api/users/"... $ canal. "/ uploads" ;
$ xml = file_get_contents ($ url);

$ feed = simplexml_load_string ($ xml);
$ ns = $ feed -> getNameSpaces (true);

Si vous regardez le flux XML, vous pouvez voir qu'il contient plusieurs éléments entité, dont chacun stocke des informations détaillées sur une vidéo spécifique d'une chaîne. Mais nous n'utilisons que les vignettes, l'URL de la vidéo et le titre. Ces trois éléments sont les descendants de l'élément grouper qui, à son tour, est un enfant de entrée:

>
…
>
…


Titre ... >
…
>
…
>

Nous allons juste passer en revue tous les éléments. entrée, et pour chacun d'eux nous extrayons les informations nécessaires. noter que joueur, la vignette et Titre sont dans l'espace de noms du média. Il faut donc procéder comme dans l'exemple précédent. Nous obtenons les noms du document et utilisons l'espace de noms pour faire référence aux éléments.

foreach ($ feed -> input as $ entry) (
$ groupe = $ entrée -> enfants ($ ns ["media"]);
$ groupe = $ groupe -> groupe ;
$ thumbnail_attrs = $ group -> vignette [1] -> attributs ();
$ image = $ thumbnail_attrs ["url"] ;
$ joueur = $ groupe -> joueur -> attributs ();
$ lien = $ joueur ["url"] ;
$ titre = $ groupe -> titre ;
printf ( "

Conclusion

Maintenant que vous savez utiliser XML simple pour analyser les données XML, vous pouvez améliorer vos compétences en analysant différents flux XML avec différentes API. Mais il est important de garder à l'esprit que SimpleXML lit l'intégralité du DOM en mémoire, donc si vous analysez un grand ensemble de données, vous risquez de manquer de mémoire. Lisez la documentation pour en savoir plus sur SimpleXML.

Si vous avez des questions, nous vous recommandons d'utiliser notre