Parsare PHP xml. Analizarea XML cu SimpleXML

Astfel, în părți după cum doriți, puteți trimite un fișier mare către procesor.

Acum să vedem cum sunt procesate aceste date și cum să le obținem.

Să începem cu funcția de deschidere a etichetelor startElement ($parser, $name, $attrs)
Să presupunem că procesarea a ajuns la linie
< ingredient amount = "3" unit = "стакан" >Făină
Apoi, în interiorul funcției, variabila $nume va fi egală cu ingredient adică numele etichetei deschise (încă nu a ajuns să închidă eticheta).
De asemenea, în acest caz, va fi disponibilă o serie de atribute ale acestei etichete $attrs, care va conține date cantitate = "3" și unitate = "sticlă".

După aceasta, datele etichetei deschise au fost procesate de funcție date ($parser, $date)
Variabila $data va conține tot ce se află între etichetele de deschidere și de închidere, în cazul nostru acesta este textul Muka

Și procesarea șirului nostru de către funcție se termină endElement ($parser, $name)
Acesta este numele etichetei închise, în cazul nostru $name va fi egal cu ingredient

Și după aceea totul a mers din nou în cerc.

Exemplul de mai sus demonstrează doar principiul procesării XML, dar pentru aplicare reală trebuie modificat.
De obicei, trebuie să analizați XML mari pentru a introduce date în baza de date și pentru a procesa corect datele, trebuie să știți cărei etichete deschise aparțin datele, ce nivel de imbricare a etichetelor și ce etichete sunt deschise în ierarhia de mai sus. Cu aceste informații, puteți procesa fișierul corect, fără probleme.
Pentru a face acest lucru, trebuie să introduceți mai multe variabile globale care vor colecta informații despre etichete deschise, imbricare și date.
Iată un exemplu pe care îl puteți folosi

Funcția webi_xml ($fișier)
{
global $webi_depth ; // contor pentru a urmări adâncimea de cuibărit
$webi_depth = 0 ;
global $webi_tag_open ; // va conține o serie de etichete deschise în prezent
$webi_tag_open = array();
global $webi_data_temp ; // această matrice va conține datele unei etichete

####################################################
### funcția de date
date funcție ($parser, $date)
{
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;
// adaugă date în matrice care indică imbricarea și eticheta deschisă în prezent
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "date" ].= $date ;
}
############################################

####################################################
### funcția etichetă de deschidere
funcția startElement ($parser, $name, $attrs)
{
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;

// dacă nivelul de imbricare nu mai este zero, atunci o etichetă este deja deschisă
// și datele din acesta sunt deja în matrice, le puteți procesa
dacă ($webi_depth)
{

" ;

printeaza "
" ;
print_r($webi_tag_open); // matrice de etichete deschise
printeaza "

// după procesarea datelor, ștergeți-le pentru a elibera memorie
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}

// acum următoarea etichetă este deschisă și procesarea ulterioară va avea loc în pasul următor
$webi_depth++; // crește cuibărirea

$webi_tag_open [ $webi_depth ]= $nume ; // adaugă o etichetă deschisă la matricea de informații
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // acum adăugați atribute de etichetă

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

#################################################
## funcția de etichetă de închidere
funcția endElement ($parser, $nume) (
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;

// procesarea datelor începe aici, de exemplu adăugarea la baza de date, salvarea într-un fișier etc.
// $webi_tag_open conține un lanț de etichete deschise după nivelul de imbricare
// de exemplu $webi_tag_open[$webi_depth] conține numele etichetei deschise ale cărei informații sunt în curs de procesare
// Nivelul de imbricare a etichetei $webi_depth
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] matrice de atribute de etichetă
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] date etichete

Tipăriți „date”. $webi_tag_open [ $webi_depth ]. „--” .($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ „date” ]). "
" ;
print_r ($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "attrs" ]);
printeaza "
" ;
print_r($webi_tag_open);
printeaza "

Unset($GLOBALS [ "webi_data_temp" ]); // după procesarea datelor, ștergem întregul tablou cu datele, deoarece eticheta a fost închisă
unset($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // șterge informații despre această etichetă deschisă... de când s-a închis

$webi_depth --; // reduce cuibărirea
}
############################################

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

// indică ce funcții vor funcționa la deschiderea și închiderea etichetelor
xml_set_element_handler($xml_parser, "startElement", "endElement");

// specificăm o funcție pentru lucrul cu date
xml_set_character_data_handler($xml_parser, „date”);

// deschide fișierul
$fp = fopen($fisier, "r");

$perviy_vxod = 1 ; // flag pentru a verifica prima intrare în fișier
$date = "" ; // aici colectăm date din fișier în părți și le trimitem la parserul xml

// buclă până când este găsit sfârșitul fișierului
în timp ce (! feof ($fp ) și $fp )
{
$simvol = fgetc ($fp); // citește un caracter din fișier
$date .= $simvol ; // adaugă acest caracter la datele de trimis

// dacă caracterul nu este o etichetă de final, atunci reveniți la începutul buclei și adăugați un alt caracter la date și așa mai departe până când este găsită eticheta de final
if($simvol != ">" ) (continuare;)
// dacă a fost găsită eticheta de închidere, acum vom trimite aceste date colectate pentru procesare

// verifică dacă aceasta este prima intrare în fișier, apoi vom șterge tot ce este înainte de etichetă// deoarece uneori poate exista gunoi înainte de începerea XML-ului (editoare stângace sau fișierul a fost primit de un script de la alt server)
if($perviy_vxod ) ( $date = strstr ($date , "

// acum aruncați datele în parserul xml
dacă (! xml_parse ($xml_parser, $date, feof ($fp))) (

// aici puteți procesa și primi erori de valabilitate...
// de îndată ce se întâlnește o eroare, analiza se oprește
ecou"
Eroare XML: " . xml_error_string(xml_get_error_code($xml_parser));
ecou "la linie" . xml_get_current_line_number ($xml_parser);
pauză;
}

// după analizare, aruncați datele colectate pentru următorul pas al ciclului.
$date = "" ;
}
fclose($fp);
xml_parser_free($xml_parser);
// eliminarea variabilelor globale
unset($GLOBALS [ "webi_depth" ]);
unset($GLOBALS [ "webi_tag_open" ]);
unset($GLOBALS [ "webi_data_temp" ]);

Webi_xml ("1.xml");

?>

Întregul exemplu este însoțit de comentarii, acum testează și experimentează.
Vă rugăm să rețineți că, în funcția de lucru cu date, datele nu sunt pur și simplu inserate într-o matrice, ci mai degrabă adăugate folosind " .=" deoarece este posibil ca datele să nu ajungă în întregime și dacă faceți doar o sarcină, atunci din când în când veți primi datele în bucăți.

Ei bine, asta este tot, acum există suficientă memorie la procesarea unui fișier de orice dimensiune, dar timpul de rulare a scriptului poate fi mărit în mai multe moduri.
Inserați o funcție la începutul scriptului
set_time_limit(6000);
sau
ini_set ("max_execution_time" , "6000" );

Sau adăugați text în fișierul .htaccess
php_value max_execution_time 6000

Aceste exemple vor crește timpul de rulare a scriptului la 6000 de secunde.
Puteți mări timpul în acest fel numai când modul sigur este dezactivat.

Dacă aveți acces pentru a edita php.ini, puteți crește timpul folosind
max_execution_time = 6000

De exemplu, pe găzduirea Masterhost, la momentul scrierii acestui articol, creșterea timpului de script este interzisă, în ciuda faptului că modul sigur este dezactivat, dar dacă sunteți un profesionist, puteți face propria dvs. versiune PHP pe Masterhost, dar asta nu face obiectul acestui articol.

Analizor XML este un program care extrage date dintr-un fișier xml sursă și le salvează sau le folosește pentru acțiuni ulterioare.

De ce sunt necesare analizoare xml?

În primul rând, pentru că formatul xml în sine este popular printre standardele computerelor. Fișierul XML arată astfel:

aceste. în esență, există etichete, există câteva reguli pentru care etichetele ar trebui să se succedă.

Motivul pentru popularitatea fișierelor xml este că sunt foarte ușor de citit de oameni. Și faptul că este relativ ușor de procesat în programe.

Dezavantajele fișierelor xml.

Dezavantajul este, în primul rând, cantitatea mare de spațiu pe disc pe care o ocupă aceste date. Datorită faptului că etichetele care se repetă în mod constant, cu volume mari de date, ocupă relativ mulți megaocteți, care pur și simplu trebuie descărcați de la sursă și apoi procesați. Există alternative? Există, desigur, dar totuși, analizatorii xml și xml astăzi sunt unul dintre cele mai simple, mai fiabile și populare din punct de vedere tehnologic.

Cum sunt scrise analizatoarele XML?

Analizoarele sunt scrise în limbaje de programare. După cum se spune, sunt scrise pe toată lumea, dar nu mai mult. Trebuie înțeles că există limbaje de programare care au deja biblioteci încorporate pentru analizarea fișierelor xml. Dar, în orice caz, chiar dacă nu există o bibliotecă, puteți găsi întotdeauna o bibliotecă potrivită pentru această problemă și o puteți utiliza pentru a extrage date dintr-un fișier.

La nivel global, există 2 abordări diferite pentru analizarea fișierelor xml.

Primul este să încărcați complet fișierul xml în memorie și apoi să faceți manipulări pentru a extrage datele.

A doua este opțiunea de streaming. În acest caz, limbajul de programare definește anumite etichete la care trebuie să reacționeze funcțiile parserului xml creat, iar programatorul însuși decide ce trebuie făcut dacă este detectată o anumită etichetă.

Avantajul primei abordări este viteza. Am descărcat fișierul dintr-o dată, apoi am trecut rapid prin memorie și am găsit ceea ce era necesar și, cel mai important, ușor de programat. dar există un minus și unul foarte important - acesta

este necesară o cantitate mare de memorie pentru funcționare. Uneori, aș spune chiar că se întâmplă adesea că este pur și simplu imposibil să procesezi și să analizezi un fișier xml, de exemplu. creați un parser xml, astfel încât prima metodă să funcționeze corect. De ce este așa? Ei bine, de exemplu, limitarea pentru aplicațiile pe 32 de biți sub Windows permite programului să ocupe maximum 2 gigaocteți de memorie - acest lucru nu mai este posibil.

Cu toate acestea, programarea bazată pe fire este dificilă. Complexitatea unei extrageri destul de serioase crește semnificativ, ceea ce afectează în consecință atât perioada de timp, cât și bugetul.

Valabilitatea fișierelor xml și a analizatorilor.

Totul ar fi bine cu fișierele xml și parserii xml, dar există o problemă. Datorită faptului că „orice școlar” poate crea un fișier xml și, în realitate, acesta este cazul (pentru că foarte mult cod este scris de școlari), apar fișiere invalide, adică incorecte Cea mai mare problemă, aceasta este că, uneori, este pur și simplu imposibil să analizezi corect un fișier invalid , de exemplu, faci un parser pe .net, apoi poți crea așa-numitele wrapper-uri, iar cel mai enervant este că faci un astfel de wrapper, apoi îl folosești pentru a citi fișierul creat de „școlarul”. , dar fișierul este invalid și imposibil de citit. Prin urmare, trebuie să scăpați de el și să apelați la opțiuni foarte, foarte nepopulare pentru analizarea unor astfel de fișiere = deoarece mulți oameni creează fișiere xml fără a folosi biblioteci standard și cu aversiune totală Standarde de fișiere xml Este dificil să explice acest lucru clienților. Aceștia așteaptă rezultatul - un parser xml care convertește datele din fișierul original în alt format.

Cum se creează analizoare xml (prima opțiune)

Există un limbaj de interogare pentru datele XML numit XPath. Acest limbaj are două ediții nu vom intra în detalii despre caracteristicile fiecărei versiuni. O idee mai bună a acestui limbaj va fi prezentată prin exemple despre cum să îl utilizați pentru a extrage date. De exemplu.

//div[@class="supcat guru"]/a

ce face aceasta cerere. Este nevoie de toate etichetele pe care le am un ref care conține textul catalog.xml?hid= și această etichetă ar trebui să fie un copil div a cărui clasă este egală cu supcat guru.

Da, s-ar putea să nu fie suficient de clar prima dată, dar poți să-ți dai seama dacă vrei. Punctul de plecare pentru mine este http://ru.wikipedia.org/wiki/XPath și vă sfătuiesc.

Acum vom studia lucrul cu XML.

XML este un format pentru schimbul de date între site-uri.

Este foarte asemănător cu HTML, dar XML permite propriile etichete și atribute.

De ce este necesar XML pentru analizare? Uneori se întâmplă ca site-ul pe care trebuie să îl analizați să aibă un API cu care puteți obține ceea ce doriți fără prea mult efort.

Să presupunem că aveți XML. Poate fi într-un șir sau stocat într-un fișier sau returnat la cerere la o anumită adresă URL.

Lăsați XML-ul să fie stocat într-un șir. În acest caz, trebuie să creați un obiect din acest șir folosind nou SimpleXMLElement:

$str = " Kolya 25 1000 "; $xml = nou SimpleXMLElement($str);

Acum avem în variabilă $xml este stocat un obiect cu XML analizat. Accesând proprietățile acestui obiect, puteți accesa conținutul etichetelor XML. Ne vom uita mai jos cum anume.

Dacă XML-ul este stocat într-un fișier sau trimis prin accesarea unei adrese URL (care este cel mai adesea cazul), atunci ar trebui să utilizați funcția simplexml_load_file, care face același obiect $xml:

Kolya 25 1000

$xml = simplexml_load_file(calea către fișier sau URL);

Metode de lucru

În exemplele de mai jos, XML-ul nostru este stocat într-un fișier sau într-un URL.

Să fie dat următorul XML:

Kolya 25 1000

Să obținem numele, vârsta și salariul angajatului:

$xml = simplexml_load_file(calea către fișier sau URL); echo $xml->nume; //va afișa „Kolya” echo $xml->age; //va imprima 25 echo $xml->salariu; //va scoate 1000

După cum puteți vedea, obiectul $xml are proprietăți corespunzătoare etichetelor.

Poate ați observat că eticheta nu apare nicăieri în recurs. Acest lucru se datorează faptului că este eticheta rădăcină.

Kolya 25 1000

$xml = simplexml_load_file(calea către fișier sau URL); echo $xml->nume; //va afișa „Kolya” echo $xml->age; //va imprima 25 echo $xml->salariu; //va scoate 1000

Îl puteți redenumi, de exemplu, în - și nimic nu se va schimba:

Nu poate exista decât o singură etichetă rădăcină în XML, la fel ca

Kolya 25 1000

în HTML obișnuit.

Să modificăm puțin XML-ul nostru:

În acest caz, vom primi un lanț de apeluri:

$xml = simplexml_load_file(calea către fișier sau URL); echo $xml->lucrător->nume; //va afișa „Kolya” echo $xml->worker->age; //va scoate 25 echo $xml->worker->salary; //va scoate 1000

Lucrul cu atribute

Lasă unele date să fie stocate în atribute:

Numărul 1

$xml = simplexml_load_file(calea către fișier sau URL); echo $xml->worker["nume"]; //va afișa "Kolya" echo $xml->worker["varsta"]; //va scoate 25 echo $xml->worker["salariu"]; //va scoate 1000 echo $xml->worker; //va afișa „Numărul 1”

Kolya Etichete cu cratime

XML permite etichete (și atribute) cu o cratimă. În acest caz, accesarea unor astfel de etichete se face astfel:

Ivanov

$xml = simplexml_load_file(calea către fișier sau URL); echo $xml->worker->(prenume); //va afișa „Kolya” echo $xml->worker->(nume); //va afișa „Ivanov”

Kolya 25 1000 Buclă 26 2000 Să avem acum nu un singur angajat, ci mai mulți. 27 3000

În acest caz, putem itera peste obiectul nostru folosind o buclă foreach:

Vasia

Dacă nu vă simțiți confortabil să lucrați cu obiectul, îl puteți converti într-o matrice PHP normală folosind următorul truc:

$xml = simplexml_load_file(calea către fișier sau URL); var_dump(json_decode(json_encode($xml), true));

Mai multe informații

Analiza bazată pe sitemap.xml

Adesea, un site are un fișier sitemap.xml.

Acest fișier stochează link-uri către toate paginile site-ului pentru ușurința indexării de către motoarele de căutare (indexarea este în esență analizarea site-ului de către Yandex și Google).

În general, nu ar trebui să ne îngrijorăm prea mult de ce este necesar acest fișier, principalul lucru este că, dacă există, nu trebuie să vă accesați cu crawlere paginile site-ului folosind metode complicate, ci pur și simplu să utilizați acest fișier.

Cum să verificați prezența acestui fișier: permiteți-ne să analizăm site-ul site.ru, apoi accesați site.ru/sitemap.xml în browser - dacă vedeți ceva, atunci este acolo, iar dacă nu îl vedeți, apoi vai.

Dacă există o hartă a site-ului, atunci aceasta conține link-uri către toate paginile site-ului în format XML. Luați cu calm acest XML, analizați-l, linkuri separate către paginile de care aveți nevoie în orice mod convenabil pentru dvs. (de exemplu, analizând URL-ul, care a fost descris în metoda spider).

Ca rezultat, obțineți o listă de link-uri pentru analiza, tot ce trebuie să faceți este să accesați ele și să analizați conținutul de care aveți nevoie.

Citiți mai multe despre dispozitivul sitemap.xml pe Wikipedia.

Ce ar trebui să faci în continuare:

Începeți să rezolvați probleme folosind următorul link: probleme pentru lecție.

Când decideți totul, treceți la studiul unui subiect nou. În ultimul articol, tu și cu mine, și am promis că în articolul următor tu și cu mine îl vom analiza. Și astăzi vă voi arăta cum puteți.

analizați documentul XML în PHP

Propun să analizăm documentul pe care l-am creat în ultimul articol și pur și simplu să scoatem datele de acolo în browser. Iată codul de script:
$dom = domDocument nou ("1.0", "utf-8"); // Creați un document XML versiunea 1.0 cu codificare utf-8
$dom->load("users.xml"); // Încărcați un document XML dintr-un fișier într-un obiect DOM
$root = $dom->documentElement; // Obține elementul rădăcină
$copii = $root->childNodes; // Obțineți copiii elementului rădăcină
/* Buclă prin elementele primite */< $childs->pentru ($i = 0; $i
lungime; $i++) (
$utilizator = $copii->item($i); // Obține următorul element din NodeList
$lp = $user->childNodes; // Obține copiii nodului „utilizator”.
$id = $user->getAttribute("id"); // Obține valoarea atributului „id” al nodului „utilizator”.
$login = $lp->item(0)->nodeValue; // Obține valoarea nodului „login”.
$parola = $lp->item(1)->nodeValue; // Obține valoarea nodului „parolă”.
/* Ieșiți datele primite */
";
echo "Autentificare: $login
";
echo „Parolă: $parolă
";
ecou "-----------------------
";
}
?>

Din acest cod nu trebuie doar să înțelegeți cum să analizați documentul XML în PHP, dar și că el procesul de analizare depinde de structura documentului. Adică, trebuie să știți care este structura, altfel analizarea unui astfel de document va fi problematică. Am scris deja o dată că principalul o caracteristică a XML este strictețea sintaxei. Sper că acum înțelegeți de ce este atât de important. Fără asta rigurozitatea codului„Ar fi extrem de greu de analizat documente, iar acest lucru este foarte des solicitat. Elementar la importul unor date din fișier XML iar apoi plasarea lor în baza de date.

Zilele trecute am început să-mi reprocesez sistemul intern de raportare pentru companie, despre a cărui structură generală am scris nu cu mult timp în urmă. Fără prevaricare, voi spune că am crescut deasupra mea în ceea ce privește PHP și, ca urmare, mi-am dat seama că algoritmul sistemului este suficient de strâmb încât să îl rescriu.

Înainte de aceasta, documentul XML a fost analizat folosind funcții care au fost împrumutate din PHP versiunea 4. Cu toate acestea, PHP5 a oferit lumii un lucru foarte convenabil numit SimpleXML. Astăzi vom vorbi despre cum să lucrăm cu el.

Merită să începem cu faptul că SimpleXML este un modul plug-in separat și, prin urmare, trebuie activat în prealabil pe serverul pe care îl utilizați.

Acum putem lucra!

Pentru a procesa documentul, folosim funcția simplexml_load_file(). Ca parametru, i se transmite adresa fișierului în format eXtended Markup Language (XML - Your K.O.).

Frumusețea acestei funcții este că puteți transfera cu ușurință un fișier de pe orice server. Astfel, avem posibilitatea de a procesa încărcări xml externe (de exemplu, Yandex-XML sau fluxuri RSS terțe).

Funcția produce o matrice. Capcanul pe care l-am întâlnit este că XML poate avea o structură neîndemânatică și, prin urmare, vă sfătuiesc să efectuați mai întâi o urmă figurativă și să scoateți o matrice pentru a înțelege cum l-a procesat funcția. După aceasta, puteți începe procesarea datelor primite.

De exemplu, voi lua un design simplu de aici:

>
>
> PHP: Apariția Parserului >
>
>
> Domnișoară Codificator >
> Onlivia Actora >
>
>
> Dl. Codificator >
> El Actor >
>
> > Dl. Analizator > > John Doe > > >
>
Deci este o limbă. Este încă un limbaj de programare. Sau
este acesta un limbaj de scripting? Totul este dezvăluit în acest documentar,
ca un film de groază.
>
>
> PHP rezolvă toate problemele mele web >
>
7>
5>
PG > >
>

Fie ca acesta să fie fișierul export.xml, care se află chiar în rădăcina serverului meu împreună cu scriptul care îl procesează.
Matricea este construită în conformitate cu structura elementelor DOM din documentul XML. Procesarea începe de la rădăcină. Pentru a obține numele de Dna. Coder, trebuie să construim următoarea cale: $xml->movies->movie->characters->character->name.
Vă rugăm să rețineți că alegem o anumită valoare. De aici provine acest tip de notație de caractere - nu uitați că lucrăm cu o matrice!

Ca orice matrice, datele noastre pot fi procesate folosind o buclă foreach. Codul va fi astfel:

$xml = simplexml_load_file ("export.xml"); //fișier încărcat
$ttl = $xml -> filme -> film -> titlu ; //am primit titlul. există doar una, deci nu este nevoie să setați o altă valoare

foreach ($xml -> filme -> film -> caractere ca $crc ) // acum să lucrăm în dinamică
{
//afișează numele eroilor
$nume = $crc -> caracter -> nume ;
ecou(" $nume
" ) ;
}

Acest cod va pune textul „PHP: Parser Appears” în variabila $ttl, apoi va afișa numele eroilor rând cu rând pe ecran.
Domnișoară Codificator, dl. Codificator, dl. Analizator.