Posts Tagged ‘xml’

Se mai întâmplă uneori să avem nevoia de a prelucra nişte date pe care le avem ţinute în fişiere excel. Dacă sunt câteva înregistrări e totul bine şi frumos, însă atunci când sunt la un loc câteva sute de înregistrări trebuie găsită o variantă mai uşoară pentru preluarea şi prelucrarea lor.

Să presupunem că avem următoarele înregistrări în fişierul nostru excel:

Datele reprezintă nişte cărţi, coloanele însemnând: Titlu, Autor, Pagini, Editură şi Preţ.

Metoda pe care vă voi prezenta în cele ce urmează foloseşte extensia de care v-am mai vorbit acum ceva vreme, DOM. După cum spuneam şi atunci, DOM prelucrează fişiere XML. Aşadar primul pas pe care trebuie să-l facem este de a salva fişierul excel ca „XML Spreadsheet”.

Fişierul în cauză conţine foarte multe taguri, însă partea care ne interesează pe noi este următoarea:

Enigma Otiliei
George Calinescu
401
Eminescu
20.440000000000001


La Tiganci
Mircea Eliade
188
Tana
9


Jocul Ielelor
Camil Petrescu
384
Gramar
15

Datele noastre sunt aflate în interiorul tagurilor „Worksheet”. În funcţie de câte sheet-uri avem în documentul excel, atâtea taguri worksheet va conţine şi fişierul nostru xml. În cadrul fiecărui Worksheet avem tagul „Table” cu ale lui „Row” (linie) şi „Cell” (coloană). În funcţie de câte linii aveam completate în document, tot atâtea taguri „Row” vom avea şi în interiorul tagului „Table”.  Valorile fiecărei coloane sunt stocate în interiorul tagului „Data”.

Ok, să ne întoarcem acum la fişierul php. Pentru început declarăm array-ul în care stocăm înregistrările şi declarăm o funcţie pentru adăugarea lor mai uşoară în acest tablou.

 $titlu,
'autor' => $autor,
'pagini' => $pagini,
'editura' => $editura,
'pret' => $pret
);
}
?>

Următorul pas este citirea documentului nostru şi a tagurilor (liniile tabelului) „Row”.

load( 'Book1.xml' );

$rows = $xml->getElementsByTagName( 'Row' );
?>

După ce am citit toate liniile tabelului, pentru fiecare în parte căutăm coloanele (tagurile „Cell”). În acest moment trebuie să ne dăm seama în care coloană ne aflăm. Tagul „Cell” are un atribut „ss:Index„ care ne indică poziţia în cazul în care sunt coloane goale pe linia curentă.

getElementsByTagName( 'Cell' );

foreach ( $cells as $cell )
{
$ind = $cell->getAttribute( 'Index' );

if ( $ind != null ) $index = $ind;

if ( $index == 1 ) $titlu      = $cell->nodeValue;
if ( $index == 2 ) $autor      = $cell->nodeValue;
if ( $index == 3 ) $pagini   = $cell->nodeValue;
if ( $index == 4 ) $editura  = $cell->nodeValue;
if ( $index == 5 ) $pret     = $cell->nodeValue;

$index += 1;
}

adauga_carte( $titlu, $autor, $pagini, $editura, $pret );
}

$first_row = false;
}
?>

În acest moment array-ul nostru conţine toate înregistrările din fişierul sursă. Dacă dorim să-l vizualizăm pe ecran pentru verificare, putem pur şi simplu să-l afişăm sub formă de tabel stil excel:

titlu:
autor:
pagini:
editura:
pret:


';

foreach ( $data as $row )
{
echo '

' . $row['titlu'] . '
' . $row['autor'] . '
' . $row['pagini'] . '
' . $row['editura'] . '
' . $row['pret'] . '


';
}

echo '

';
?>

Dacă totul este în regulă, îl inserăm în baza de date:

Cam asta este procedura pe care eu o folosesc atunci când trebuie să lucrez cu fişierele excel. Este un procedeu de bază realizat pentru un caz particular. Evident se poate îmbunătăţi considerabil, însă nu acesta era scopul exemplului.

Ca urmare a ultimului articol, voi continua acum descrierea modalităţilor de lucru cu xml din php. De această dată este vorba de DOM.

Parserele de tip DOM construiesc în memorie întregul arbore de resurse. Acesta poate fi ulterior parcurs, şters, modificat, adăugat. Un avantaj al DOM constă în flexibilitatea mai mare oferită faţă de SimpleXML, cu preţul unei complexităţi sporite.

Extensia DOM (specifică php5) este exclusiv orientată pe obiecte. Principala clasă este DOMNode, din care derivă DOMDocument, DOMElement, DOMAttr, DOMComment, DOMText. Celelalte două clase disponibile sunt DOMNodeList şi DOMXPath.

Încărcarea codului xml se poate face din fişier sau string, prin instanţierea unui obiect de tip DOMDocument urmat de apelarea metodelor de încărcare: load şi loadHTMLFile (din fişier), respectiv loadHTML şi loadXML (din string).

$xml = new DOMDocument();

$xml->load("fisier.xml");

$xml->load("http://adresa_web/fisier.xml");

$string = file_get_contents("fisier.xml");

$xml->loadXML($string);

Parcurgerea unui arbore de tip DOM şi accesul la resurse se face printr-o multitudine de metode şi câmpuri puse la dispoziţie de toate clasele DOM. Lista lor este foarte mare şi de aceea voi menţiona doar câteva, cele mai importante.

Să luăm drept exemplu acelaşi fişier ca şi în prima parte a articolului:

unitatea 0


unitatea 1
1500 lei


unitatea 2
1200 lei


unitatea 3
3500 lei

Parcurgerea acestui fişier se poate face în felul următor:

$xml = new DOMDocument();

$xml->load("fisier_de_mai_sus.xml");

echo $xml->nodeName; // afiseaza #document

echo $xml->firstChild->nodeName; // afiseaza unitati

echo $xml->firstChild->firstChild->nodeName; // afiseaza server

foreach ( $xml->firstChild->childNodes as $s) echo $s->nodeName . " "; // afiseaza server calculator calculator calculator

foreach ( $xml->DocumentElement as $nod )
{
echo $nod->nodeName;

if ( $nod->hasAttributes() )
{
foreach ( $nod->attributes as $a )
{
echo $a->name . ": " . $a->value . "
"; //afiseaza nume_atribut: valoare_atribut
}
}

echo "
";
}

Bun, acum să luăm pe rând să vedem ce am folosit mai sus pentru parsarea fişierului.

• Câmpul nodeName din clasa DOMNode afişează numele nodului. Pentru elemente returnează numele tagului, iar pentru noduri text #text.
• Câmpul firstChild ( sau lastChild ) desemnează primul/ultimul nod copil al nodului curent
• childNodes returnează lista de noduri copil
• documentElement returnează elementul rădăcină al fişierului xml
• metoda hasAttributes returnează true/false dacă elementul are atribute sau nu
• Câmpul attributes returnează lista de atribute ale unui nod, sub forma unui obiect iterabil. pentru afisarea lor se folosesc câmpurile clasei DOMAttr, name şi value.

De asemenea se pot adăuga noduri la obiectul curent prin metodele clasei DOMNode, appendChild sau insertBefore, iar asocierea de atribute se poate face prin metoda setAttribute, a clasei DOMElement.

Dacă dorim, putem crea de la zero un document xml folosind metoda createElement a clasei DOMDocument, pentru crearea de elemente, createAttribute, pentru adăugare de atribute şi createTextNode, pentru adăugarea de PCDATA.

Spuneam la început că se pot folosi şi interogări XPath pentru parcurgerea codului XML. Clasa care ajută la acest lucru este DOMXPath. Prinicipala metodă a acestei clase este query, care primeşte ca argument expresia XPath şi returnează nodurile găsite sub forma unui obiect de tip DOMNodeList ce se poate itera.

Extensia DOM este foarte puternică pentru lucrul cu fişiere XML şi din acest motiv, foarte complexă. Dacă doriţi să cunoaşteţi mai multe desprea ea puteţi să începeţi cu documentaţia de pe site-ul oficial.

Pentru lucrul cu XML există 2 extensii disponibile în PHP, SimpleXML şi DOM. În următoarele 2 articole voi vorbi pe rând despre fiecare dintre ele, iar la final voi scrie nişte avantaje şi dezavantaje pentru fiecare.

SimpleXML

După cum spune şi numele, extensia SimpleXML este intuitivă şi uşor de învăţat. Ea a fost dezvoltată ca o soluţie intermediară între DOM şi SAX: are un consum de resurse mic, precum SAX, însă nu este aşa de flexibilă, precum DOM.

SimpleXML prezintă funcţii ce permit încărcarea de cod XML din fişiere, string-uri sau noduri DOM.

//încarcare din fişier
$xml = simple_xml_load_file("fisier_sursa.xml");

//încarcare din string
$string = file_get_contents("fisier_sursa.xml");

$xml = simplexml_load_string($string);

De asemenea acest lucru se poate realiza şi prin utilizarea clasei SimpleXMLElement (principala clasă a SimpleXML):

$xml = new SimpleXMLElement("fisier_sursa.xml", null, true);

După încărcarea codului XML, conţinutul poate fi parcurs foarte uşor folosind membrii clasei SimpleXMLElement.

Să presupunem că fişierul sursă invocat mai sus are următorul conţinut:

unitatea 0


unitatea 1
1500 lei


unitatea 2
1200 lei

unitatea 3
3500 lei

Un obiect de tip SimpleXMLElement corespunde fiecarui element din XML, în cazul de mai sus fiind chiar elementul rădăcină. Pentru aflarea numelui se foloseşte metoda getName().

echo $xml->getName(); // va afişa unitati

În cazul acestei extensii sub-elementele sunt tratate precum câmpuri ale obiectului definit, fiecare element copil având un câmp cu numele său.

$server = $xml->server; // $c devine un obiect SimpleXMLElement

echo $server->nume; // va afisa unitatea 0

În cazul în care există mai multe sub-elemente cu acelaşi nume, ele vor fi construite ca un array şi se vor putea apela asemeni acestora.

$calculatoare = $xml->calculator; //preiau toate sub-elementele calculator

foreach ( $calculatoare as $calculator ) echo $calculator->nume; //va afişa pe rând fiecare numele

Conţinutul PCDATA se poate obţine prin conversia la string a unui obiect SimpleXMLElement.

echo $server->nume; // va afisa unitatea 0

Atributele fiecărui element se pot accesa sub forma unui tablou asociativ, având forma elementului căruia aparţin.

echo $server['tip']; //va afişa pc

De asemenea pentru atributele unui element se mai poate folosi şi metoda attributes(), care extrage atributele sub forma unui tablou asociativ de obiecte de tip SimpleXMLElement.
Pe scurt, cam aşa se prezintă extensia SimpleXML. După cum spuneam la început, este foarte intuitivă şi uşor de învăţat. Pentru a nu lungi însa prea mult acest post voi vorbi despre cealaltă extensie pentru lucrul cu fişiere xml în următorul articol.