sushiandbox.ru A számítógép elsajátítása - Internet. Skype. Közösségi média. Windows leckék.
Ebben az oktatóanyagban néhány példa XML karakterláncot tartalmaz. Ahelyett, hogy minden példában megismételné, helyezze ezt a sort egy fájlba, amelyet minden példában szerepel. Ez a vonal látható a következő példában. Ezenkívül XML-dokumentumot is létrehozhat, és a funkcióval elolvashatja simplexml_load_file().
1. példa Példa.php fájl XML karakterlánccal
$xmlstr =<<
ez egy script nyelv? Minden kiderül ebből a dokumentumfilmből,
mint egy horrorfilmben.
XML;
?>
A SimpleXML használata nagyon egyszerű! Próbáljon ki egy karakterláncot vagy számot az alapul szolgáló XML-dokumentumból.
2. példa Dokumentum egy részének lekérése
tartalmazza "example.php" ;
echo $filmek -> film [ 0 ]-> cselekmény ;
?>
Tehát ez egy nyelv. Ez még mindig egy programozási nyelv. Vagy ez egy script nyelv? Minden kiderül ebben a horrorfilmszerű dokumentumfilmben.
PHP-ben egy olyan elemhez férhet hozzá egy XML-dokumentumban, amely illegális karaktereket (például kötőjelet) tartalmaz a nevében, ha az elem nevét kapcsos zárójelek és aposztrófok közé helyezi.
3. példa Karakterlánc beszerzése
tartalmazza "example.php" ;
echo $filmek -> film ->( "nagyvonalak" )-> sor ;
?>
A példa futtatásának eredménye:
A PHP minden webes problémámat megoldja
4. példa Nem egyedi elemek elérése a SimpleXML-ben
Ha ugyanazon a szülőelemen belül több gyermekelem példány is található, akkor szabványos iterációs módszereket kell használni.
tartalmazza "example.php" ;
$filmek = új SimpleXMLElement ($xmlstr );
/* Minden csomóponthoz
foreach ($filmek -> film -> karakterek -> karakter mint $karakter ) (
echo $karakter -> név, "játszik", $karakter -> színész, PHP_EOL;
}
?>
A példa futtatásának eredménye:
Kisasszony. Kódoló játssza Onlivia Actora Mr. Coder játssza El Actort
Megjegyzés:
Tulajdonságok ( $filmek->film az előző példában) nem tömbök. Ez egy iterálható objektum tömb formájában.
5. példa Attribútumok használata
Eddig csak az elemek neveit és értékeit kértük le. A SimpleXML hozzáférhet az elemattribútumokhoz is. Az elemek attribútumait ugyanúgy érheti el, mint a tömbelemeket ( sor).
tartalmazza "example.php" ;
$filmek = új SimpleXMLElement ($xmlstr );
/* Hozzáférési csomópont
* Egy értékelési skálát is megjelenítünk. */
foreach ($filmek -> film [ 0 ]-> $rating minősítés) (
switch((karakterlánc) $értékelés [ "típus" ]) ( // Elemattribútumok lekérése index szerint
"hüvelykujj" eset:
echo $rating , "tetszik" ;
szünet;
"csillagok" eset:
echo $értékelés, "csillagok";
szünet;
}
}
?>
A példa futtatásának eredménye:
7 remek 5 csillag
6. példa Elemek és attribútumok összehasonlítása szöveggel
Ha egy elemet vagy attribútumot szeretne összehasonlítani egy karakterlánccal, vagy szövegként szeretné átadni egy függvénynek, át kell adnia egy karakterláncba a (húr). Ellenkező esetben a PHP objektumként kezeli az elemet.
tartalmazza "example.php" ;
$filmek = új SimpleXMLElement ($xmlstr );
if ((karakterlánc) $filmek -> film -> cím == "PHP: Az elemző megjelenése") {
nyomtatás – A kedvenc filmem.;
}
echo htmlentities ((karakterlánc) $filmek -> film -> cím );
?>
A példa futtatásának eredménye:
Kedvenc filmem.PHP: Emergence of the Parser
7. példa Két elem összehasonlítása
Két SimpleXMLElement akkor is különbözik, ha ugyanarra az objektumra mutat, mint a PHP 5.2.0-ban.
tartalmazza "example.php" ;
$filmek1 = új SimpleXMLElement ($xmlstr );
$filmek2 = új SimpleXMLElement ($xmlstr );
var_dump($filmek1 == $filmek2); // hamis a PHP 5.2.0 óta
?>
A példa futtatásának eredménye:
8. példa XPath használatával
A SimpleXML beépített XPath támogatást tartalmaz. Keresés az összes elemben
tartalmazza "example.php" ;
$filmek = új SimpleXMLElement ($xmlstr );
foreach ($movies -> xpath ("//karakter") mint $karakter ) (
echo $karakter -> név, "játszik", $karakter -> színész, PHP_EOL;
}
?>
"// " helyettesítő karakterként szolgál. Abszolút elérési út megadásához hagyja ki az egyik perjelet.
A példa futtatásának eredménye:
Kisasszony. Kódoló játssza Onlivia Actora Mr. El Actor kódolójátékai
9. példa Értékek beállítása
A SimpleXML-ben lévő adatoknak nem kell megváltoztathatatlannak lenniük. Az objektum lehetővé teszi az összes elem kezelését.
tartalmazza "example.php" ;
$filmek = új SimpleXMLElement ($xmlstr );
$filmek -> film [ 0 ]-> karakterek -> karakter [ 0 ]-> név = "Kódoló kisasszony" ;
echo $filmek -> asXML();
?>
A példa futtatásának eredménye:
10. példa Elemek és attribútumok hozzáadása
A PHP 5.1.3 óta a SimpleXML képes könnyen hozzáadni gyermekelemeket és attribútumokat.
tartalmazza "example.php" ;
$filmek = új SimpleXMLElement ($xmlstr );
$karakter = $filmek -> film [ 0 ]-> karakterek -> addChild ("karakter" );
$karakter -> addChild ( "név" , "Mr. Elemző" );
$karakter -> addChild ("színész" , "John Doe" );
$rating = $filmek -> film [ 0 ]-> addChild ( "értékelés" , "PG" );
$rating -> addAttribute ("type" , "mpaa" );
echo $filmek -> asXML();
?>
A példa futtatásának eredménye:
11. példa Interakció a DOM-mal
A PHP képes az XML csomópontokat SimpleXML-ből DOM formátumba konvertálni és fordítva. Ez a példa bemutatja, hogyan módosíthat egy DOM-elemet a SimpleXML-ben.
$dom = új DOMDokmány ;
$dom -> loadXML ( "
if (! $dom ) (
visszhang "Hiba a dokumentum elemzésekor";
kijárat;
}
$könyvek = simplexml_import_dom($dom);
echo $könyvek -> könyv [ 0 ]-> cím ;
?>
A példa futtatásának eredménye:
4 évvel ezelőtt
Van egy gyakori „trükk”, amelyet gyakran javasolnak a SimpleXML-objektumok tömbbé alakítására, a json_encode()-n, majd a json_decode()-on keresztül futtatva. Szeretném elmagyarázni, hogy ez miért rossz ötlet.
A legegyszerűbben azért, mert a SimpleXML lényege, hogy könnyebben használható és erősebb, mint egy sima tömb. Például írhatszbar -> baz [ "bing" ] ?> és ugyanazt jelenti, mintbar [ 0 ]-> baz [ 0 ][ "bing" ] ?> , függetlenül attól, hogy hány bar vagy baz elem van az XML-ben; és ha írszbar [ 0 ]-> baz [ 0 ] ?> az adott csomópont összes string tartalmát megkapja - beleértve a CDATA szakaszokat is - függetlenül attól, hogy vannak-e gyermekelemei vagy attribútumai is. Hozzáférhet a névtér-információkhoz, egyszerű szerkesztéseket végezhet az XML-ben, és még DOM-objektumba is "importálhat" a sokkal hatékonyabb manipuláció érdekében. Mindez elveszik, ha az objektumot tömbbé alakítjuk, ahelyett, hogy elolvasnánk az ezen az oldalon található példákat.
Ezen túlmenően, mivel nem erre a célra tervezték, a JSON-ra és vissza átalakítás bizonyos helyzetekben ténylegesen elveszíti az adatokat. Például a névtérben lévő elemek vagy attribútumok egyszerűen el lesznek vetve, és minden szöveges tartalom el lesz vetve, ha egy elemnek gyermekei vagy attribútumai is vannak. Néha ez nem számít, de ha megszokja, hogy mindent tömbökké konvertáljon, az előbb-utóbb csípni fog.
Természetesen írhatna egy intelligensebb konverziót is, aminek nem voltak ilyen korlátai, de ezen a ponton a SimpleXML-ből egyáltalán nem kapunk értéket, és csak az alacsonyabb szintű XML Parser függvényeket vagy az XMLReader osztályt kell használni. A SimpleXML extra kényelmi funkciói továbbra sem lesznek elérhetőek, de ez az Ön vesztesége.
2 évvel ezelőtt
Ha az xml-karakterlánc "0"-val és "1-gyel" kódolt logikai értékeket tartalmaz, akkor problémákba ütközik, amikor az elemet közvetlenül a bool-ba önti:
$xmlstr =<<
XML;
$értékek = new SimpleXMLElement($xmlstr);
$igazérték = (bool)$értékek->igazérték; // igaz
$falsevalue = (bool)$értékek->falsevalue; // is igaz!!!
Ehelyett először karakterláncra vagy intre kell átküldenie:
$igazérték = (bool)(int)$értékek->igazérték; // igaz
$falsevalue = (bool)(int)$értékek->falsevalue; // hamis
9 évvel ezelőtt
Ha a válaszában érvényes xml-t kell kiadnia, ne felejtse el beállítani a fejléctartalom típusát xml-re az asXML() eredményének visszajelzése mellett:
$xml = simplexml_load_file("...");
...
... xml cucc
...
//Xml-t ír ki a válaszában:
header("Tartalomtípus: szöveg/xml");
echo $xml -> asXML();
?>
9 évvel ezelőtt
A README fájlból:
A SimpleXML célja az XML adatok egyszerű elérésének módja.
A SimpleXML objektumok négy alapvető szabályt követnek:
1) a tulajdonságok elemiterátorokat jelölnek
2) a numerikus indexek elemeket jelölnek
3) a nem numerikus indexek attribútumokat jelölnek
4) A karakterlánc-konverzió lehetővé teszi a SZÖVEG adatok elérését
A tulajdonságok iterálásakor a kiterjesztés mindig ismétlődik
minden ilyen elemnévvel rendelkező csomópont. Így a children() metódusnak kell lennie
alcsomópontok feletti iterációra hívják. De a következőket is megteszi:
foreach ($obj->node_name mint $elem) (
// csinálj valamit a $elemmel
}
mindig a "node_name" elemek iterációját eredményezi. Szóval ne tovább
ellenőrzés szükséges az adott típusú csomópontok számának megkülönböztetéséhez.
Amikor egy elemhez SZÖVEG adatok érhetők el egy tulajdonságon keresztül
akkor az eredmény nem tartalmazza a részelemek SZÖVEG adatait.
Ismert problémák
============
Motorproblémák miatt jelenleg nem lehet hozzáférni
egy részelem 0 index szerint: $object->property.
8 évvel ezelőtt
Az olyan dolgok használata, mint például: is_object($xml->module->admin) annak ellenőrzésére, hogy valóban létezik-e "admin" nevű csomópont, nem úgy tűnik, hogy a várt módon működik, mivel a simplexml mindig egy objektumot ad vissza - ebben az esetben egy üreset. - még akkor is, ha egy adott csomópont nem létezik.
Számomra a jó öreg üres() függvény jól működik ilyen esetekben.
8 évvel ezelőtt
Egy gyors tipp az xpath lekérdezésekhez és az alapértelmezett névterekhez. Úgy tűnik, hogy a SimpleXML mögött meghúzódó XML-rendszer ugyanúgy működik, mint ahogyan azt gondolom, hogy a .NET XML-rendszere: amikor az alapértelmezett névtérben kell valamit megcímezni, deklarálnia kell a névteret a registerXPathNamespace használatával, majd az előtagot kell használnia címezze meg az egyébként az alapértelmezett névtér élő elemét.
$karakterlánc =<<
Tudom, hogy ez a válasz – de mi a kérdés?
XML;
$xml = simplexml_load_string ($string);
$xml -> registerXPathNamespace("def", "http://www.w3.org/2005/Atom");
$csomópontok = $xml -> xpath ("//def:dokumentum/def:cím" );
?>
9 évvel ezelőtt
Bár a SimpleXMLElement azt állítja, hogy iterálható, úgy tűnik, hogy nem valósítja meg megfelelően a szabványos Iterator interfész funkciókat, mint például::next és::reset. Ezért míg a foreach() működik, az olyan függvények, mint a next(), a current() vagy az Each() nem úgy tűnik, hogy úgy működnek, ahogy elvárnád – a mutató soha nem mozdul, vagy folyamatosan visszaáll.
6 évvel ezelőtt
Ha az XML-dokumentum kódolása nem UTF-8, a kódolási deklarációnak közvetlenül a version="..." és a standalone="..." előtt kell megjelennie. Ez az XML szabvány követelménye.
Ha az XML-dokumentum kódolása eltér az UTF-8-tól. A kódolási deklarációnak közvetlenül a version = "..." és a standalone = "..." előtt kell következnie. Ez a követelmény szabványos XML.
Rendben
Végzetes hiba: „Kivétel” el nem fogott kivétel „A karakterlánc nem értelmezhető XML-ként” üzenettel a következőben:
a cikk közzététele csak a cikk szerzőjének webhelyére mutató hivatkozással engedélyezett
Ebben a cikkben egy példát mutatok be egy nagy XML-fájl elemzésére. Ha a kiszolgáló (hoszting) nem tiltja a szkript futási idejének növelését, akkor legalább gigabájt súlyú XML-fájlt is elemezhet, én személy szerint csak 450 megabájtos ózonból elemeztem a fájlokat.
A nagy XML-fájlok elemzésekor két probléma merül fel:
1. Nincs elég memória.
2. Nincs elegendő idő a szkript futtatásához.
A második idővel kapcsolatos probléma megoldható, ha a szerver nem tiltja.
De a memória problémáját nehéz megoldani, még akkor is, ha a saját szerveréről beszélünk, akkor az 500 megabájtos fájlok mozgatása nem túl egyszerű, és egyszerűen nem lehet növelni a memóriát a tárhelyen és a VDS-en.
A PHP számos beépített XML feldolgozási opcióval rendelkezik - SimpleXML, DOM, SAX.
Mindezeket a lehetőségeket számos cikk részletesen leírja példákkal, de minden példa bemutatja a teljes XML-dokumentummal való munkát.
Íme egy példa egy objektum XML-fájlból való lekérésére
Most már feldolgozhatja ezt az objektumot, DE...
Amint láthatja, a teljes XML-fájlt a rendszer beolvassa a memóriába, majd mindent egy objektummá értelmez.
Ez azt jelenti, hogy minden adat a memóriába kerül, és ha nincs elég memória, a szkript leáll.
Ez az opció nem alkalmas nagy fájlok feldolgozására, soronként kell elolvasni a fájlokat, és ezeket az adatokat egyenként kell feldolgozni.
Ebben az esetben az adatok feldolgozása során az érvényesség ellenőrzése is megtörténik, így képesnek kell lennie a visszaállításra, például érvénytelen XML fájl esetén törölni kell az adatbázisba bevitt összes adatot, vagy két lépést kell végrehajtani. a fájlon keresztül, először olvassa el az érvényességet, majd olvassa el az adatok feldolgozásához.
Itt van egy elméleti példa egy nagy XML-fájl elemzésére.
Ez a szkript egy-egy karaktert olvas be egy fájlból, ezeket az adatokat blokkokba gyűjti és elküldi az XML elemzőnek.
Ez a megközelítés teljesen megoldja a memóriaproblémát, és nem okoz terhelést, de idővel súlyosbítja a problémát. Az alábbiakban olvashat arról, hogyan próbálja meg megoldani a problémát idővel.
Webi_xml függvény ($file)
{
########
### adatfüggvény
{
nyomtatás $adatok ;
}
############################################
{
nyomtatás $név ;
print_r($attrs);
}
## záró tag funkció
függvény endElement ($elemző, $név)
{
nyomtatás $név ;
}
############################################
($xml_parser, "adat");
// nyissa meg a fájlt
$fp = fopen($file, "r");
$perviy_vxod = 1 ; $adat = "" ;
{
$simvol = fgetc ($fp); $adat .= $simvol ;
if($simvol != ">" ) ( folytatás;)
visszhang"
szünet;
}
$adat = "" ;
}
fclose($fp);
Webi_xml("1.xml");
?>
Ebben a példában mindent egy webi_xml() függvénybe raktam, és a legalul láthatod a hívását.
Maga a szkript három fő funkcióból áll:
1. Egy függvény, amely elkapja a startElement() címke nyitását
2. Egy függvény, amely elkapja a záró endElement() címkét
3. És az adatokat fogadó függvény data() .
Tegyük fel, hogy az 1.xml fájl tartalma egy recept
<
title
>Egyszerű kenyér
<
ingredient amount
=
"3"
unit
=
"стакан"
>Liszt
<
ingredient amount
=
"0.25"
unit
=
"грамм"
>Élesztő
<
ingredient amount
=
"1.5"
unit
=
"стакан"
>Meleg víz
<
ingredient amount
=
"1"
unit
=
"чайная ложка"
>Só
<
instructions
>
<
step
>
Az összes hozzávalót összekeverjük és alaposan összegyúrjuk.
<
step
>
Fedjük le egy ruhával, és hagyjuk egy órán át meleg szobában..
<
step
>
Ismét összegyúrjuk,
tepsire tesszük és betesszük a sütőbe.
<
step
>
Látogassa meg a webhely webhelyét
Mindent a webi_xml ("1.xml" ) általános függvény meghívásával kezdünk;
Ezután az elemző elindul ebben a függvényben, és az összes címkenevet nagybetűssé alakítja, így minden címkének ugyanaz a kis- és nagybetűje.
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);
Most jelezzük, hogy mely funkciók fognak működni a címke megnyitásának, bezárásának és adatfeldolgozásának elfogására
xml_set_element_handler($xml_parser, "startElement", "endElement");
xml_set_character_data_handler($xml_parser, "adat");
Következik a megadott fájl megnyitása, egy karakterenként iterálva a fájlt, és minden karakter hozzáadódik a karakterlánc változóhoz, amíg meg nem találja a karaktert >
.
Ha ez a legelső hozzáférés a fájlhoz, akkor útközben minden, ami a fájl elején felesleges, törlődik, minden, ami előtte van. , ezzel a címkével kell kezdődnie az XML-nek.
Első alkalommal a karakterlánc-változó tartalmazni fog egy karakterláncot
És küldje el a szétszerelőnek
xml_parse ($xml_parser, $data, feof ($fp));
Az adatok feldolgozása után a karakterlánc-változó alaphelyzetbe áll, és az adatok sztringbe gyűjtése újra kezdődik és a karakterlánc másodszor jön létre
A harmadikon
Kérjük, vegye figyelembe, hogy egy karakterlánc-változó mindig egy befejezett címkéből jön létre >
és nem szükséges a betörőnek például nyitott és zárt címkét küldeni adatokkal
Ennek a kezelőnek fontos, hogy egy egész bontatlan címkét kapjon, legalább egy nyitott címkét, és a következő lépésben egy zárt címkét, vagy azonnal kapjon 1000 sornyi fájlt, mindegy, a lényeg, hogy a címke nem törik például
le> Sima kenyér
Így nem lehet adatot küldeni a kezelőnek, mivel a címke elszakad.
Ki lehet találni egy saját módszert a kezelőnek való adatküldésre, például összegyűjthetsz 1 megabájt adatot és elküldheted a kezelőnek, hogy növeld a sebességet, csak ügyelj arra, hogy a címkék mindig kitöltve legyenek, és az adatok eltéphetők legyenek.
Így tetszőleges részekben küldhet egy nagy fájlt a processzornak.
Most pedig nézzük meg, hogyan dolgozzák fel ezeket az adatokat, és hogyan szerezhetők be.
Kezdjük a nyitó címkék funkcióval startElement ($elemző, $név, $attrs)
Tegyük fel, hogy a feldolgozás elérte a sort
<
ingredient amount
=
"3"
unit
=
"стакан"
>Liszt
Ekkor a függvényen belül a $name változó egyenlő lesz hozzávaló vagyis a nyitott címke neve (még nem zárta be a címkét).
Ebben az esetben is elérhető lesz a $attrs címke attribútumainak tömbje, amely adatokat fog tartalmazni mennyiség = "3" és egység = "üveg".
Ezt követően a függvény feldolgozta a nyitott címke adatait adatok ($parser, $data)
A $data változó mindent tartalmazni fog, ami a nyitó és záró címke között van, esetünkben ez a Muka szöveg
És a karakterláncunk függvény általi feldolgozása véget ér endElement ($elemző, $név)
Ez a zárt címke neve, esetünkben a $name egyenlő lesz hozzávaló
Utána pedig újra körbefutott minden.
A fenti példa csak az XML feldolgozás elvét mutatja be, de a valós alkalmazáshoz módosítani kell.
Általában nagyméretű XML-t kell elemezni, hogy adatokat vigyünk be az adatbázisba, és az adatok megfelelő feldolgozásához tudnia kell, hogy melyik nyitott címkéhez tartoznak az adatok, milyen szintű címkebeágyazás és mely címkék vannak nyitva a fenti hierarchiában. Ezen információk birtokában probléma nélkül tudja megfelelően feldolgozni a fájlt.
Ehhez több globális változót kell bevezetnie, amelyek információkat gyűjtenek a nyitott címkékről, a beágyazásról és az adatokról.
Íme egy példa, amelyet használhat
Webi_xml függvény ($file)
{
globális $webi_depth ; // számláló a beágyazási mélység nyomon követéséhez
$webi_mélység = 0 ;
globális $webi_tag_open ; // jelenleg megnyitott címkék tömbjét fogja tartalmazni
$webi_tag_open = array();
globális $webi_data_temp ; // ez a tömb egy címke adatait fogja tartalmazni
####################################################
### adatfüggvény
függvényadatok ($parser, $data)
{
globális $webi_depth ;
globális $webi_tag_open ;
globális $webi_data_temp ;
// adatok hozzáadása a tömbhöz, amely jelzi a beágyazást és az aktuálisan nyitott címkét
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ].= $adat ;
}
############################################
####################################################
### nyitó címke funkció
függvény startElement ($elemző, $név, $attrs)
{
globális $webi_depth ;
globális $webi_tag_open ;
globális $webi_data_temp ;
// ha a beágyazási szint már nem nulla, akkor egy címke már nyitva van
// és az abból származó adatok már a tömbben vannak, akkor feldolgozhatod
ha ($webi_depth)
{
"
;
nyomtatás"
"
;
print_r($webi_tag_open); // nyitott címkék tömbje
nyomtatás"
" ;
// az adatok feldolgozása után a memória felszabadítása érdekében törölje azokat
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}
// most a következő címke nyílik meg, és a további feldolgozás a következő lépésben történik
$webi_depth++; // fészkelődés növelése
$webi_tag_open [ $webi_depth ]= $név ; // nyitott tag hozzáadása az információs tömbhöz
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // most adjunk hozzá címkeattribútumokat
}
###############################################
#################################################
## záró tag funkció
függvény endElement ($elemző, $név) (
globális $webi_depth ;
globális $webi_tag_open ;
globális $webi_data_temp ;
// itt kezdődik az adatfeldolgozás, például az adatbázisba való felvétel, fájlba mentés stb.
// A $webi_tag_open nyitott címkék láncát tartalmazza beágyazási szint szerint
// például a $webi_tag_open[$webi_depth] tartalmazza annak a nyitott tagnek a nevét, amelynek információi jelenleg feldolgozás alatt állnak
// $webi_depth címke beágyazási szintje
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] címkeattribútumok tömbje
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] címkeadatok
"Adatok" nyomtatása. $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" ]);
nyomtatás"
"
;
print_r($webi_tag_open);
nyomtatás"
" ;
Unset($GLOBALS [ "webi_data_temp" ]); // az adatok feldolgozása után töröljük a teljes tömböt az adatokkal, mivel a tag bezárva volt
unset($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // információ törlése erről a nyitott címkéről... mivel bezárta
$webi_depth --; // csökkenti a beágyazást
}
############################################
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);
// jelzi, hogy mely funkciók működnek a címkék megnyitásakor és bezárásakor
xml_set_element_handler($xml_parser, "startElement", "endElement");
// függvény megadása az adatokkal való munkavégzéshez
xml_set_character_data_handler($xml_parser, "adat");
// nyissa meg a fájlt
$fp = fopen($file, "r");
$perviy_vxod = 1 ; // jelölőnégyzet a fájl első bejegyzésének ellenőrzéséhez
$adat = "" ; // itt részletekben gyűjtjük az adatokat a fájlból és elküldjük az xml elemzőnek
// ciklus, amíg meg nem találja a fájl végét
míg (! feof ($fp ) és $fp )
{
$simvol = fgetc ($fp); // beolvasott egy karaktert a fájlból
$adat .= $simvol ; // adjuk hozzá ezt a karaktert a küldendő adatokhoz
// ha a karakter nem a végcímke, akkor menjen vissza a ciklus elejére, és adjon hozzá egy másik karaktert az adatokhoz, és így tovább, amíg meg nem találja a végcímkét
if($simvol != ">" ) ( folytatás;)
// ha a záró címkét megtaláltuk, akkor ezt az összegyűjtött adatot elküldjük feldolgozásra
// ellenőrizze, hogy ez az első bejegyzés a fájlba, akkor mindent törölünk, ami a címke előtt van// mivel néha előfordulhat, hogy az XML kezdete előtt szeméttel találkozhat (ügyetlen szerkesztők, vagy a fájlt egy másik szerverről kapott szkript)
if($perviy_vxod ) ( $data = strstr ($data , "
// most dobd be az adatokat az xml elemzőbe
if (! xml_parse ($xml_parser, $data, feof ($fp))) (
// itt tudod feldolgozni és fogadni az érvényességi hibákat...
// amint hiba történik, az elemzés leáll
visszhang"
XML-hiba: " . xml_error_string(xml_get_error_code($xml_parser));
visszhang "vonalnál" . xml_get_current_line_number ($xml_parser);
szünet;
}
// az elemzés után dobja el az összegyűjtött adatokat a ciklus következő lépéséhez.
$adat = "" ;
}
fclose($fp);
xml_parser_free($xml_parser);
// globális változók eltávolítása
unset($GLOBALS [ "webi_depth" ]);
unset($GLOBALS [ "webi_tag_open" ]);
unset($GLOBALS [ "webi_data_temp" ]);
Webi_xml("1.xml");
?>
Az egész példát megjegyzések kísérik, most tesztelje és kísérletezzen.
Kérjük, vegye figyelembe, hogy az adatokkal való munka során az adatok nem egyszerűen egy tömbbe kerülnek, hanem a " .="
mivel előfordulhat, hogy az adatok nem érkeznek meg teljes egészében, és ha csak megbízást adsz, akkor időről időre darabokban kapod meg az adatokat.
Nos, ez minden, most van elég memória bármilyen méretű fájl feldolgozásához, de a szkript futási ideje többféleképpen növelhető.
Szúrjon be egy függvényt a szkript elejére
set_time_limit(6000);
vagy
ini_set ("max_végrehajtási_idő" , "6000" );
Vagy adjon hozzá szöveget a .htaccess fájlhoz
php_value max_execution_time 6000
Ezek a példák a szkript futási idejét 6000 másodpercre növelik.
Ily módon csak akkor növelheti az időt, ha a csökkentett mód ki van kapcsolva.
Ha van hozzáférése a php.ini szerkesztéséhez, növelheti az időt a használatával
maximális_végrehajtási_idő = 6000
Például a Masterhost tárhelyen a cikk írásakor tilos a szkriptidő növelése, annak ellenére, hogy a csökkentett mód ki van kapcsolva, de ha profi vagy, elkészítheted saját PHP-d a Masterhostra, de nem tárgya ennek a cikknek.
1. szakasz. Sikeres teszt (kölcsönhatás a GIS GMP tesztáramkörrel) #GIS GMP tesztszolgáltatás címe:
gisgmp.wsdlLocation=http://213.59.255.182:7777/gateway/services/SID0003663?wsdl
gisgmp.wsdlLocation.endPoint=http://213.59.255.182:7777/gateway/services/SID0003663
Ez a cím regisztrálva van az SP beállításokban, emellett regisztrálnia kell a naplózási beállítások fájlban, megadva az értéket
Feltöltés után ellenőriznie kell az állapotot a „Feldolgozási állapot kérése” művelettel. Ezt követően az ED fizetési információ „Accepted by GIS GMP” státuszra vált –…
Adott: MSG (üzenetek) táblázat sok bejegyzéssel.
CREATETABLEmsg(idINTEGERNOTNULLPRIMARYKEY,descriptionCHAR(50)NOTNULL, date_createDATE);
Feladat:
Törölni kell az adattáblázatot/
Megoldás: Számos módja van ennek a probléma megoldásának. Az alábbiakban mindegyik leírását és példáját találja.
A legegyszerűbb módja ( első lehetőség) - a rekordtörlés operátor végrehajtása. Amikor végrehajtja, látni fogja az eredményt (hány rekordot töröltek). Hasznos dolog, ha biztosan tudnia kell, és meg kell értenie, hogy a helyes adatokat törölték-e. DE vannak hátrányai a probléma megoldásának más lehetőségeivel szemben.
DELETE FROMmsg;--Törli a táblázat összes sorát -- Törli az összes sort, amelynek létrehozási dátuma "2019.02.01" DELETE FROMmsg WHEREdate_create="2019.02.01";
Második lehetőség. A DML utasítás használata a táblázat összes sorának törléséhez.
TRUNCATETABLEmsg;
Ennek az operátornak számos funkciója van:
Firebirdben nem érhető el, ezért az első és a harmadik opciót használjuk.
Az SMEV 3.0-hoz intézett kérések aktuális címei Felhívjuk figyelmét, hogy az SMEV 3.0 technológiai portálon korábban közzétett információkkal összhangban az egyesített elektronikus szolgáltatáshoz a jelenlegi címeket kell használni:
az SMEV 3.0 fejlesztői környezet egységes elektronikus szolgáltatásának címe, amely megfelel az 1.1 sémának - http://smev3-d.test.gosuslugi.ru:7500/smev/v1.1/ws?wsdl, és a szolgáltatás is címen legyen elérhető
Az XML Extensible Markup Language a dokumentumok géppel olvasható formában történő kódolására szolgáló szabályok összessége. Az XML az internetes adatcsere népszerű formátuma. A tartalmukat gyakran frissítő webhelyek, például híroldalak vagy blogok gyakran biztosítanak XML-hírcsatornát, hogy a külső programok értesüljenek a tartalomváltozásokról. Az XML adatok küldése és elemzése gyakori feladat a hálózathoz kapcsolódó alkalmazásoknál. Ez a lecke elmagyarázza, hogyan kell XML-dokumentumokat elemezni és felhasználni az adataikat.
Elemző kiválasztása
Csatornaelemzés
A hírcsatorna elemzésének első lépése annak eldöntése, hogy mely adatmezők érdeklik. Az elemző kivonja a megadott mezőket, és figyelmen kívül hagy minden mást.
Íme egy részlet a csatornából, amelyet a példaalkalmazásban vizsgálunk meg. A StackOverflow.com webhelyen minden bejegyzés bejegyzéscímkeként jelenik meg egy feedben, amely több alcímkét tartalmaz:
Van egy alkalmazásom, amelyhez adatfájl szükséges...
A példaalkalmazás lekéri az adatokat a bejegyzés címkéjéből és annak cím, hivatkozás és összegzés alcímkéiből.
Elemző példány létrehozása
A következő lépés az elemző példányosítása és az elemzési folyamat elindítása. Ez a kódrészlet inicializálja az elemzőt, hogy ne kezelje a névtereket, és a megadott InputStream-et használja bemenetként. Az elemzési folyamat a nextTag() meghívásával kezdődik, és meghívja a readFeed() metódust, amely lekéri és feldolgozza az alkalmazást érdeklő adatokat:
Nyilvános osztály StackOverflowXmlParser ( // Nem használunk névtereket private static final String ns = null; public List parse(InputStream in) XmlPullParserException, IOException ( próbálja meg ( XmlPullParser parser = Xml.newPullParser();); parser.set.set. , false); parser.setInput(in, null); parser.nextTag(); return readFeed(elemző); ) végül (in.close(); ) ) ... )
Csatorna kivonása
A readFeed() metódus végzi el az adatfolyam feldolgozásának tényleges munkáját. Az "entry" címkével jelölt elemek a csatorna rekurzív feldolgozásának kiindulópontja. Ha a következő címke nem belépési címke, akkor a rendszer kihagyja. A teljes "hírcsatorna" rekurzív feldolgozása után a readFeed() egy listát ad vissza, amely tartalmazza a hírfolyamból lekért bejegyzéseket (beleértve a beágyazott adatelemeket is). Ezt a listát az elemző visszaadja.
Private List readFeed(XmlPullParser parser) az XmlPullParserException, IOException (listabejegyzések = new ArrayList (); parser.require(XmlPullParser.START_TAG, ns, "feed"); while (parser.next() != XmlPullParser) (if. (parser.getEventType() != XmlPullParser.START_TAG) ( folytatás; ) String name = parser.getName(); // Az if (name.equals("entry") bejegyzési címkével kezdődik) ( entries.add( readEntry(elemző)); ) else ( skip(parser); ) ) adja vissza a bejegyzéseket; )
XML elemzés
Az XML-hírcsatorna elemzésének lépései a következők:
Ez a részlet megmutatja, hogy az elemző hogyan elemzi a bejegyzést, a címet, a hivatkozást és az összefoglalót.
Nyilvános statikus osztály Bejegyzés ( publikus végleges Karakterlánc címe; publikus végleges Karakterlánc hivatkozás; nyilvános végleges Karakterlánc összefoglaló ; ) ) // Egy bejegyzés tartalmát elemzi. Ha címet, összefoglalót vagy hivatkozási címkét talál, adja át // a megfelelő "olvasási" metódusuknak a feldolgozáshoz. Ellenkező esetben hagyja ki a címkét. private Entry readEntry(XmlPullParser parser) XmlPullParserException, IOException (parser.require(XmlPullParser.START_TAG, ns, "entry"); String title = null; String summary = null; String link = null; while (parser.next()) ! = XmlPullParser.END_TAG) ( if (parser.getEventType() != XmlPullParser.START_TAG) ( folytatás; ) Karakterlánc neve = parser.getName(); if (name.equals("title")) ( title = readTitle(parser) ; ) else if (name.equals("összefoglaló")) ( summary = readSummary(parser); ) else if (name.equals("link")) ( link = readLink(elemző); ) else ( skip(parser) ; ) ) return new Entry(cím, összefoglaló, link); ) // Feldolgozza a címcímkéket a hírfolyamban. private String readTitle(XmlPullParser parser) IOException, XmlPullParserException ( parser.require(XmlPullParser.START_TAG, ns, "title"); String title = readText(parser); parser.require(XmlPullParser.END_TAG, n) parancsot return title; ) // Feldolgozza a linkcímkéket a hírfolyamban. private String readLink(XmlPullParser parser) IOException, XmlPullParserException (String link = ""; parser.require(XmlPullParser.START_TAG, ns, "link"); String tag = parser.getName(); String relType = parser.getAttributeValue , "rel"); if (tag.equals("link")) (if (relType.equals("alternate"))( link = parser.getAttributeValue(null, "href"); parser.nextTag(); ) ) parser.require(XmlPullParser.END_TAG, ns, "link"); return link; ) // Feldolgozza az összefoglaló címkéket a hírfolyamban. private String readSummary(XmlPullParser parser) IOException, XmlPullParserException ( parser.require(XmlPullParser.START_TAG, ns, "summary"); String summary = readText(parser); parser.require(XmlPullParser.END_TAG, n); return summary; ) // A title és summary címkék szöveges értékeit kivonja. private String readText(XmlPullParser elemző) IOException, XmlPullParserException ( String result = ""; if (parser.next() == XmlPullParser.TEXT) ( result = parser.getText(); parser.nextTag(); ) eredményt ad vissza; ) ... )
Kihagyja azokat a tárgyakat, amelyekre nincs szüksége
A fent leírt XML-elemzési lépések egyikében az elemző kihagyja azokat a címkéket, amelyekre nem vagyunk kíváncsiak. Alább látható a skip() metódus elemző kódja:
A privát void skip(XmlPullParser parser) az XmlPullParserException, IOException paramétert dobja ( if (parser.getEventType() != XmlPullParser.START_TAG) ( új IllegalStateException(); ) int mélység = 1; while (depth != 0) ( kapcsoló next()) ( XmlPullParser eset.END_TAG: mélység--; törés; XmlPullParser kisbetű.START_TAG: mélység++; törés; ) ) )
Így működik:
- A metódus kivételt dob, ha az aktuális esemény nem START_TAG.
- Felhasznál START_TAG és minden eseményt END_TAG-ig.
- Annak érdekében, hogy a megfelelő END_TAG-nál álljon meg, és ne az eredeti START_TAG utáni első címkénél, nyomon követi a beágyazási mélységet.
Így, ha az aktuális elem beágyazott elemeket tartalmaz, a mélység értéke nem lesz 0, amíg az elemző fel nem dolgozott minden eseményt az eredeti START_TAG és a megfelelő END_TAG között. Például nézze meg, hogyan halad az analizátor
- A while cikluson való első áthaladáskor a következő címke, amely után az elemző találkozik
ez START_TAG a számára - A while ciklus második áthaladásakor a következő címke, amellyel az elemző találkozik, az END_TAG
- A while cikluson áthaladó harmadik lépésnél a következő címke, amellyel az elemző találkozik, a START_TAG
. A mélység értéke 2-re nő. - A while ciklus negyedik áthaladásakor a következő címke, amellyel az elemző találkozik, az END_TAG. A mélység értéke 1-re csökken.
- Az ötödik és egyben utolsó áthaladáskor a while cikluson a következő címke, amellyel az elemző találkozik, az END_TAG. A mélység értéke 0-ra csökken, jelezve, hogy
az elemet sikeresen kihagytuk.
XML adatfeldolgozás
A példaalkalmazás fogad és elemzi egy XML-hírcsatornát egy AsyncTask-ban. A feldolgozás a fő felhasználói felületen kívül történik. Amikor a feldolgozás befejeződött, az alkalmazás frissíti a felhasználói felületet a fő tevékenységben (NetworkActivity).
Az alábbi részletben a loadPage() metódus a következőket teszi:
- Inicializál egy karakterlánc-változót egy XML-hírcsatornára mutató URL-lel.
- Ha a felhasználói beállítások és a hálózati kapcsolat megengedi, akkor a DownloadXmlTask().execute(url) új hívása. Ezzel létrehoz egy új DownloadXmlTask objektumot (AsyncTask alosztály), és végrehajtja az execute() metódust, amely letölti és elemzi a csővezetéket, és visszaad egy karakterlánc eredményt, amely megjelenik a felhasználói felületen.
- A doInBackground() végrehajtja a loadXmlFromNetwork() metódust. Paraméterként adja át a csatorna URL-címét. A loadXmlFromNetwork() metódus fogadja és feldolgozza a csatornát. Amikor befejezi a feldolgozást, visszaadja a kapott karakterláncot.
- Az onPostExecute() megkapja a visszaadott karakterláncot, és megjeleníti a felhasználói felületen.
Az alábbiakban látható a loadXmlFromNetwork() metódus, amelyet a DownloadXmlTask programból hívnak meg. A következőket teszi:
- Létrehozza a StackOverflowXmlParser példányát. Változókat hoz létre a List Entry objektumokhoz, valamint a címhez, URL-hez és összefoglalóhoz, hogy tárolja az XML-hírcsatornából kinyert értékeket ezekhez a mezőkhöz.
- Meghívja a downloadUrl() függvényt, amely letölti a csatornát, és InputStreamként adja vissza.
- A StackOverflowXmlParser segítségével elemzi az InputStream-et. A StackOverflowXmlParser feltölti a listabejegyzéseket a feedből származó adatokkal.
- Feldolgozza a List bejegyzéseket, és egyesíti a csatornaadatokat HTML-jelöléssel.
- A fő tevékenység, az AsyncTask felhasználói felületén az onPostExecute() metódusban megjelenő HTML-karakterláncot adja vissza.
" + getResources().getString(R.string.page_title) + "
"); htmlString.append(" " + getResources().getString(R.string.updated) + " " + formatter.format(rightNow.getTime()) + ""); try ( stream = downloadUrl(urlString); bejegyzések = stackOverflowXmlParser.parse(stream); // Győződjön meg arról, hogy az InputStream be van zárva, miután az alkalmazás // befejezte a használatát. ) végül ( if (stream != null) ( stream.close(); ) ) // A StackOverflowXmlParser egy listát (úgynevezett "bejegyzéseket") ad vissza az Entry objektumokról. // Minden Entry objektum egyetlen bejegyzést jelent az XML feedben. // Ez a szakasz feldolgozza a bejegyzéslistát az egyes elemek kombinálásához. bejegyzés HTML-jelöléssel. // Minden bejegyzés hivatkozásként jelenik meg a felhasználói felületen, amely opcionálisan // tartalmaz egy szöveges összefoglalót. for (Bejegyzés: bejegyzések) ( htmlString.append("" + bejegyzés.cím + "
"); // Ha a felhasználó úgy állítja be az összefoglaló szöveget, // hozzáadja a megjelenítéshez. if (pref) ( htmlString.append(entry.summary); ) ) return htmlString.toString(); ) // Adott egy URL karakterlánc-ábrázolása, létrehoz egy kapcsolatot és // kap egy bemeneti adatfolyamot. private InputStream downloadUrl(String urlString) IOExceptiont dob ( URL url = new URL(urlString); HttpURLConnection conn = (HttpURLConnection) url.openConnection() ; conn.setReadTimeout(10000 /* ezredmásodperc */); conn.setConnectTimeout(15000 /* ezredmásodperc */); conn.setRequestMethod("GET"); conn.setDoInput(true); // Elindítja a conn.connect( ); return conn.getInputStream(); )
Az XML elemzés lényegében azt jelenti, hogy végigsétálunk egy XML dokumentumon, és visszaadjuk a megfelelő adatokat. Noha egyre több webszolgáltatás ad vissza adatokat JSON formátumban, a legtöbb továbbra is XML-t használ, ezért fontos, hogy elsajátítsa az XML-elemzést, ha az elérhető API-k teljes skáláját szeretné használni.
A kiterjesztés használata SimpleXML a PHP-ben, amelyet a PHP 5.0-ban adtak hozzá, az XML-lel való munkavégzés nagyon könnyű és egyszerű. Ebben a cikkben megmutatom, hogyan kell csinálni.
A használat alapjai
Kezdjük a következő példával nyelvek.xml:
>
>
>
>
Ez az XML-dokumentum a programozási nyelvek listáját tartalmazza, néhány információval az egyes nyelvekről: a bevezetés éve és a készítő neve.
Az első lépés az XML betöltése a függvények használatával simplexml_load_file(), vagy simplexml_load_string(). Ahogy a függvények neve is sugallja, az első egy fájlból, a második pedig egy karakterláncból tölti be az XML-t.
Mindkét függvény beolvassa a teljes DOM-fát a memóriába, és visszaad egy objektumot SimpleXMLElement. A fenti példában az objektum a $languages változóban van tárolva. Használhatja a funkciókat var_dump() vagy print_r() hogy részleteket kapjon a visszaküldött objektumról, ha akarja.
SimpleXMLElement objektum
[lang] => Tömb
[ 0 ] => SimpleXMLElement objektum
[@attributes] => Tömb
[név] => C
[megjelent] => 1972
[alkotó] => Dennis Ritchie
[ 1 ] => SimpleXMLElement objektum
[@attributes] => Tömb
[név] => PHP
[megjelent] => 1995
[alkotó] => Rasmus Lerdorf
[ 2 ] => SimpleXMLElement objektum
[@attributes] => Tömb
[név] => Java
[megjelent] => 1995
[alkotó] => James Gosling
)
)
Ez az XML gyökérelemet tartalmaz nyelvek, amelyen belül három elem található lang. Minden tömbelem egy elemnek felel meg lang az XML dokumentumban.
Egy objektum tulajdonságait az operátor segítségével érheti el -> . Például a $languages->lang egy SimpleXMLElement objektumot ad vissza, amely megfelel az első elemnek lang. Ez az objektum két tulajdonságot tartalmaz: megjelent és létrehozó.
$languages -> lang [ 0 ] -> megjelent ;
$languages -> lang [ 0 ] -> creator ;
A nyelvek listájának megjelenítése és tulajdonságaik megjelenítése nagyon egyszerűen elvégezhető egy szabványos hurok használatával, mint pl az egyes.
foreach ($languages> -> lang mint $lang ) (
printf(
""
,
$lang [ "név" ] ,
$lang -> megjelent ,
$lang -> alkotó
)
;
}
Figyelje meg, hogyan jutottam hozzá az elem lang attribútumának nevéhez, hogy megkapjam a nyelv nevét. Így elérheti a SimpleXMLElement objektumként ábrázolt elem bármely attribútumait.
Névterekkel való munka
A különféle webszolgáltatások XML-ével való munka során többször találkozhat elemnévterekkel. Változtassuk meg nyelvek.xml hogy példát mutassunk a névtér használatára:
xmlns:dc =>
>
>
>
>
Most az elem Teremtő elfér a névtérben dc amely a http://purl.org/dc/elements/1.1/ címre mutat. Ha megpróbálja kinyomtatni a nyelvi alkotókat a korábbi kódunkkal, az nem fog működni. Az elemek névtereinek olvasásához a következő módszerek egyikét kell használnia.
Az első megközelítés az, hogy az URI-neveket közvetlenül a kódban használjuk, amikor hozzáférünk az elem névteréhez. A következő példa bemutatja, hogyan történik ez:
$dc = $nyelvek -> lang [ 1 ] - > children( "http://purl.org/dc/elements/1.1/")
;
echo $dc -> creator ;
Módszer gyermekek() névteret vesz, és előtaggal kezdődő gyermekelemeket ad vissza. Két argumentumra van szükség, amelyek közül az első az XML névtér, a második pedig egy opcionális argumentum, amely az alapértelmezett hamis. Ha a második argumentum értéke IGAZ, a névteret előtagként kezeli a rendszer. Ha FALSE, akkor a névteret URL névtérként kezeli a rendszer.
A második megközelítés az URI-nevek beolvasása a dokumentumból, és az elemek névterének elérésekor történő felhasználás. Ez valójában egy jobb módja annak, hogy hozzáférjen az elemekhez, mert nem kell az URI-hez kódolni.
$namespaces = $languages> -> getNamespaces (igaz) ;
$dc = $languages -> lang [ 1 ] -> children ( ($namespaces [ "dc" ] ) ;
echo $dc -> creator ;
Módszer GetNamespaces() előtagnevek és a hozzájuk tartozó URI-k tömbjét adja vissza. Elfogad egy további paramétert, amely az alapértelmezett hamis. Ha úgy állítod be igaz, akkor ez a metódus a szülő és gyermek csomópontokban használt neveket adja vissza. Ellenkező esetben a csak a szülőcsomópontban használt névtereket találja meg.
Most ismételheti a nyelvek listáját, így:
$languages = simplexml_load_file ("languages.xml" ) ;
$ns = $nyelvek -> getNamespaces (igaz) ;
foreach ($languages> -> lang mint $lang ) (
$dc = $lang -> gyermek ($ns [ "dc" ] ) ;
printf(
"
%s megjelent itt: %d, és %s hozta létre.
" ,$lang [ "név" ] ,
$lang -> megjelent ,
$dc -> alkotó
) ;
}
Gyakorlati példa – Videócsatorna elemzése a YouTube-ról
Nézzünk egy példát, amely egy RSS-hírcsatornát kap egy YouTube-csatornától, és megjeleníti az ott található összes videóra mutató hivatkozásokat. Ehhez vegye fel a kapcsolatot az alábbi címen:
http://gdata.youtube.com/feeds/api/users/xxx/uploads
Az URL egy adott csatorna legújabb videóinak listáját adja vissza XML formátumban. Elemezzük az XML-t, és minden videóhoz megkapjuk a következő információkat:
- Link a videóhoz
- Miniatűr
- Név
Kezdjük az XML keresésével és betöltésével:
$channel = "Csatorna_neve" ;
$url = "http://gdata.youtube.com/feeds/api/users/". $csatorna. "/feltöltések" ;
$xml = file_get_contents($url);
$feed = simplexml_load_string ($xml) ;
$ns = $feed -> getNameSpaces ( igaz ) ;
Ha megnézed az XML feedet, láthatod, hogy több elem is van benne entitás, amelyek mindegyike részletes információkat tárol a csatorna adott videójáról. De csak a képek miniatűrjeit, a videó URL-jét és címét használjuk. Ez a három elem az elem leszármazottja csoport, ami viszont gyermeke belépés:
…
…
…
>
…
Csak végigmegyünk az összes elemen belépés, és mindegyikhez kinyerjük a szükséges információkat. vegye figyelembe, hogy játékos miniatűrÉs cím a média névtérben vannak. Így az előző példában leírtak szerint kell eljárnunk. Neveket kapunk a dokumentumból, és a névteret használjuk az elemek eléréséhez.
foreach ($feed -> bejegyzés mint $entry ) (
$group = $bejegyzés -> gyermek ($ns [ "media" ] ) ;
$csoport = $csoport -> csoport ;
$thumbnail_attrs = $csoport -> thumbnail [ 1 ] -> attribútumok () ;
$image = $thumbnail_attrs [ "url" ] ;
$lejátszó = $csoport -> játékos -> attribútumok () ;
$link = $player [ "url" ] ;
$cím = $csoport -> cím ;
printf( "
$lejátszó, $kép, $cím);
}
Következtetés
Most, hogy tudja, hogyan kell használni SimpleXML Az XML-adatok elemzéséhez fejlesztheti készségeit a különböző XML-hírcsatornák különböző API-kkal történő elemzésével. Fontos azonban figyelembe venni, hogy a SimpleXML a teljes DOM-ot beolvassa a memóriába, így ha nagy adatkészletet elemez, elfogyhat a memória. Ha többet szeretne megtudni a SimpleXML-ről, olvassa el a dokumentációt.
Ha kérdése van, javasoljuk, hogy használja
