Parsing XML-data. Parsing XML-data Instantiere en parser
Forfatter: Arseny Kapoulkine
Publiseringsdato: 21. september 2012
Oversettelse: A. Panin
Oversettelsesdato: 10. november 2013
Introduksjon
XML er et standardisert markup-språk som har et sett med regler for koding av hierarkisk strukturerte dokumenter på en lesbar måte. tekstformat. XML-standarden har blitt utbredt og brukes til å generere både svært kompakte enkle dokumenter (som SOAP-forespørsler) og multi-gigabyte dokumenter (brukt av OpenStreetMap-prosjektet) med komplekse dataavhengigheter (COLLADA). For å behandle XML-dokumenter krever brukere vanligvis et spesielt bibliotek: det må implementere en XML-dokumentparser som konverterer dokumentet fra et tekstdokument til en intern representasjon. XML-standarden er en avveining når det gjelder parsehastighet, brukerlesbarhet og kodekompleksitet for å analysere - derfor kan det å ha et raskt system for å analysere XML-dokumenter påvirke det foretrukne valget av XML som format for lagring av applikasjonsdata.
Dette kapittelet beskriver ulike teknikker som tar sikte på å forbedre ytelsen til det beskrevne parsesystemet og la forfatteren utvikle et ekstremt produktivt parsesystem ved å bruke C++-programmeringsspråket: pugixml. Selv om disse teknikkene ble brukt for XML-dokumentparsing-systemet, kan de fleste av dem brukes på dokumentparsingsystemer i andre formater eller til og med i fullstendig urelaterte programvarekomponenter (for eksempel er minneadministrasjonsalgoritmer mye brukt i urelaterte parsingsystemer tekstdokumenter områder).
Fordi det er flere vidt forskjellige tilnærminger til å analysere XML-dokumenter, og parsingsystemet må utføre ytterligere trinn som selv de som har erfaring med XML-dokumenter ikke er klar over, er det viktig å først beskrive oppgaven før du går i detalj om implementeringsdetaljene.
Modeller av XML-parsingsystemer
Hver av ulike modeller XML-dokumentanalysesystemer er optimale i visse situasjoner, og hver av disse modellene har sine egne ytelses- og minneforbruksparametere. Følgende modeller er de mest brukte:
- Ved bruk av SAX-baserte parsingsystemer (Simple API for XML), mottar brukeren på sin plassering programvarekomponent, som forventer en dokumentdatastrøm som input og gir flere tilbakeringingsfunksjoner som "åpne tag", "lukk tag", "tegn inne i taggen". Parsingsystemet bruker tilbakeringingsfunksjoner mens dokumentdata behandles. Konteksten som kreves for parsing er begrenset av dybden til det gjeldende elementets tre, noe som innebærer en betydelig reduksjon i minnekrav. Denne typen analyseringssystem kan brukes til å behandle streamede dokumenter når bare en del av dokumentet er tilgjengelig om gangen.
- Pull-parsing ligner på SAX-basert parsing når det gjelder selve prosessen - ett dokumentelement behandles om gangen, men metoden for å administrere parsing-prosessen endres: i et SAX-basert parsing-system styres parsing-prosessen av systemet selv ved hjelp av tilbakeringingsfunksjoner, mens brukeren under pull-parsing kontrollerer parsingsprosessen ved å bruke et iteratorlignende objekt.
- Ved bruk av DOM-baserte parsingsystemer (Document Object Model), sender brukeren parsingsystemet et komplett dokument i form av en buffer eller strøm av tekstdata, basert på hvilket parsingsystemet genererer en objektrepresentasjon i minnet av hele tre med dokumentelementer, ved å bruke separate objekter for hvert et spesifikt element eller XML-attributt, samt et sett med gyldige operasjoner (for eksempel "få alt barneelementer denne noden"). pugxml-biblioteket bruker denne modellen.
Valget av analysesystemmodell avhenger vanligvis av størrelsen på dokumentet og dets struktur. Fordi pugixml analyserer basert på DOM, er det effektivt for dokumenter som:
- er så små i størrelse at de kan passe helt inn i minnet,
- ha en kompleks struktur med koblinger mellom noder som må krysses, eller
- krever komplekse dokumenttransformasjoner.
Arkitektoniske løsninger i pugixml
Under utviklingen av pugixml-biblioteket var mye av fokuset på problemet med å lage DOM-representasjonen, siden selv om raske og lette SAX-baserte parsesystemer (som Expat) var tilgjengelige, var alle DOM-baserte XML-parsingsystemer tilgjengelige for produksjon bruk på tidspunktet pugixml ble opprettet (2006) var enten ikke for lette eller ikke for raske. Basert på dette er hovedmålet med puixml-utviklingsprosessen å lage et veldig raskt, lett bibliotek for å utføre DOM-basert manipulasjon av XML-dokumenter.
publisering av denne artikkelen er kun tillatt med en lenke til nettstedet til forfatteren av artikkelen
I denne artikkelen vil jeg vise et eksempel på hvordan man analyserer en stor XML-fil. Hvis serveren din (hosting) ikke forbyr å øke kjøretiden til skriptet, kan du analysere en XML-fil som veier minst gigabyte. Jeg har personlig kun analysert filer fra ozon som veier 450 megabyte.
Når du analyserer store XML-filer, oppstår det to problemer:
1. Ikke nok minne.
2. Det er ikke nok tildelt tid for skriptet til å kjøre.
Det andre problemet med tid kan løses hvis serveren ikke forbyr det.
Men problemet med minne er vanskelig å løse, selv om vi snakker om din egen server, så er det ikke veldig enkelt å flytte filer på 500 megabyte, og det er rett og slett ikke mulig å øke minnet på hosting og VDS.
PHP har flere innebygde XML-behandlingsalternativer - SimpleXML, DOM, SAX.
Alle disse alternativene er beskrevet i detalj i mange artikler med eksempler, men alle eksemplene viser arbeid med et fullstendig XML-dokument.
Her er ett eksempel, vi får et objekt fra XML-fil
Nå kan du behandle dette objektet, MEN...
Som du kan se, leses hele XML-filen inn i minnet, deretter blir alt analysert til et objekt.
Det vil si at all data går inn i minnet og hvis det ikke er nok tildelt minne, stopper skriptet.
Dette alternativet er ikke egnet for behandling av store filer, du må lese filen linje for linje og behandle disse dataene en etter en.
I dette tilfellet utføres også gyldighetskontrollen etter hvert som dataene behandles, så du må kunne tilbakestille, for eksempel slette alle data som er lagt inn i databasen ved en ugyldig XML-fil, eller utføre to pass gjennom filen, les først for gyldighet, les deretter for behandling av data.
Her er et teoretisk eksempel på å analysere en stor XML-fil.
Dette skriptet leser ett tegn om gangen fra en fil, samler disse dataene i blokker og sender dem til XML-parseren.
Denne tilnærmingen løser minneproblemet fullstendig og forårsaker ikke en belastning, men forverrer problemet over tid. Hvordan prøve å løse problemet over tid, les nedenfor.
Funksjon webi_xml ($file)
{
########
### datafunksjon
{
print $data ;
}
############################################
{
skriv ut $navn ;
print_r($attrs);
}
## avsluttende tag-funksjon
funksjon endElement ($parser, $navn)
{
skriv ut $navn ;
}
############################################
($xml_parser, "data");
// åpne filen
$fp = fopen($fil, "r");
$perviy_vxod = 1 ; $data = "" ;
{
$simvol = fgetc ($fp); $data .= $simvol ;
if($simvol != ">" ) (fortsett;)
ekko "
gå i stykker;
}
$data = "" ;
}
fclose($fp);
Webi_xml("1.xml");
?>
I dette eksemplet legger jeg alt inn i en funksjon webi_xml() og helt nederst kan du se kallet.
Selve skriptet består av tre hovedfunksjoner:
1. En funksjon som fanger opp åpningen av startElement()-taggen
2. En funksjon som fanger opp den avsluttende endElement()-koden
3. Og datamottaksfunksjonen data() .
La oss anta at innholdet i fil 1.xml er en oppskrift
<
title
>Enkelt brød
<
ingredient amount
=
"3"
unit
=
"стакан"
>Mel
<
ingredient amount
=
"0.25"
unit
=
"грамм"
>Gjær
<
ingredient amount
=
"1.5"
unit
=
"стакан"
>Varmt vann
<
ingredient amount
=
"1"
unit
=
"чайная ложка"
>Salt
<
instructions
>
<
step
>
Bland alle ingrediensene og elt grundig.
<
step
>
Dekk til med et klede og la stå i en time i et varmt rom..
<
step
>
Elt igjen,
legg på en bakeplate og sett i ovnen.
<
step
>
Besøk nettstedet
Vi starter alt med å kalle den generelle funksjonen webi_xml ("1.xml" );
Deretter starter parseren i denne funksjonen og alle taggnavn konverteres til store bokstaver slik at alle tagger har samme store og små bokstaver.
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);
Nå indikerer vi hvilke funksjoner som vil fungere for å fange opp åpningen av en tag, lukke og behandle data
xml_set_element_handler($xml_parser, "startElement", "endElement");
xml_set_character_data_handler($xml_parser, "data");
Deretter kommer åpningen spesifisert fil, itererer gjennom filen ett tegn om gangen og hvert tegn legges til en strengvariabel til tegnet er funnet >
.
Hvis dette er den aller første tilgangen til filen, så slettes underveis alt som er unødvendig i begynnelsen av filen, alt som kommer før , dette er taggen som XML skal begynne med.
For første gang vil en strengvariabel inneholde en streng
Og send den til demontøren
xml_parse ($xml_parser, $data, feof ($fp));
Etter behandling av dataene tilbakestilles strengvariabelen og innsamlingen av data til en streng begynner igjen og strengen dannes for andre gang
På den tredje
Vær oppmerksom på at en strengvariabel alltid dannes fra en fullført tag >
og det er ikke nødvendig å sende innbruddstyven en åpen og lukket brikke med for eksempel data
Det er viktig for denne behandleren å motta en hel ubrutt tag, minst en åpen tag, og i neste trinn en lukket tag, eller umiddelbart motta 1000 linjer av en fil, det spiller ingen rolle, det viktigste er at taggen går ikke i stykker, for eksempel
le>Vanlig brød
På denne måten er det umulig å sende data til behandleren, siden taggen er revet.
Du kan komme opp med din egen metode for å sende data til behandleren, for eksempel samle 1 megabyte med data og sende det til behandleren for å øke hastigheten, bare sørg for at taggene alltid er fullført og dataene kan rives
Dermed kan du sende i deler som du ønsker stor fil til behandleren.
La oss nå se på hvordan disse dataene behandles og hvordan du får tak i dem.
La oss starte med åpningstaggerfunksjonen startElement ($parser, $name, $attrs)
La oss anta at behandlingen har nådd linjen
<
ingredient amount
=
"3"
unit
=
"стакан"
>Mel
Så inne i funksjonen vil variabelen $navn være lik ingrediens det vil si navnet på den åpne taggen (den har ikke kommet til å lukke taggen ennå).
Også i dette tilfellet vil en rekke attributter for denne taggen $attrs være tilgjengelig, som vil inneholde data beløp = "3" og enhet = "glass".
Etter dette ble dataene til den åpne taggen behandlet av funksjonen data ($parser, $data)
$data-variabelen vil inneholde alt som er mellom åpnings- og avslutningstaggen, i vårt tilfelle er dette teksten Muka
Og behandlingen av strengen vår av funksjonen avsluttes endElement ($parser, $name)
Dette er navnet på den lukkede taggen, i vårt tilfelle vil $name være lik ingrediens
Og etter det gikk alt i sirkler igjen.
Eksemplet ovenfor viser bare prinsippet for XML-behandling, men for reell bruk må det endres.
Vanligvis må du analysere stor XML for å legge inn data i databasen, og for å behandle dataene på riktig måte må du vite hvilken åpen tag dataene tilhører, hvilket nivå av tag-nesting og hvilke tags som er åpne i hierarkiet ovenfor. Med denne informasjonen kan du behandle filen riktig uten problemer.
For å gjøre dette, må du introdusere flere globale variabler som vil samle informasjon om åpne tagger, nesting og data.
Her er et eksempel du kan bruke
Funksjon webi_xml ($file)
{
global $webi_depth ; // teller for å spore hekkedybde
$webi_depth = 0 ;
global $webi_tag_open ; // vil inneholde en rekke åpne i dette øyeblikket tagger
$webi_tag_open = array();
global $webi_data_temp ; // denne matrisen vil inneholde dataene til én tag
####################################################
### datafunksjon
funksjonsdata ($parser, $data)
{
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;
// legg til data til matrisen som indikerer neste og åpen tag
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ].= $data ;
}
############################################
####################################################
### åpningsmerkefunksjon
funksjon startElement ($parser, $navn, $attrs)
{
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;
// hvis nesting-nivået ikke lenger er null, er én tag allerede åpen
// og dataene fra den allerede er i arrayet, kan du behandle den
if ($webi_depth)
{
"
;
skrive ut "
"
;
print_r($webi_tag_open); // rekke åpne tagger
skrive ut "
" ;
// etter å ha behandlet dataene, slett dem for å frigjøre minne
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}
// nå åpnes neste tag og videre behandling vil skje i neste trinn
$webi_depth++; // øke hekkingen
$webi_tag_open [ $webi_depth ]= $navn ; // legg til en åpen kode i informasjonsarrayen
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // legg nå til tag-attributter
}
###############################################
#################################################
## avsluttende tag-funksjon
funksjon endElement ($parser, $navn) (
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;
// databehandling begynner her, for eksempel å legge til databasen, lagre i en fil, etc.
// $webi_tag_open inneholder en kjede av åpne tagger etter neste nivå
// for eksempel $webi_tag_open[$webi_depth] inneholder navnet på den åpne taggen hvis informasjon for øyeblikket behandles
// $webi_depth tag neste nivå
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] rekke tagattributter
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] tagdata
Skriv ut "data". $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" ]);
skrive ut "
"
;
print_r($webi_tag_open);
skrive ut "
" ;
Unset($GLOBALS ["webi_data_temp"]); // etter å ha behandlet dataene, sletter vi hele arrayen med dataene, siden taggen ble lukket
unset($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // slett informasjon om denne åpne taggen... siden den ble lukket
$webi_depth --; // redusere hekking
}
############################################
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);
// angi hvilke funksjoner som vil fungere når du åpner og lukker tagger
xml_set_element_handler($xml_parser, "startElement", "endElement");
// spesifiser en funksjon for arbeid med data
xml_set_character_data_handler($xml_parser, "data");
// åpne filen
$fp = fopen($fil, "r");
$perviy_vxod = 1 ; // flagg for å sjekke den første oppføringen i filen
$data = "" ; // her samler vi inn data fra filen i deler og sender den til xml-parseren
// loop til slutten av filen er funnet
while (! feof ($fp ) og $fp )
{
$simvol = fgetc ($fp ); // les ett tegn fra filen
$data .= $simvol ; // legg til dette tegnet i dataene som skal sendes
// hvis tegnet ikke er sluttkoden, gå tilbake til begynnelsen av loopen og legg til et annet tegn i dataene, og så videre til sluttkoden blir funnet
if($simvol != ">" ) (fortsett;)
// hvis den avsluttende taggen ble funnet, vil vi nå sende disse innsamlede dataene for behandling
// sjekk om dette er den første oppføringen i filen, så sletter vi alt som er før taggen// siden noen ganger kan du støte på søppel før begynnelsen av XML (klossete redaktører, eller filen ble mottatt av et skript fra en annen server)
if($perviy_vxod ) ( $data = strstr ($data , "
// Kast nå dataene inn i xml-parseren
if (! xml_parse ($xml_parser, $data, feof ($fp))) (
// her kan du behandle og motta gyldighetsfeil...
// så snart en feil oppstår, stopper parsingen
ekko "
XML-feil: " . xml_error_string(xml_get_error_code($xml_parser));
ekko "på linje". xml_get_current_line_number ($xml_parser);
gå i stykker;
}
// etter parsing, forkast de innsamlede dataene for neste trinn i syklusen.
$data = "" ;
}
fclose($fp);
xml_parser_free($xml_parser);
// fjerning av globale variabler
unset($GLOBALS ["webi_depth"]);
unset($GLOBALS [ "webi_tag_open" ]);
unset($GLOBALS ["webi_data_temp"]);
Webi_xml("1.xml");
?>
Hele eksemplet er ledsaget av kommentarer, nå test og eksperimenter.
Vær oppmerksom på at i funksjonen for å jobbe med data, blir data ikke bare satt inn i en matrise, men heller lagt til ved å bruke " .="
siden dataene kanskje ikke kommer i sin helhet, og hvis du bare lager en oppgave, vil du fra tid til annen motta dataene i biter.
Vel, det er alt, nå er det nok minne når du behandler en fil uansett størrelse, men skriptets kjøretid kan økes på flere måter.
Sett inn en funksjon i begynnelsen av skriptet
set_time_limit(6000);
eller
ini_set ("maks_utførelsestid" , "6000" );
Eller legg til tekst i .htaccess-filen
php_value max_execution_time 6000
Disse eksemplene vil øke kjøretiden for skriptet til 6000 sekunder.
Du kan kun øke tiden på denne måten når sikker modus er slått av.
Hvis du har tilgang til edit php.ini kan du øke tiden ved å bruke
max_execution_time = 6000
For eksempel, på Masterhost-hosting, er det i skrivende stund forbudt å øke skripttiden, til tross sikkerhetsmodus, men hvis du er en proff, kan du lage din egen php-bygge på masterhosten, men det står ikke i denne artikkelen.
XML-parsing betyr i hovedsak å gå gjennom et XML-dokument og returnere de tilsvarende dataene. Og selv om et økende antall webtjenester returnerer data til JSON-format men de fleste bruker fortsatt XML, så det er viktig å mestre XML-parsing hvis du vil bruke hele spekteret tilgjengelige grensesnitt API.
Bruker utvidelsen SimpleXML i PHP, som ble lagt tilbake i PHP 5.0, er det veldig enkelt og enkelt å jobbe med XML. I denne artikkelen vil jeg vise deg hvordan du gjør det.
Grunnleggende bruk
La oss starte med følgende eksempel languages.xml:
>
>
>
>
Dette XML-dokumentet inneholder en liste over programmeringsspråk med litt informasjon om hvert språk: året det ble introdusert og navnet på dets skaper.
Det første trinnet er å laste XML ved hjelp av funksjonene enten simplexml_load_file(), eller simplexml_load_string(). Som navnet på funksjonene antyder, vil den første laste XML fra en fil, og den andre vil laste XML fra en streng.
Begge funksjonene leser hele DOM-treet inn i minnet og returnerer et objekt SimpleXMLElement. I eksemplet ovenfor er objektet lagret i $languages-variabelen. Du kan bruke funksjonene var_dump() eller print_r() for å få detaljer om det returnerte objektet hvis du vil.
SimpleXMLElement-objekt
[lang] => Array
[ 0 ] => EnkeltXMLElementobjekt
[@attributes] => Matrise
[navn] => C
[dukket opp] => 1972
[skaper] => Dennis Ritchie
[ 1 ] => SimpleXMLElement-objekt
[@attributes] => Matrise
[navn] => PHP
[dukket opp] => 1995
[skaper] => Rasmus Lerdorf
[ 2 ] => SimpleXMLElement-objekt
[@attributes] => Matrise
[navn] => Java
[dukket opp] => 1995
[skaper] => James Gosling
)
)
Denne XML-en inneholder et rotelement språk, der det er tre elementer lang. Hvert array-element tilsvarer et element lang i XML-dokumentet.
Du kan få tilgang til egenskapene til et objekt ved å bruke operatoren -> . For eksempel vil $languages->lang returnere deg et SimpleXMLElement-objekt som samsvarer med det første elementet lang. Dette objektet inneholder to egenskaper: dukket opp og skaperen.
$languages -> lang [ 0 ] -> dukket opp ;
$languages -> lang [ 0 ] -> skaper ;
Å vise en liste over språk og vise deres egenskaper kan gjøres veldig enkelt ved å bruke en standard loop som f.eks for hver.
foreach ($languages-> lang as $lang ) (
printf(
""
,
$lang ["navn" ],
$lang -> dukket opp,
$lang -> skaper
)
;
}
Legg merke til hvordan jeg fikk tilgang til elementets lang-attributtnavn for å få språknavnet. På denne måten kan du få tilgang til alle attributter til et element representert som et SimpleXMLElement-objekt.
Arbeide med navnerom
Mens du arbeider med XML for ulike nettjenester, vil du støte på elementnavnerom mer enn én gang. La oss endre vår languages.xml for å vise et eksempel på bruk av et navneområde:
xmlns:dc =>
>
>
>
>
Nå elementet skaperen passer i navneområdet dc som peker til http://purl.org/dc/elements/1.1/. Hvis du prøver å skrive ut språkskaperne med vår forrige kode, vil det ikke fungere. For å lese elementnavnerom må du bruke en av følgende tilnærminger.
Den første tilnærmingen er å bruke URI-navn direkte i koden når du får tilgang til elementnavneområdet. Følgende eksempel viser hvordan dette gjøres:
$dc = $languages-> lang [ 1 ] - > barn( "http://purl.org/dc/elements/1.1/")
;
echo $dc -> skaper ;
Metode barn() tar et navneområde og returnerer underordnede elementer som starter med et prefiks. Det krever to argumenter, hvorav det første er XML-navneområdet, og det andre er et valgfritt argument som er standard falsk. Hvis det andre argumentet er satt til TRUE, vil navneområdet bli behandlet som et prefiks. Hvis FALSE, vil navneområdet bli behandlet som et URL-navneområde.
Den andre tilnærmingen er å lese URI-navnene fra dokumentet og bruke dem når du får tilgang til elementnavneområdet. Dette er faktisk en bedre måte å få tilgang til elementer fordi du ikke trenger å være hardkodet til URI.
$namespaces = $languages-> getNamespaces (true) ;
$dc = $languages-> lang [1] -> barn (($namespaces ["dc"]);
echo $dc -> skaper ;
Metode GetNamespaces() returnerer en rekke prefiksnavn og tilhørende URIer. Den godtar en tilleggsparameter som er standard falsk. Hvis du setter det slik ekte, vil denne metoden returnere navnene som brukes i overordnede og underordnede noder. Ellers finner den navnerom som bare brukes i den overordnede noden.
Nå kan du iterere gjennom listen over språk som dette:
$languages = simplexml_load_file ("languages.xml" );
$ns = $languages-> getNamespaces (true);
foreach ($languages-> lang as $lang ) (
$dc = $lang -> barn ($ns [ "dc" ] );
printf(
"
%s dukket opp i %d og ble opprettet av %s.
" ,$lang ["navn" ],
$lang -> dukket opp,
$dc -> skaper
) ;
}
Praktisk eksempel - Parsing av en videokanal fra YouTube
La oss se på et eksempel som får en RSS-feed fra en YouTube-kanal og viser lenker til alle videoene fra den. For å gjøre dette, vennligst kontakt følgende adresse:
http://gdata.youtube.com/feeds/api/users/xxx/uploads
URL-en returnerer en liste over de nyeste videoene fra en gitt kanal i XML-format. Vi vil analysere XML og få følgende informasjon for hver video:
- Link til video
- Miniatyr
- Navn
Vi starter med å søke og laste inn XML:
$channel = "Kanalnavn" ;
$url = "http://gdata.youtube.com/feeds/api/users/". $channel. "/opplastinger" ;
$xml = file_get_contents($url);
$feed = simplexml_load_string ($xml) ;
$ns = $feed -> getNameSpaces (true);
Hvis du ser på XML-feeden, kan du se at det er flere elementer der enhet, som hver forhandler detaljert informasjon om en bestemt video fra kanalen. Men vi bruker bare miniatyrbilder, video-URL og tittel. Disse tre elementene er etterkommere av elementet gruppe, som igjen er et barn av inngang:
…
…
…
>
…
Vi skal bare gå gjennom alle elementene inngang, og for hver av dem vil vi trekke ut den nødvendige informasjonen. noter det spiller miniatyrbilde Og tittel er i medienavneområdet. Derfor må vi fortsette som i forrige eksempel. Vi henter navn fra dokumentet og bruker navneområdet ved tilgang til elementer.
foreach ($feed -> oppføring som $entry ) (
$group = $entry -> barn ($ns [ "media" ] );
$gruppe = $gruppe -> gruppe ;
$thumbnail_attrs = $gruppe -> thumbnail [1] -> attributter () ;
$image = $thumbnail_attrs [ "url" ] ;
$spiller = $gruppe -> spiller -> attributter () ;
$link = $player [ "url" ] ;
$tittel = $gruppe -> tittel ;
printf( "
$player, $image, $title);
}
Konklusjon
Nå som du vet hvordan du bruker SimpleXML For å analysere XML-data kan du forbedre ferdighetene dine ved å analysere forskjellige XML-feeder med forskjellige APIer. Men det er viktig å tenke på at SimpleXML leser hele DOM inn i minnet, så hvis du analyserer et stort datasett, kan du gå tom for minne. Les dokumentasjonen for å lære mer om SimpleXML.
Hvis du har spørsmål, anbefaler vi å bruke vår
