XML elemzése. XML adatok elemzése Példa az xml-lel való munkára

Így tetszőleges részekben küldhet egy nagy fájlt a kezelőnek.

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 a $ attrs címke attribútumainak tömbje is elérhető lesz, amelyben lesznek adatok mennyiség = "3" és egység = "üveg".

Ezt követően a nyitott címke adatainak feldolgozása a funkcióval adat ($ elemző, $ adat)
A $ adatváltozó mindent tartalmaz a nyitó és záró címke között, esetünkben ez a Liszt szöveg

A karakterláncunk feldolgozását pedig a függvény fejezi be endElement ($ elemző, $ név)
Ez a zárt címke neve, esetünkben a $ név egyenlő lesz hozzávaló

Utána pedig újra körbe ment minden.

A fenti példa csak az XML feldolgozás elvét mutatja be, de a valós használathoz még tovább kell fejleszteni.
Általában nagyméretű XML elemzése szükséges az adatok adatbázisba történő beírásához, és a helyes adatfeldolgozáshoz tudnia kell, hogy az adatok melyik nyitott címkéhez tartoznak, melyik tag-beágyazási szint és mely címkék nyitottak a hierarchiában magasabban. Ezen információk birtokában probléma nélkül tudja megfelelően feldolgozni a fájlt.
Ehhez meg kell adnia több globális változót, 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 ($ fájl)
{
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 = tömb ();
globális $ webi_data_temp; // ez a tömb egy címke adatait fogja tartalmazni

####################################################
### funkció az adatokkal való munkavégzéshez
függvényadatok ($ elemző, $ adat)
{
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ágyazott és jelenleg nyitott címkét
$ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"] = $ adat;
}
############################################

####################################################
### nyitó címkék funkció
függvény startElement ($ értelmező, $ 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
if ($ webi_depth)
{

" ;

nyomtatni"
" ;
print_r ($ webi_tag_open); // nyitott címkék tömbje
nyomtatni"

// az adatok feldolgozása után töröljük a memória felszabadításához
unset ($ GLOBALS ["webi_data_temp"] [$ webi_depth]);
}

// most elkezdődött a következő címke megnyitása, és a további feldolgozás a következő lépésben történik meg
$ webi_depth ++; // fészekrakás növelése

$ webi_tag_open [$ webi_depth] = $ név; // az open tag hozzáadása az információs tömbhöz
$ webi_data_temp [$ webi_depth] [$ név] ["attrs"] = $ attrs; // most adja hozzá a címke attribútumait

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

#################################################
## end tag funkció
függvény endElement ($ értelmező, $ 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 címke 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

Nyomtassa ki az "adatokat". $ 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"]);
nyomtatni"
" ;
print_r ($ webi_tag_open);
nyomtatni"

Unset ($ GLOBALS ["webi_data_temp"]); // az adatok feldolgozása után töröljük a teljes tömböt adatokkal, mivel a címke zárva volt
unset ($ GLOBALS ["webi_tag_open"] [$ webi_depth]); // információ eltávolítása erről a megnyitott címkéről ... a bezárása óta

$ webi_depth -; // a beágyazás csökkentése
}
############################################

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

// adja meg, hogy mely függvények működjenek 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 ($ fájl, "r");

$ perviy_vxod = 1; // jelölje be az első fájlbejegyzés 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); // beolvas egy karaktert a fájlból
$ adat = $ simvol; // adja hozzá ezt a szimbólumot az elküldendő adatokhoz

// ha a karakter nem zárócímke, akkor visszamegyünk a ciklus elejére, és hozzáadunk egy másik karaktert az adatokhoz, és így tovább, amíg meg nem találjuk a végcímkét
if ($ simvol! = ">") (folytatás;)
// ha záró címkét találtunk, most küldje el ezeket az összegyűjtött adatokat feldolgozásra

// ellenőrizze, hogy ez-e az első bejegyzés a fájlba, majd töröljön mindent, ami a címke előtt van// mivel néha az XML kezdete előtt szemetet lehet találni (ügyetlen szerkesztők, vagy a fájlt egy script fogadja egy másik szerverről)
if ($ perviy_vxod) ($ data = strstr ($ adat, "

// most bedobjuk az adatokat az xml elemzőbe
if (! xml_parse ($ xml_parser, $ data, feof ($ fp))) (

// itt lehet feldolgozni és érvényességi hibákat kérni...
// 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érték, most teszteljetek és kísérletezzetek.
Kérjük, vegye figyelembe, hogy az adatokkal való munkavégzés funkciójában az adatok nem egyszerűen egy tömbbe kerülnek, hanem a " .=" mivel előfordulhat, hogy az adatok nem érkeznek teljes egészében, és ha egyszerű feladatot adsz meg, akkor időről időre darabokban kapod meg az adatokat.

Nos, ennyi, most már tetszőleges méretű fájl feldolgozásakor van elég memória, de a szkript futási ideje többféleképpen növelhető.
A szkript elejére illessze be a függvényt
set_time_limit (6000);
vagy
ini_set ("max. végrehajtási_idő", "6000");

Vagy adja hozzá a 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.
Az időt így csak letiltott módban növelheti.

Ha van hozzáférése a php.ini szerkesztéséhez, növelheti az időt a következővel
maximális_végrehajtási_idő = 6000

Például a hosting masterhost-on az írás idején a szkriptidő növelése tilos, a letiltott csökkentett mód ellenére, de ha profi vagy, készíthetsz saját php-összeállítást a masterhost-on, de ez nem erről ebben a cikkben.

Az oktatóanyag néhány példája XML-karakterláncot tartalmaz. Ahelyett, hogy minden példában megismételné, helyezze el azt a sort egy fájlba, amelyet minden példában felvesz. Ez a vonal látható a következő példában. Ezenkívül XML-dokumentumot is készíthet, és a funkcióval elolvashatja simplexml_load_file ().

1. példa Példa.php fájl XML karakterlánccal

$ xmlstr =<<





Kisasszony. Kódoló
Onlivia Actora


Úr. Kódoló
El ActÓr


Tehát ez egy nyelv. Ez még mindig egy programozási nyelv. Vagy
ez egy script nyelv? Ebben a dokumentumfilmben minden kiderül
mint egy horrorfilmben.




7
5


XML;
?>

A SimpleXML használata 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 az "example.php" kifejezést;

echo $ filmek -> film [0] -> cselekmény;
?>

Tehát ez egy nyelv. Ez még mindig egy programozási nyelv. Vagy ez egy script nyelv? Ebben a horrorszerű dokumentumfilmben minden kiderül.

PHP-ben egy XML-dokumentum olyan eleméhez férhet hozzá, amely érvénytelen karaktereket (például kötőjelet) tartalmaz a nevében, ha az adott elem nevét kapcsos zárójelek és aposztrófok közé helyezi.

3. példa Egy karakterlánc lekérése

tartalmazza az "example.php" kifejezést;

echo $ filmek -> film -> ("nagyvonalak") -> sor;
?>

Ennek a példának az eredménye:

A PHP minden webproblémát megold

4. példa Nem egyedi elemek elérése a SimpleXML-ben

Abban az esetben, ha egy szülőelemben több gyermekelem is található, akkor a szabványos iterációs módszereket kell használnia.

tartalmazza az "example.php" kifejezést;

$ filmek = új SimpleXMLElement ($ xmlstr);

/ * Minden csomóponthoz , a nevet külön jelenítjük meg . */
foreach ($ filmek -> film -> karakterek -> karakter mint $ karakter) (
echo $ karakter -> név, "játszó", $ karakter -> színész, PHP_EOL;
}

?>

Ennek a példának az eredménye:

Kisasszony. A kódolót Onlivia Actora Mr. A kódolót El ActÓr alakítja

Megjegyzés:

Tulajdonságok ( $ filmek-> film az előző példában) nem tömbök. Tömbként iterálható.

5. példa Attribútumok használata

Eddig csak az elemek nevét és értékét kaptuk meg. A SimpleXML hozzáférhet egy elem attribútumaihoz is. Egy elemattribútum ugyanúgy elérhető, mint a tömbelemek ( sor).

tartalmazza az "example.php" kifejezést;

$ filmek = új SimpleXMLElement ($ xmlstr);

/ * Hozzáférés a csomóponthoz az első film.
* Az értékelési skálát is megjelenítjük. * /
foreach ($ filmek -> film [0] -> értékelés $ értékelésként) (
kapcsoló ((karakterlánc) $ értékelés ["típus"]) ( // Az elem attribútumainak lekérése index szerint
"hüvelykujj" eset:
echo $ értékelés, "tetszik";
szünet;
"csillagok" eset:
echo $ értékelés, "csillagok";
szünet;
}
}
?>

Ennek a példának az 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 az "example.php" kifejezést;

$ filmek = új SimpleXMLElement ($ xmlstr);

if ((karakterlánc) $ filmek -> film -> cím == "PHP: The Rise of the Parser") {
nyomtatás – A kedvenc filmem.;
}

echo htmlentities ((karakterlánc) $ filmek -> film -> cím);
?>

Ennek a példának az eredménye:

Kedvenc filmem Php: The Emergence of the Parser

7. példa Két elem összehasonlítása

Két SimpleXMLElement akkor is eltérőnek számít, ha ugyanarra az objektumra mutat a PHP 5.2.0 óta.

tartalmazza az "example.php" kifejezést;

$ filmek1 = új SimpleXMLElement ($ xmlstr);
$ filmek2 = új SimpleXMLElement ($ xmlstr);
var_dump ($ filmek1 == $ filmek2); // hamis a PHP 5.2.0 óta
?>

Ennek a példának az eredménye:

8. példa XPath használata

A SimpleXML beépített XPath támogatást tartalmaz. Találja meg az összes elemet :

tartalmazza az "example.php" kifejezést;

$ filmek = új SimpleXMLElement ($ xmlstr);

foreach ($ filmek -> xpath ("// karakter") $ karakterként) (
echo $ karakter -> név, "játszó", $ karakter -> színész, PHP_EOL;
}
?>

"// "sablonként szolgál. Abszolút elérési út megadásához hagyja ki az egyik perjelet.

Ennek a példának az eredménye:

Kisasszony. A kódolót Onlivia Actora Mr. A kódolót El ActÓr alakítja

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 az "example.php" kifejezést;
$ filmek = új SimpleXMLElement ($ xmlstr);

$ filmek -> film [0] -> karakterek -> karakter [0] -> név = "Kódoló kisasszony";

echo $ filmek -> asXML ();
?>

Ennek a példának az eredménye:

Kódoló kisasszony Onlivia Actora Úr. Kódoló El ActÓr 7 5

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 az "example.php" kifejezést;
$ filmek = új SimpleXMLElement ($ xmlstr);

$ karakter = $ filmek -> film [0] -> karakterek -> addChild ("karakter");
$ karakter -> addChild ("név", "Mr. Elemző");
$ karakter -> addChild ("színész", "John Doe");

$ értékelés = $ filmek -> film [0] -> addChild ("értékelés", "PG");
$ értékelés -> addAttribute ("type", "mpaa");

echo $ filmek -> asXML ();
?>

Ennek a példának az eredménye:

Kisasszony. Kódoló Onlivia Actora Úr. Kódoló El ActÓr Úr. ElemzőGipsz Jakab Tehát ez egy nyelv. Ez még mindig egy programozási nyelv. Vagy ez egy script nyelv? Ebben a horrorszerű dokumentumfilmben minden kiderül. A PHP minden webes feladatomat megoldja 7 5 PG

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 DOMDocument;
$ dom -> loadXML ( "" );
if (! $ dom) (
visszhang "Hiba történt a dokumentum elemzése közben";
kijárat;
}

$ könyvek = simplexml_import_dom ($ dom);

echo $ könyvek -> könyv [0] -> cím;
?>

Ennek a példának az 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 (), majd a json_decode () függvényen 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]?> megkapja az adott csomópont összes karakterlánc-tartalmát - 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ések végrehajtására 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 készült, a JSON-ra és vissza történő á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é alakítson át", az előbb-utóbb csípni fog.

Természetesen írhatna egy intelligensebb konverziót, amely nem rendelkezik ilyen korlátokkal, de ezen a ponton a SimpleXML-ből egyáltalán nem kap értéket, és csak az alacsonyabb szintű XML-elemző függvényeket vagy az XMLReader osztályt kell használnia, Még mindig "nem fogja megkapni a SimpleXML extra kényelmi funkcióit, 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 =<<

1
0

XML;
$ értékek = új SimpleXMLElement ($ xmlstr);
$ truevalue = (bool) $ értékek-> truevalue; // igaz
$ falsevalue = (bool) $ értékek-> falsevalue; // is igaz!!!

Ehelyett először karakterláncra vagy intre kell átküldenie:

$ truevalue = (bool) (int) $ értékek-> truevalue; // igaz
$ falsevalue = (bool) (int) $ értékek-> falsevalue; // hamis

9 évvel ezelőtt

Ha válaszában érvényes xml-t kell megadnia, 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:
fejléc ("Content-Type: text / 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 módszergyerekeknek ()-nek kell lenniük
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 egy tulajdonságon keresztül SZÖVEG adatok érhetők el
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: $ objektum-> tulajdonság.

8 évvel ezelőtt

Az olyan dolgok használata, mint például: is_object ($ xml-> modul-> 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 üres - még akkor is, ha egy adott csomópont nem létezik.
Számomra a jó öreg üres () funkció 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 szerintem a .NET XML-rendszere: ha valamit meg kell címezni az alapértelmezett névtérben, akkor 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 =<<


Joe
Jane

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: document / def: title");

?>

9 évvel ezelőtt

Noha a SimpleXMLElement azt állítja, hogy iterálható, úgy tűnik, hogy nem valósítja meg a szabványos Iterator interfész funkcióit, mint például a :: next és :: reset megfelelően. Ezért míg a foreach () működik, az olyan funkciók, mint a next (), az aktuális () vagy az egyes () nem úgy tűnik, hogy úgy működnek, ahogyan azt elvárná – a mutató soha nem mozdul, vagy folyamatosan visszaáll.

6 évvel ezelőtt

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 = "..." után és a standalone = "..." előtt kell következnie. 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ót közvetlenül a version = "..." és a standalone = "..." előtt kell követnie. Ez a követelmény szabványos XML.

Rendben

Orosz nyelv. orosz nyelv
Végzetes hiba: „Kivétel” el nem fogott kivétel „A karakterlánc nem értelmezhető XML-ként” üzenettel itt...