Analýza dat XML. Analýza dat XML Vytvoření instance analyzátoru
Autor: Arseny Kapoulkine
Datum zveřejnění: 21. září 2012
Překlad: A. Panin
Datum překladu: 10. listopadu 2013
Úvod
XML je standardizovaný značkovací jazyk, který má sadu pravidel pro kódování hierarchicky strukturovaných dokumentů způsobem čitelným pro člověka. textový formát. Standard XML se rozšířil a používá se pro generování jak velmi kompaktních jednoduchých dokumentů (jako jsou požadavky SOAP), tak mnohagigabajtových dokumentů (využívaných projektem OpenStreetMap) se složitými datovými závislostmi (COLLADA). Ke zpracování dokumentů XML uživatelé obvykle vyžadují speciální knihovnu: musí implementovat analyzátor dokumentů XML, který převede dokument z textového dokumentu na interní reprezentaci. Standard XML je kompromisem, pokud jde o rychlost analýzy, uživatelskou čitelnost a složitost kódu při analýze – rychlý systém pro analýzu dokumentů XML proto může ovlivnit preferovanou volbu XML jako formátu pro ukládání aplikačních dat.
Tato kapitola popisuje různé techniky zaměřené na zlepšení výkonu popsaného systému analýzy a umožňující autorovi vyvinout extrémně produktivní systém analýzy pomocí programovacího jazyka C++: pugixml. Ačkoli byly tyto techniky použity pro systém analýzy dokumentů XML, většinu z nich lze aplikovat na systémy analýzy dokumentů jiných formátů nebo dokonce na zcela nesouvisející softwarové komponenty (například algoritmy správy paměti jsou široce používány v nesouvisejících systémech analýzy textové dokumenty oblasti).
Vzhledem k tomu, že existuje několik velmi odlišných přístupů k analýze dokumentů XML a systém analýzy musí provádět další kroky, o kterých ani ti, kdo mají zkušenosti s dokumenty XML, nevědí, je důležité nejprve popsat danou úlohu, než se pustíme do podrobností o podrobnostech implementace.
Modely systémů pro analýzu XML
Každý z různé modely Systémy pro analýzu dokumentů XML jsou v určitých situacích optimální a každý z těchto modelů má své vlastní parametry výkonu a spotřeby paměti. Nejpoužívanější jsou následující modely:
- Při použití systémů analýzy založených na SAX (Simple API for XML) uživatel obdrží na svém místě softwarová součást, který očekává datový tok dokumentu jako vstup a poskytuje několik funkcí zpětného volání, jako je „otevřený tag“, „zavřít tag“, „znak uvnitř tagu“. Systém analýzy využívá funkce zpětného volání při zpracování dat dokumentu. Kontext potřebný pro analýzu je omezen hloubkou stromu aktuálního prvku, což znamená výrazné snížení požadavků na paměť. Tento typ systému analýzy lze použít ke zpracování streamovaných dokumentů, když je najednou dostupná pouze část dokumentu.
- Pull parsování je podobné analýze založené na SAX, pokud jde o samotný proces – jeden prvek dokumentu je zpracováván najednou, ale způsob řízení procesu analýzy se mění: v systému analýzy založeném na SAX je proces analýzy řízen samotný systém pomocí funkcí zpětného volání, zatímco při analýze vytažení uživatel řídí proces analýzy pomocí objektu podobného iterátoru.
- Při použití systémů analýzy založené na DOM (Document Object Model) uživatel předá systému analýzy kompletní dokument ve formě vyrovnávací paměti nebo proudu textových dat, na základě kterých systém analýzy generuje v paměti reprezentaci celého objektu. strom prvků dokumentu, pomocí samostatných objektů pro každý konkrétní prvek popř XML atribut a také sadu platných operací (například „získat vše podřízené prvky Tento uzel používá knihovna pugxml.
Volba modelu parsovacího systému obvykle závisí na velikosti dokumentu a jeho struktuře. Protože pugixml analyzuje na základě modelu DOM, je účinný pro dokumenty, které:
- jsou tak malé, že se vejdou úplně do paměti,
- mají složitou strukturu s vazbami mezi uzly, které je potřeba procházet, popř
- vyžadují složité transformace dokumentů.
Architektonická řešení v pugixml
Během vývoje knihovny pugixml se velká část pozornosti soustředila na problém vytváření reprezentace DOM, protože ačkoli byly k dispozici rychlé a lehké systémy pro analýzu založené na SAX (jako Expat), všechny systémy pro analýzu XML založené na DOM byly k dispozici pro produkci. použití v době, kdy byl vytvořen pugixml (2006), nebyly příliš lehké nebo příliš rychlé. Na základě toho je hlavním cílem vývojového procesu puixml vytvořit velmi rychlou a odlehčenou knihovnu pro provádění manipulace s dokumenty XML na bázi DOM.
zveřejnění tohoto článku je povoleno pouze s odkazem na webovou stránku autora článku
V tomto článku ukážu příklad, jak analyzovat velký soubor XML. Pokud váš server (hosting) nezakazuje prodlužovat dobu běhu skriptu, pak můžete analyzovat XML soubor o hmotnosti alespoň gigabajtů, já osobně jsem analyzoval pouze soubory z ozónu o hmotnosti 450 megabajtů.
Při analýze velkých souborů XML nastávají dva problémy:
1. Nedostatek paměti.
2. Není dostatek vyhrazeného času pro spuštění skriptu.
Druhý problém s časem lze vyřešit, pokud to server nezakáže.
Ale problém s pamětí je těžké vyřešit, i když mluvíme o vašem vlastním serveru, pak přesun souborů o velikosti 500 MB není příliš snadný a jednoduše není možné zvětšit paměť na hostingu a VDS.
PHP má několik vestavěných možností zpracování XML - SimpleXML, DOM, SAX.
Všechny tyto možnosti jsou podrobně popsány v mnoha článcích s příklady, ale všechny příklady demonstrují práci s úplným dokumentem XML.
Zde je jeden příklad, ze kterého získáváme objekt XML soubor
Nyní můžete tento objekt zpracovat, ALE...
Jak vidíte, celý soubor XML je načten do paměti a poté je vše analyzováno do objektu.
To znamená, že všechna data přejdou do paměti a pokud není dostatek přidělené paměti, skript se zastaví.
Tato volba není vhodná pro zpracování velkých souborů, je třeba číst soubor řádek po řádku a zpracovávat tato data jeden po druhém.
V tomto případě se kontrola platnosti provádí také při zpracování dat, takže musíte mít možnost vrátit se zpět, například odstranit všechna data zadaná do databáze v případě neplatného souboru XML nebo provést dva průchody přes soubor, nejprve načíst pro platnost, poté přečíst pro zpracování dat.
Zde je teoretický příklad analýzy velkého souboru XML.
Tento skript čte jeden znak po druhém ze souboru, shromažďuje tato data do bloků a posílá je do XML parseru.
Tento přístup zcela řeší problém s pamětí a nezpůsobuje zatížení, ale v průběhu času problém zhoršuje. Jak se pokusit problém vyřešit v průběhu času, přečtěte si níže.
Funkce webi_xml ($file)
{
########
### datová funkce
{
tisk $data ;
}
############################################
{
tisk $jméno ;
print_r($attrs);
}
## funkce uzavírací značky
funkce endElement ($parser, $name)
{
tisk $jméno ;
}
############################################
($xml_parser, "data");
// otevřete soubor
$fp = fopen($soubor, "r");
$perviy_vxod = 1 ; $data = "" ;
{
$simvol = fgetc ($fp); $data .= $simvol ;
if($simvol != ">" ) (pokračovat;)
echo"
přestávka;
}
$data = "" ;
}
fclose($fp);
Webi_xml("1.xml");
?>
V tomto příkladu jsem vše vložil do jedné funkce webi_xml() a úplně dole vidíte její volání.
Samotný skript se skládá ze tří hlavních funkcí:
1. Funkce, která zachytí otevření značky startElement().
2. Funkce, která zachytí koncovou značku endElement().
3. A funkce příjmu dat data() .
Předpokládejme, že obsah souboru 1.xml je recept
<
title
>Jednoduchý chleba
<
ingredient amount
=
"3"
unit
=
"стакан"
>Mouka
<
ingredient amount
=
"0.25"
unit
=
"грамм"
>Droždí
<
ingredient amount
=
"1.5"
unit
=
"стакан"
>Teplá voda
<
ingredient amount
=
"1"
unit
=
"чайная ложка"
>Sůl
<
instructions
>
<
step
>
Všechny ingredience smícháme a důkladně prohněteme.
<
step
>
Přikryjeme utěrkou a necháme hodinu v teplé místnosti..
<
step
>
Znovu prohněteme,
dáme na plech a dáme do trouby.
<
step
>
Navštivte stránky webu
Vše spustíme voláním obecné funkce webi_xml ("1.xml" );
Dále se v této funkci spustí analyzátor a převede všechny názvy tagů na velká písmena, aby všechny tagy měly stejná velká a malá písmena.
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);
Nyní naznačíme, které funkce budou fungovat pro zachycení otevření tagu, uzavření a zpracování dat
xml_set_element_handler($xml_parser, "startElement", "endElement");
xml_set_character_data_handler($xml_parser, "data");
Následuje objev zadaný soubor, iteruje souborem jeden znak po druhém a každý znak je přidán do řetězcové proměnné, dokud není znak nalezen >
.
Pokud se jedná o úplně první přístup k souboru, bude po cestě odstraněno vše, co je na začátku souboru nepotřebné, vše, co předchází , to je značka, kterou by měl XML začínat.
Poprvé bude řetězcová proměnná obsahovat řetězec
A pošlete to do disassembleru
xml_parse ($xml_parser, $data, feof ($fp));
Po zpracování dat se proměnná řetězce resetuje a sběr dat do řetězce začne znovu a řetězec se vytvoří podruhé
Na třetí
Vezměte prosím na vědomí, že proměnná typu string je vždy tvořena z dokončené značky >
a není nutné posílat zloději například otevřený a uzavřený štítek s údaji
Pro tento handler je důležité obdržet celý nepřerušený tag, alespoň jeden otevřený tag a v dalším kroku uzavřený tag, nebo rovnou přijmout 1000 řádků souboru, to je jedno, hlavní je, že tag nerozbije se např
le>Obyčejný chléb
Tímto způsobem není možné odesílat data do handleru, protože tag je roztržený.
Můžete si vymyslet vlastní metodu odesílání dat do handleru, například shromáždit 1 megabajt dat a poslat je handleru pro zvýšení rychlosti, jen se ujistěte, že tagy jsou vždy vyplněny a data mohou být trhána
Můžete tedy posílat po částech, jak si přejete velký soubor psovodovi.
Nyní se podíváme, jak se tato data zpracovávají a jak je získat.
Začněme funkcí otevírání značek startElement ($parser, $name, $attrs)
Předpokládejme, že zpracování dosáhlo linky
<
ingredient amount
=
"3"
unit
=
"стакан"
>Mouka
Pak uvnitř funkce bude proměnná $jméno rovna přísada to znamená název otevřené značky (zatím nedošlo k uzavření značky).
I v tomto případě bude k dispozici pole atributů tohoto tagu $attrs, které bude obsahovat data množství = "3" a jednotka = "sklo".
Poté byla data z otevřeného tagu zpracována funkcí data ($parser, $data)
Proměnná $data bude obsahovat vše, co je mezi otevírací a uzavírací značkou, v našem případě se jedná o text Muka
A zpracování našeho řetězce funkcí končí endElement ($parser, $name)
Toto je název uzavřené značky, v našem případě se $name bude rovnat přísada
A poté se vše opět točilo v kruhu.
Výše uvedený příklad pouze demonstruje princip zpracování XML, ale pro reálnou aplikaci je potřeba jej upravit.
Obvykle musíte analyzovat velké XML, abyste mohli zadat data do databáze, a pro správné zpracování dat potřebujete vědět, ke které otevřené značce data patří, na jaké úrovni vnoření značek a které značky jsou otevřené ve výše uvedené hierarchii. S těmito informacemi můžete soubor bez problémů zpracovat správně.
Chcete-li to provést, musíte zavést několik globálních proměnných, které budou shromažďovat informace o otevřených značkách, vnoření a datech.
Zde je příklad, který můžete použít
Funkce webi_xml ($file)
{
globální $webi_depth ; // čítač sledování hloubky vnoření
$webi_depth = 0 ;
globální $webi_tag_open ; // bude obsahovat pole open in tento moment značky
$webi_tag_open = array();
globální $webi_data_temp ; // toto pole bude obsahovat data jedné značky
####################################################
### datová funkce
funkční data ($parser, $data)
{
globální $webi_depth ;
globální $webi_tag_open ;
globální $webi_data_temp ;
// přidá data do pole označující vnoření a aktuálně otevřenou značku
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ].= $data ;
}
############################################
####################################################
### funkce otevření značky
funkce startElement ($parser, $name, $attrs)
{
globální $webi_depth ;
globální $webi_tag_open ;
globální $webi_data_temp ;
// pokud úroveň vnoření již není nula, pak je jeden tag již otevřený
// a data z něj jsou již v poli, můžete je zpracovat
if ($webi_depth)
{
"
;
tisk "
"
;
print_r($webi_tag_open); // pole otevřených značek
tisk "
" ;
// po zpracování dat je smažte, abyste uvolnili paměť
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}
// nyní se otevře další značka a další zpracování proběhne v dalším kroku
$webi_depth++; // zvýšení vnořování
$webi_tag_open [ $webi_depth ]= $name ; // přidání otevřené značky do pole informací
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // nyní přidejte atributy značek
}
###############################################
#################################################
## funkce uzavírací značky
funkce endElement ($parser, $name) (
globální $webi_depth ;
globální $webi_tag_open ;
globální $webi_data_temp ;
// zde začíná zpracování dat, například přidání do databáze, uložení do souboru atd.
// $webi_tag_open obsahuje řetězec otevřených značek podle úrovně vnoření
// například $webi_tag_open[$webi_depth] obsahuje název otevřené značky, jejíž informace se právě zpracovávají
// $webi_depth úroveň vnoření značek
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] pole atributů značek
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] údaje značky
Tisk "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" ]);
tisk "
"
;
print_r($webi_tag_open);
tisk "
" ;
Unset($GLOBALS [ "webi_data_temp" ]); // po zpracování dat smažeme celé pole s daty, protože tag byl uzavřen
unset($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // smazat informace o této otevřené značce... protože byla uzavřena
$webi_depth --; // snížení vnořování
}
############################################
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);
// označte, které funkce budou fungovat při otevírání a zavírání značek
xml_set_element_handler($xml_parser, "startElement", "endElement");
// specifikuje funkci pro práci s daty
xml_set_character_data_handler($xml_parser, "data");
// otevřete soubor
$fp = fopen($soubor, "r");
$perviy_vxod = 1 ; // příznak pro kontrolu prvního záznamu v souboru
$data = "" ; // zde sbíráme data ze souboru po částech a posíláme je do xml parseru
// smyčka, dokud není nalezen konec souboru
zatímco (! feof ($fp) a $fp)
{
$simvol = fgetc ($fp); // přečte jeden znak ze souboru
$data .= $simvol ; // přidat tento znak k datům, která mají být odeslána
// pokud znak není koncová značka, pak se vraťte na začátek smyčky a přidejte další znak k datům a tak dále, dokud nenajdete koncovou značku
if($simvol != ">" ) (pokračovat;)
// pokud byla nalezena uzavírací značka, nyní odešleme tato shromážděná data ke zpracování
// zkontrolujeme, zda se jedná o první záznam do souboru, poté smažeme vše, co je před tagem// protože někdy se můžete setkat s odpadky před začátkem XML (nemotorné editory nebo soubor byl přijat skriptem z jiného serveru)
if($perviy_vxod ) ( $data = strstr ($data , "
// nyní hodí data do xml analyzátoru
if (! xml_parse ($xml_parser, $data, feof ($fp))) (
// zde můžete zpracovávat a přijímat chyby platnosti...
// jakmile dojde k chybě, analýza se zastaví
echo"
Chyba XML: " . xml_error_string(xml_get_error_code($xml_parser));
echo "na řádku" . xml_get_current_line_number ($xml_parser);
přestávka;
}
// po analýze zahodí shromážděná data pro další krok cyklu.
$data = "" ;
}
fclose($fp);
xml_parser_free($xml_parser);
// odstranění globálních proměnných
unset($GLOBALS [ "webi_depth" ]);
unset($GLOBALS [ "webi_tag_open" ]);
unset($GLOBALS [ "webi_data_temp" ]);
Webi_xml("1.xml");
?>
Celý příklad je doplněn komentáři, nyní testujte a experimentujte.
Vezměte prosím na vědomí, že ve funkci práce s daty se data jednoduše nevkládají do pole, ale přidávají se pomocí " .="
protože data nemusí dorazit celá, a pokud jen zadáte úkol, čas od času obdržíte data po částech.
To je vše, nyní je dostatek paměti při zpracování souboru jakékoli velikosti, ale dobu běhu skriptu lze prodloužit několika způsoby.
Vložte funkci na začátek skriptu
set_time_limit(6000);
nebo
ini_set ("max_execution_time" , "6000" );
Nebo přidejte text do souboru .htaccess
php_value max_execution_time 6000
Tyto příklady zvýší dobu běhu skriptu na 6000 sekund.
Tímto způsobem můžete prodloužit čas pouze při vypnutém nouzovém režimu.
Pokud máte přístup k úpravám php.ini, můžete prodloužit čas používání
max_execution_time = 6000
Například na hostingu Masterhost je v době psaní tohoto článku zakázáno prodlužování doby skriptování bezpečný režim, ale pokud jste profík, můžete si vytvořit svůj vlastní php build na masterhost, ale to není v tomto článku.
Analýza XML v podstatě znamená procházení dokumentu XML a vrácení odpovídajících dat. A přestože stále větší počet webových služeb vrací data do formát JSON ale většina stále používá XML, takže pokud chcete používat celý rozsah, je důležité ovládat analýzu XML dostupná rozhraní API.
Pomocí rozšíření SimpleXML v PHP, které bylo přidáno zpět v PHP 5.0, je práce s XML velmi snadná a jednoduchá. V tomto článku vám ukážu, jak na to.
Základy použití
Začněme následujícím příkladem jazyky.xml:
>
>
>
>
Tento dokument XML obsahuje seznam programovacích jazyků s několika informacemi o každém jazyce: rok jeho zavedení a jméno jeho tvůrce.
Prvním krokem je načtení XML buď pomocí funkcí simplexml_load_file() nebo simplexml_load_string(). Jak název funkcí napovídá, první načte XML ze souboru a druhá načte XML z řetězce.
Obě funkce načtou celý strom DOM do paměti a vrátí objekt SimpleXMLElement. Ve výše uvedeném příkladu je objekt uložen v proměnné $languages . Můžete používat funkce var_dump() nebo print_r() chcete-li získat podrobnosti o vráceném objektu.
Objekt SimpleXMLElement
[lang] => Pole
[ 0 ] => Objekt SimpleXMLElement
[@attributes] => Pole
[jméno] => C
[objevilo se] => 1972
[tvůrce] => Dennis Ritchie
[ 1 ] => Objekt SimpleXMLElement
[@attributes] => Pole
[jméno] => PHP
[objevilo se] => 1995
[tvůrce] => Rasmus Lerdorf
[ 2 ] => Objekt SimpleXMLElement
[@attributes] => Pole
[jméno] => Java
[objevilo se] => 1995
[tvůrce] => James Gosling
)
)
Tento XML obsahuje kořenový element jazyky, uvnitř kterého jsou tři prvky lang. Každý prvek pole odpovídá prvku lang v dokumentu XML.
K vlastnostem objektu můžete přistupovat pomocí operátoru -> . Například $languages->lang vám vrátí objekt SimpleXMLElement, který odpovídá prvnímu prvku lang. Tento objekt obsahuje dvě vlastnosti: objevil a tvůrce.
$languages -> lang [ 0 ] -> objevil se ;
$languages -> lang [ 0 ] -> tvůrce ;
Zobrazení seznamu jazyků a zobrazení jejich vlastností lze velmi snadno provést pomocí standardní smyčky jako např pro každého.
foreach ($languages -> lang jako $lang ) (
printf(
""
,
$lang [ "jméno" ] ,
$lang -> objevil se ,
$lang -> tvůrce
)
;
}
Všimněte si, jak jsem přistupoval k názvu atributu lang prvku, abych získal název jazyka. Tímto způsobem můžete přistupovat k libovolnému atributu prvku reprezentovaného jako objekt SimpleXMLElement.
Práce s jmennými prostory
Při práci s XML různých webových služeb se nejednou setkáte se jmennými prostory prvků. Pojďme změnit naše jazyky.xml ukázat příklad použití jmenného prostoru:
xmlns:dc =>
>
>
>
>
Nyní prvek tvůrce zapadá do jmenného prostoru DC který odkazuje na http://purl.org/dc/elements/1.1/. Pokud se pokusíte vytisknout tvůrce jazyka pomocí našeho předchozího kódu, nebude to fungovat. Abyste mohli číst jmenné prostory prvků, musíte použít jeden z následujících přístupů.
První přístup spočívá v použití názvů URI přímo v kódu při přístupu k jmennému prostoru prvků. Následující příklad ukazuje, jak se to dělá:
$dc = $languages -> jazyk [ 1 ] - > děti( "http://purl.org/dc/elements/1.1/")
;
echo $dc -> tvůrce ;
Metoda děti() vezme jmenný prostor a vrátí podřízené prvky, které začínají prefixem. Vyžaduje dva argumenty, z nichž první je jmenný prostor XML a druhý je volitelný argument, který je výchozí Nepravdivé. Pokud je druhý argument nastaven na hodnotu TRUE, bude se jmenný prostor považovat za prefix. Pokud je NEPRAVDA, pak se jmenný prostor bude považovat za jmenný prostor URL.
Druhým přístupem je číst názvy URI z dokumentu a používat je při přístupu k jmennému prostoru prvků. Toto je ve skutečnosti lepší způsob přístupu k prvkům, protože nemusíte být pevně zakódováni do URI.
$namespaces = $languages -> getNamespaces (true) ;
$dc = $languages -> lang [ 1 ] -> děti ( ($namespaces [ "dc" ] ) ;
echo $dc -> tvůrce ;
Metoda GetNamespaces() vrátí pole názvů předpon a jejich přiřazených URI. Přijímá další parametr, který je výchozí Nepravdivé. Pokud to nastavíte jako skutečný, pak tato metoda vrátí jména použitá v nadřazených a podřízených uzlech. Jinak najde jmenné prostory používané pouze v nadřazeném uzlu.
Nyní můžete iterovat seznam jazyků takto:
$languages = simplexml_load_file ("languages.xml" );
$ns = $languages -> getNamespaces (true) ;
foreach ($languages -> lang jako $lang ) (
$dc = $lang -> děti ($ns [ "dc" ] ) ;
printf(
"
%s se objevil v %d a byl vytvořen %s .
" ,$lang [ "jméno" ] ,
$lang -> objevil se ,
$dc -> tvůrce
) ;
}
Praktický příklad – Analýza videokanálu z YouTube
Podívejme se na příklad, který získává RSS kanál z kanálu YouTube a zobrazuje odkazy na všechna videa z něj. Chcete-li to provést, kontaktujte následující adresu:
http://gdata.youtube.com/feeds/api/users/xxx/uploads
Adresa URL vrátí seznam nejnovějších videí z daného kanálu ve formátu XML. Zanalyzujeme XML a pro každé video získáme následující informace:
- Odkaz na video
- Miniaturní
- název
Začneme vyhledáním a načtením XML:
$kanál = "Název_kanálu" ;
$url = "http://gdata.youtube.com/feeds/api/users/". $kanál. "/uploads" ;
$xml = file_get_contents($url);
$feed = simplexml_load_string ($xml) ;
$ns = $feed -> getNameSpaces ( true ) ;
Když se podíváte na XML feed, můžete vidět, že tam je několik prvků entita, z nichž každý obchoduje detailní informace o konkrétním videu z kanálu. Ale používáme pouze miniatury obrázků, URL videa a název. Tyto tři prvky jsou potomky prvku skupina, která je zase dítětem vstup:
…
…
…
>
…
Prostě projdeme všechny prvky vstup a pro každou z nich vytáhneme potřebné informace. Všimněte si, že hráč miniatura A titul jsou ve jmenném prostoru médií. Musíme tedy postupovat stejně jako v předchozím příkladu. Názvy získáváme z dokumentu a jmenný prostor používáme při přístupu k prvkům.
foreach ($feed -> záznam jako $entry ) (
$group = $entry -> children ($ns [ "media" ] ) ;
$skupina = $skupina -> skupina ;
$thumbnail_attrs = $skupina -> miniatura [ 1 ] -> atributy () ;
$image = $thumbnail_attrs [ "url" ] ;
$player = $group -> player -> atributy () ;
$link = $player [ "url" ] ;
$titul = $skupina -> nadpis ;
printf( "
$player, $image, $title);
}
Závěr
Nyní, když víte, jak používat SimpleXML Při analýze dat XML můžete zlepšit své dovednosti analýzou různých zdrojů XML pomocí různých rozhraní API. Je však důležité vzít v úvahu, že SimpleXML načte celý DOM do paměti, takže pokud analyzujete velkou sadu dat, může vám dojít paměť. Chcete-li se dozvědět více o SimpleXML, přečtěte si dokumentaci.
Pokud máte nějaké dotazy, doporučujeme použít náš
