Razčlenjevanje podatkov XML. Razčlenjevanje podatkov XML Instanciranje razčlenjevalnika
Avtor: Arseny Kapoulkine
Datum objave: 21. september 2012
Prevod: A. Panin
Datum prevoda: 10. november 2013
Uvod
XML je standardiziran označevalni jezik, ki ima nabor pravil za kodiranje hierarhično strukturiranih dokumentov na človeku berljiv način. format besedila. Standard XML je postal zelo razširjen in se uporablja za ustvarjanje tako zelo kompaktnih enostavnih dokumentov (kot so zahteve SOAP) kot večgigabajtnih dokumentov (ki jih uporablja projekt OpenStreetMap) s kompleksnimi podatkovnimi odvisnostmi (COLLADA). Za obdelavo dokumentov XML uporabniki običajno potrebujejo posebno knjižnico: implementirati mora razčlenjevalnik dokumentov XML, ki pretvori dokument iz besedilnega dokumenta v notranjo predstavitev. Standard XML je kompromis v smislu hitrosti razčlenjevanja, berljivosti uporabnika in kompleksnosti kode za razčlenjevanje - zato lahko hiter sistem za razčlenjevanje dokumentov XML vpliva na prednostno izbiro XML kot formata za shranjevanje podatkov aplikacije.
To poglavje opisuje različne tehnike, namenjene izboljšanju delovanja opisanega sistema za razčlenjevanje in avtorju omogočajo razvoj izjemno produktivnega sistema za razčlenjevanje z uporabo programskega jezika C++: pugixml. Čeprav so bile te tehnike uporabljene za sistem za razčlenjevanje dokumentov XML, jih je večino mogoče uporabiti za sisteme za razčlenjevanje dokumentov drugih formatov ali celo v popolnoma nepovezanih programskih komponentah (na primer, algoritmi za upravljanje pomnilnika se pogosto uporabljajo v nepovezanih sistemih za razčlenjevanje besedilni dokumenti področja).
Ker obstaja več zelo različnih pristopov k razčlenjevanju dokumentov XML in mora sistem za razčlenjevanje izvesti dodatne korake, ki se jih niti tisti, ki imajo izkušnje z dokumenti XML, ne zavedajo, je pomembno, da najprej opišete zadevno nalogo, preden greste v podrobnosti o podrobnostih izvedbe.
Modeli sistemov za razčlenjevanje XML
Vsak od razni modeli Sistemi za razčlenjevanje dokumentov XML so v določenih situacijah optimalni in vsak od teh modelov ima lastno zmogljivost in parametre porabe pomnilnika. Najpogosteje se uporabljajo naslednji modeli:
- Pri uporabi sistemov za razčlenjevanje, ki temeljijo na SAX (Simple API for XML), uporabnik prejme na svoji lokaciji programska komponenta, ki kot vhod pričakuje podatkovni tok dokumenta in ponuja več funkcij povratnega klica, kot so "odprta oznaka", "zapri oznaka", "znak znotraj oznake". Sistem za razčlenjevanje uporablja funkcije povratnega klica med obdelavo podatkov dokumenta. Kontekst, potreben za razčlenjevanje, je omejen z globino drevesa trenutnega elementa, kar pomeni znatno zmanjšanje pomnilniških zahtev. To vrsto sistema za razčlenjevanje je mogoče uporabiti za obdelavo pretočnih dokumentov, ko je naenkrat na voljo le del dokumenta.
- Razčlenjevanje po vleku je podobno razčlenjevanju, ki temelji na SAX, kar zadeva sam proces - en element dokumenta se obdeluje naenkrat, vendar je način upravljanja procesa razčlenjevanja spremenjen: v sistemu za razčlenjevanje, ki temelji na SAX, proces razčlenjevanja nadzoruje sam sistem z uporabo funkcij za povratni klic, medtem ko uporabnik pri vlečnem razčlenjevanju nadzoruje postopek razčlenjevanja z uporabo predmeta, podobnega iteratorju.
- Pri uporabi sistemov za razčlenjevanje, ki temeljijo na DOM (Document Object Model), uporabnik posreduje sistemu za razčlenjevanje celoten dokument v obliki medpomnilnika ali toka besedilnih podatkov, na podlagi katerega sistem za razčlenjevanje ustvari v pomnilniku objektno predstavitev celotnega dokumenta. drevo elementov dokumenta, z uporabo ločenih objektov za vsak določen element oz XML atribut, kot tudi niz veljavnih operacij (na primer "dobi vse otroški elementi to vozlišče"). Knjižnica pugxml uporablja ta model.
Izbira modela sistema za razčlenjevanje je običajno odvisna od velikosti dokumenta in njegove strukture. Ker pugixml razčlenjuje na podlagi DOM, je učinkovit za dokumente, ki:
- so tako majhne, da se lahko popolnoma prilegajo v spomin,
- imajo kompleksno strukturo s povezavami med vozlišči, ki jih je treba prehoditi, oz
- zahtevajo zapletene transformacije dokumentov.
Arhitekturne rešitve v pugixml
Med razvojem knjižnice pugixml je bil velik poudarek na problemu ustvarjanja predstavitve DOM, saj so bili kljub temu, da so bili na voljo hitri in lahki sistemi za razčlenjevanje na podlagi SAX (kot je Expat), vsi sistemi za razčlenjevanje XML na podlagi DOM na voljo za produkcijo uporaba v času, ko je bil ustvarjen pugixml (2006), niso bili prelahki ali ne prehitri. Na podlagi tega je glavni cilj razvojnega procesa puixml ustvariti zelo hitro in lahko knjižnico za izvajanje manipulacije dokumentov XML, ki temelji na DOM.
objava tega članka je dovoljena samo s povezavo na spletno stran avtorja članka
V tem članku bom pokazal primer, kako razčleniti veliko datoteko XML. Če vaš strežnik (gostovanje) ne prepoveduje povečanja časa delovanja skripta, potem lahko razčlenite datoteko XML, ki tehta vsaj gigabajtov; osebno sem razčlenil samo datoteke iz ozona, ki tehtajo 450 megabajtov.
Pri razčlenjevanju velikih datotek XML se pojavita dve težavi:
1. Ni dovolj pomnilnika.
2. Ni dovolj dodeljenega časa za izvajanje skripta.
Drugi problem s časom je mogoče rešiti, če strežnik tega ne prepove.
Toda težavo s pomnilnikom je težko rešiti, tudi če govorimo o lastnem strežniku, potem premikanje datotek velikosti 500 megabajtov ni zelo enostavno in preprosto ni mogoče povečati pomnilnika na gostovanju in VDS.
PHP ima več vgrajenih možnosti obdelave XML - SimpleXML, DOM, SAX.
Vse te možnosti so podrobno opisane v številnih člankih s primeri, vendar vsi primeri prikazujejo delo s celotnim dokumentom XML.
Tukaj je en primer, iz katerega dobimo predmet datoteko XML
Zdaj lahko obdelate ta predmet, TODA ...
Kot lahko vidite, je celotna datoteka XML prebrana v pomnilnik, nato pa je vse razčlenjeno v objekt.
To pomeni, da gredo vsi podatki v pomnilnik in če ni dovolj dodeljenega pomnilnika, se skript ustavi.
Ta možnost ni primerna za obdelavo velikih datotek; datoteko morate brati vrstico za vrstico in obdelati te podatke enega za drugim.
V tem primeru se preverjanje veljavnosti izvaja tudi med obdelavo podatkov, zato morate imeti možnost povrniti nazaj, na primer izbrisati vse podatke, vnesene v bazo podatkov v primeru neveljavne datoteke XML, ali izvesti dva prehoda skozi datoteko, najprej preberite za veljavnost, nato preberite za obdelavo podatkov.
Tukaj je teoretični primer razčlenjevanja velike datoteke XML.
Ta skript bere en znak naenkrat iz datoteke, zbira te podatke v bloke in jih pošlje razčlenjevalniku XML.
Ta pristop popolnoma reši problem pomnilnika in ne povzroča obremenitve, ampak sčasoma poslabša težavo. Kako sčasoma poskušati rešiti težavo, preberite v nadaljevanju.
Funkcija webi_xml ($file)
{
########
### podatkovna funkcija
{
natisni $podatke;
}
############################################
{
natisni $ime;
print_r($attrs);
}
## funkcija zaključne oznake
funkcija endElement ($parser, $name)
{
natisni $ime;
}
############################################
($xml_parser, "podatki");
// odprite datoteko
$fp = fopen($file, "r");
$perviy_vxod = 1; $podatki = "";
{
$simvol = fgetc ($fp); $podatki .= $simvol ;
if($simvol != ">" ) (nadaljuj;)
odmev "
odmor;
}
$podatki = "";
}
fclose($fp);
Webi_xml("1.xml");
?>
V tem primeru sem vse postavil v eno funkcijo webi_xml() in čisto na dnu lahko vidite njen klic.
Sam skript je sestavljen iz treh glavnih funkcij:
1. Funkcija, ki ujame začetek oznake startElement().
2. Funkcija, ki ujame zaključno oznako endElement().
3. In funkcija za prejemanje podatkov data() .
Predpostavimo, da je vsebina datoteke 1.xml recept
<
title
>Preprost kruh
<
ingredient amount
=
"3"
unit
=
"стакан"
>Moka
<
ingredient amount
=
"0.25"
unit
=
"грамм"
>kvas
<
ingredient amount
=
"1.5"
unit
=
"стакан"
>Topla voda
<
ingredient amount
=
"1"
unit
=
"чайная ложка"
>Sol
<
instructions
>
<
step
>
Vse sestavine zmešajte in temeljito pregnetite.
<
step
>
Pokrijemo s krpo in pustimo eno uro na toplem..
<
step
>
Ponovno pregnetemo,
položimo na pekač in damo v pečico.
<
step
>
Obiščite spletno mesto
Vse začnemo s klicem splošne funkcije webi_xml ("1.xml" );
Nato se razčlenjevalnik zažene v tej funkciji in pretvori vsa imena oznak v velike črke, tako da imajo vse oznake enake velike črke.
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, res);
Zdaj navajamo, katere funkcije bodo delovale za lovljenje odpiranja oznake, zapiranja in obdelave podatkov
xml_set_element_handler($xml_parser, "startElement", "endElement");
xml_set_character_data_handler($xml_parser, "podatki");
Sledi odkritje določeno datoteko, ponavlja skozi datoteko en znak naenkrat in vsak znak je dodan spremenljivki niza, dokler znaka ne najdemo >
.
Če je to prvi dostop do datoteke, bo na poti izbrisano vse, kar je nepotrebno na začetku datoteke, vse, kar je pred , to je oznaka, s katero bi se moral začeti XML.
Prvič bo spremenljivka niz vsebovala niz
In ga pošljite razstavljalcu
xml_parse ($xml_parser, $data, feof ($fp));
Po obdelavi podatkov se spremenljivka niza ponastavi in ponovno se začne zbiranje podatkov v niz ter drugič oblikuje niz.
Na tretjem
Upoštevajte, da je spremenljivka niza vedno oblikovana iz dokončane oznake >
in vlomilcu ni treba poslati odprto in zaprto oznako s podatki npr
Za ta upravljalnik je pomembno, da prejme celotno neprekinjeno oznako, vsaj eno odprto oznako in v naslednjem koraku zaprto oznako ali takoj prejme 1000 vrstic datoteke, ni pomembno, glavno je, da oznaka se ne zlomi npr
le>Navaden kruh
Na ta način je nemogoče poslati podatke upravljavcu, ker je oznaka raztrgana.
Lahko si izmislite lastno metodo pošiljanja podatkov obdelovalniku, na primer zberite 1 megabajt podatkov in ga pošljite obdelovalniku, da povečate hitrost, samo pazite, da so oznake vedno izpolnjene in da se podatki lahko raztrgajo
Tako lahko pošiljate po delih po želji velika datoteka vodniku.
Zdaj pa poglejmo, kako se ti podatki obdelujejo in kako jih pridobiti.
Začnimo s funkcijo začetnih oznak startElement ($parser, $name, $attrs)
Predpostavimo, da je obdelava dosegla črto
<
ingredient amount
=
"3"
unit
=
"стакан"
>Moka
Potem bo znotraj funkcije spremenljivka $name enaka sestavina to je ime odprte oznake (do zapiranja oznake še ni prišlo).
Tudi v tem primeru bo na voljo niz atributov te oznake $attrs, ki bo vseboval podatke količina = "3" in enota = "kozarec".
Po tem je funkcija obdelala podatke odprte oznake podatki ($parser, $data)
Spremenljivka $data bo vsebovala vse, kar je med začetno in zapiralno oznako, v našem primeru je to besedilo Muka
In obdelava našega niza s funkcijo se konča endElement ($parser, $name)
To je ime zaprte oznake, v našem primeru bo $name enako sestavina
In potem je šlo spet vse v krogu.
Zgornji primer samo prikazuje princip obdelave XML, vendar ga je za resnično uporabo treba spremeniti.
Običajno morate za vnos podatkov v bazo podatkov razčleniti velik XML, za pravilno obdelavo podatkov pa morate vedeti, kateri odprti oznaki podatki pripadajo, kateri ravni ugnezdenja oznak in katere oznake so odprte v zgornji hierarhiji. S temi informacijami lahko brez težav pravilno obdelate datoteko.
Če želite to narediti, morate uvesti več globalnih spremenljivk, ki bodo zbirale informacije o odprtih oznakah, gnezdenju in podatkih.
Tukaj je primer, ki ga lahko uporabite
Funkcija webi_xml ($file)
{
globalna $webi_depth; // števec za sledenje globine gnezdenja
$webi_depth = 0;
globalno $webi_tag_open; // bo vseboval niz odprtih v ta trenutek oznake
$webi_tag_open = array();
globalno $webi_data_temp; // ta niz bo vseboval podatke ene oznake
####################################################
### podatkovna funkcija
podatki funkcije ($parser, $data)
{
globalna $webi_depth;
globalno $webi_tag_open;
globalno $webi_data_temp;
// dodajte podatke v matriko, ki označuje gnezdenje in trenutno odprto oznako
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data"].= $data;
}
############################################
####################################################
### funkcija začetne oznake
funkcija startElement ($parser, $name, $attrs)
{
globalna $webi_depth;
globalno $webi_tag_open;
globalno $webi_data_temp;
// če raven gnezdenja ni več nič, potem je ena oznaka že odprta
// in podatki iz njega so že v matriki, jih lahko obdelate
če ($webi_depth)
{
"
;
natisni "
"
;
print_r($webi_tag_open); // niz odprtih oznak
natisni "
" ;
// po obdelavi podatkov jih izbrišite, da sprostite pomnilnik
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}
// zdaj je odprta naslednja oznaka in nadaljnja obdelava se bo zgodila v naslednjem koraku
$webi_depth++; // povečaj gnezdenje
$webi_tag_open [ $webi_depth ]= $name; // dodamo odprto oznako v polje informacij
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs; // zdaj dodajte atribute oznake
}
###############################################
#################################################
## funkcija zaključne oznake
funkcija endElement ($parser, $name) (
globalna $webi_depth;
globalno $webi_tag_open;
globalno $webi_data_temp;
// tukaj se začne obdelava podatkov, na primer dodajanje v bazo podatkov, shranjevanje v datoteko itd.
// $webi_tag_open vsebuje verigo odprtih oznak glede na raven gnezdenja
// na primer $webi_tag_open[$webi_depth] vsebuje ime odprte oznake, katere informacije se trenutno obdelujejo
// raven gnezdenja oznake $webi_depth
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] niz atributov oznak
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] podatki oznake
Natisnite "podatke". $webi_tag_open [ $webi_depth ]. "--" .($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "podatki" ]). "
"
;
print_r ($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "attrs" ]);
natisni "
"
;
print_r($webi_tag_open);
natisni "
" ;
Unset($GLOBALS [ "webi_data_temp" ]); // po obdelavi podatkov izbrišemo celotno matriko s podatki, saj je bil tag zaprt
unset($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // izbriši informacije o tej odprti oznaki ... ker se je zaprla
$webi_depth --; // zmanjšaj gnezdenje
}
############################################
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, res);
// navedite, katere funkcije bodo delovale pri odpiranju in zapiranju oznak
xml_set_element_handler($xml_parser, "startElement", "endElement");
// določite funkcijo za delo s podatki
xml_set_character_data_handler($xml_parser, "podatki");
// odprite datoteko
$fp = fopen($file, "r");
$perviy_vxod = 1; // zastavica za preverjanje prvega vnosa v datoteko
$podatki = ""; // tukaj zbiramo podatke iz datoteke po delih in jih pošiljamo razčlenjevalniku xml
// zanka, dokler ni najden konec datoteke
medtem ko (! feof ($fp) in $fp)
{
$simvol = fgetc ($fp); // prebere en znak iz datoteke
$podatki .= $simvol ; // dodajte ta znak podatkom, ki jih želite poslati
// če znak ni končna oznaka, se vrnite na začetek zanke in podatkom dodajte še en znak in tako naprej, dokler ne najdete končne oznake
if($simvol != ">" ) (nadaljuj;)
// če je bila zaključna oznaka najdena, bomo zdaj te zbrane podatke poslali v obdelavo
// preverimo, ali je to prvi vnos v datoteko, potem bomo izbrisali vse, kar je pred oznako// ker včasih lahko naletite na smeti pred začetkom XML-ja (nerodni urejevalniki ali pa je datoteko prejel skript z drugega strežnika)
if($perviy_vxod) ($data = strstr ($data, "
// zdaj vrzi podatke v razčlenjevalnik xml
if (! xml_parse ($xml_parser, $data, feof ($fp))) (
// tukaj lahko obdelate in prejmete napake veljavnosti ...
// takoj ko pride do napake, se razčlenjevanje ustavi
odmev "
Napaka XML: " . xml_error_string(xml_get_error_code($xml_parser));
echo "v vrstici". xml_get_current_line_number ($xml_parser);
odmor;
}
// po razčlenjevanju zavrzi zbrane podatke za naslednji korak cikla.
$podatki = "";
}
fclose($fp);
xml_parser_free($xml_parser);
// odstranjevanje globalnih spremenljivk
unset($GLOBALS [ "webi_depth" ]);
unset($GLOBALS [ "webi_tag_open" ]);
unset($GLOBALS [ "webi_data_temp" ]);
Webi_xml("1.xml");
?>
Celoten primer spremljajo komentarji, zdaj preizkusite in preizkusite.
Upoštevajte, da v funkciji dela s podatki podatki niso preprosto vstavljeni v matriko, temveč dodani z uporabo " .="
ker podatki morda ne bodo prispeli v celoti in če boste samo dodelili, boste od časa do časa prejeli podatke v kosih.
No, to je vse, zdaj je dovolj pomnilnika pri obdelavi datoteke katere koli velikosti, vendar je čas delovanja skripta mogoče povečati na več načinov.
Vstavite funkcijo na začetek skripta
nastavi_časovno_omejitev(6000);
oz
ini_set ("max_execution_time" , "6000" );
Ali dodajte besedilo v datoteko .htaccess
php_vrednost max_execution_time 6000
Ti primeri bodo podaljšali čas delovanja skripta na 6000 sekund.
Na ta način lahko podaljšate čas le, če je varni način izklopljen.
Če imate dostop do urejanja php.ini, lahko podaljšate čas z uporabo
max_execution_time = 6000
Na primer, pri gostovanju Masterhost je v času pisanja tega članka podaljševanje časa skripta prepovedano, kljub varni način, če pa ste profesionalec, lahko naredite svojo lastno php gradnjo na masterhost, vendar to ni v tem članku.
Razčlenjevanje XML v bistvu pomeni sprehod skozi dokument XML in vrnitev ustreznih podatkov. In čeprav vse več spletnih storitev vrača podatke v format JSON vendar večina še vedno uporablja XML, zato je pomembno, da obvladate razčlenjevanje XML, če želite uporabiti celoten obseg razpoložljivi vmesniki API.
Uporaba razširitve SimpleXML v PHP, ki je bil dodan nazaj v PHP 5.0, je delo z XML zelo lahko in preprosto. V tem članku vam bom pokazal, kako to storiti.
Osnove uporabe
Začnimo z naslednjim primerom languages.xml:
>
>
>
>
Ta dokument XML vsebuje seznam programskih jezikov z nekaj informacijami o vsakem jeziku: leto, ko je bil predstavljen, in ime njegovega ustvarjalca.
Prvi korak je naložiti XML z uporabo funkcij simplexml_load_file(), oz simplexml_load_string(). Kot že ime funkcij pove, bo prva naložila XML iz datoteke, druga pa bo naložila XML iz niza.
Obe funkciji prebereta celotno drevo DOM v pomnilnik in vrneta objekt SimpleXMLElement. V zgornjem primeru je objekt shranjen v spremenljivki $languages . Uporabite lahko funkcije var_dump() oz print_r() da dobite podrobnosti o vrnjenem predmetu, če želite.
Objekt SimpleXMLElement
[lang] => Niz
[ 0 ] => Objekt SimpleXMLElement
[@attributes] => Niz
[ime] => C
[se je pojavilo] => 1972
[ustvarjalec] => Dennis Ritchie
[ 1 ] => Objekt SimpleXMLElement
[@attributes] => Niz
[ime] => PHP
[se je pojavilo] => 1995
[ustvarjalec] => Rasmus Lerdorf
[ 2 ] => Objekt SimpleXMLElement
[@attributes] => Niz
[ime] => Java
[se je pojavilo] => 1995
[ustvarjalec] => James Gosling
)
)
Ta XML vsebuje korenski element jezikov, znotraj katerega so trije elementi jezik Vsak element matrike ustreza elementu jezik v dokumentu XML.
Do lastnosti predmeta lahko dostopate z uporabo operatorja -> . Na primer, $languages->lang vam bo vrnil objekt SimpleXMLElement, ki se ujema s prvim elementom jezik. Ta objekt vsebuje dve lastnosti: pojav in ustvarjalec.
$languages -> lang [0] -> pojavil se je;
$languages -> lang [0] -> ustvarjalec;
Prikaz seznama jezikov in njihovih lastnosti je mogoče narediti zelo enostavno z uporabo standardne zanke, kot je npr za vsakogar.
foreach ($languages -> lang kot $lang ) (
printf(
""
,
$lang [ "ime"],
$lang -> prikazano,
$lang -> ustvarjalec
)
;
}
Opazite, kako sem dostopal do imena atributa lang elementa, da sem dobil ime jezika. Na ta način lahko dostopate do katerega koli atributa elementa, predstavljenega kot objekt SimpleXMLElement.
Delo z imenskimi prostori
Med delom z XML različnih spletnih storitev boste večkrat naleteli na imenske prostore elementov. Spremenimo svoje languages.xml za prikaz primera uporabe imenskega prostora:
xmlns:dc =>
>
>
>
>
Zdaj element ustvarjalec ustreza imenskemu prostoru dc ki kaže na http://purl.org/dc/elements/1.1/. Če poskusite natisniti ustvarjalce jezika z našo prejšnjo kodo, ne bo delovalo. Za branje imenskih prostorov elementov morate uporabiti enega od naslednjih pristopov.
Prvi pristop je uporaba imen URI neposredno v kodi pri dostopu do imenskega prostora elementov. Naslednji primer prikazuje, kako se to naredi:
$dc = $languages -> lang [ 1 ] - > otroci ( "http://purl.org/dc/elements/1.1/")
;
echo $dc -> ustvarjalec ;
Metoda otroci () prevzame imenski prostor in vrne podrejene elemente, ki se začnejo s predpono. Potrebuje dva argumenta, od katerih je prvi imenski prostor XML, drugi pa je izbirni argument, ki privzeto lažno. Če je drugi argument nastavljen na TRUE, bo imenski prostor obravnavan kot predpona. Če je FALSE, bo imenski prostor obravnavan kot imenski prostor URL-ja.
Drugi pristop je branje imen URI iz dokumenta in njihova uporaba pri dostopu do imenskega prostora elementov. To je dejansko boljši način za dostop do elementov, ker vam ni treba biti trdo kodiran za URI.
$namespaces = $languages -> getNamespaces (true) ;
$dc = $languages -> lang [ 1 ] -> otroci (($namespaces [ "dc" ] );
echo $dc -> ustvarjalec ;
Metoda GetNamespaces() vrne niz imen predpon in z njimi povezanih URI-jev. Sprejema dodaten parameter, ki je privzeto nastavljen lažno. Če ga nastavite kot prav, bo ta metoda vrnila imena, uporabljena v nadrejenih in podrejenih vozliščih. V nasprotnem primeru najde imenske prostore, ki se uporabljajo samo v nadrejenem vozlišču.
Zdaj lahko ponavljate seznam jezikov, kot je ta:
$languages = simplexml_load_file ("languages.xml" ) ;
$ns = $languages -> getNamespaces (true) ;
foreach ($languages -> lang kot $lang ) (
$dc = $lang -> otroci ($ns [ "dc" ] );
printf(
"
%s se je pojavil v %d in ga je ustvaril %s.
" ,$lang [ "ime"],
$lang -> prikazano,
$dc -> ustvarjalec
) ;
}
Praktični primer - Razčlenitev video kanala iz YouTuba
Oglejmo si primer, ki dobi vir RSS s kanala YouTube in prikaže povezave do vseh videoposnetkov iz njega. Če želite to narediti, se obrnite na naslednji naslov:
http://gdata.youtube.com/feeds/api/users/xxx/uploads
URL vrne seznam najnovejših videoposnetkov iz danega kanala v formatu XML. XML bomo razčlenili in za vsak video dobili naslednje informacije:
- Povezava do videa
- Miniaturno
- Ime
Začeli bomo z iskanjem in nalaganjem XML-ja:
$channel = "Ime_kanala" ;
$url = "http://gdata.youtube.com/feeds/api/users/". $kanal. "/uploads" ;
$xml = file_get_contents($url);
$feed = simplexml_load_string ($xml) ;
$ns = $feed -> getNameSpaces (true);
Če pogledate vir XML, lahko vidite, da je tam več elementov entiteta, od katerih vsaka shranjuje podrobne informacije o določenem videu iz kanala. Vendar uporabljamo samo sličice slik, URL videoposnetka in naslov. Ti trije elementi so potomci elementa skupina, ki je nato otrok vstop:
…
…
…
>
…
Samo pregledali bomo vse elemente vstop, in za vsakega od njih bomo izluščili potrebne informacije. Upoštevajte to igralec sličica in naslov so v imenskem prostoru medijev. Zato moramo nadaljevati kot v prejšnjem primeru. Imena dobimo iz dokumenta in uporabljamo imenski prostor pri dostopu do elementov.
foreach ($feed -> vnos kot $entry) (
$group = $entry -> children ($ns [ "media" ] ) ;
$group = $group -> group ;
$thumbnail_attrs = $group -> sličica [1] -> atributi ();
$image = $thumbnail_attrs [ "url" ] ;
$player = $group -> player -> attributes () ;
$link = $player [ "url" ] ;
$naslov = $skupina -> naslov ;
printf( "
$player, $image, $title);
}
Zaključek
Zdaj, ko veste, kako uporabljati SimpleXML Za razčlenjevanje podatkov XML lahko izboljšate svoje sposobnosti z razčlenjevanjem različnih virov XML z različnimi API-ji. Vendar je pomembno upoštevati, da SimpleXML prebere celoten DOM v pomnilnik, tako da vam lahko zmanjka pomnilnika, če razčlenjujete velik nabor podatkov. Če želite izvedeti več o SimpleXML, preberite dokumentacijo.
Če imate kakršna koli vprašanja, priporočamo uporabo našega
