Posts Tagged ‘PHP’

În toate limbajele de programare există aşa numitele „Standarde de codare” (sau Coding Standards). În general există 2 standarde de codare, diferenţa constând în felul în care sunt poziţionate acoladele:

Primul stil (C++ Coding Standards):

function foo()
{
    echo 'bar';
}

După cum se observă, peste tot pe unde este necesară deschiderea unei acolade, aceasta se poziţionează pe rândul următor, închiderea ei făcându-se cu un rând mai jos decât ultima linie de cod a blocului respectiv, pe aceeaşi linie verticală cu perechea ei de începere. Foarte pe larg aici.

Un exemplu complet de cod scris în acest stil ar putea arăta aşa:

public function setParams( $params )
{
    if ( empty( $params ) )
    {
        $this->__request['params'] = null;
    }
    else
    {
        $keys = $values = array();
        $count = count( $params );

        for( $i = 0; $i < $count; $i++ )
        {
            $param = $this->getAlpha( $params[$i] );
            $i % 2 == 0 ? $keys[] = $param : $values[] = $param;
        }

        $this->__request['params'] = array_combine( $keys, $values );
    }
}

Avantaje:

• Lizibilitate sporită
• Urmărire rapidă a codului, acoladele fiind poziţionate pe aceeaşi linie verticală

Dezavantaje:

• Număr de linii mai mare ocupat de cod

Cel de-al doilea stil (PEAR style):

function bar() {
    echo 'foo';
}

În acest caz, deschiderea acoladelor se face pe acelaşi rând cu instrucţiunea, iar închiderea ei se face la fel ca în primul caz. Descriere completă aici.

Un exemplu complet de cod s cris în acest stil ar putea arăta aşa:

public function relative($offset) {
    // which absolute row number are we seeking
    $pos = $this->cursorPos + ($offset - 1);
    $ok = $this->seek($pos);

    if ($ok === false) {
        if ($pos < 0) {
            $this->beforeFirst();
        } else {
            $this->afterLast();
        }
    } else {
        $ok = $this->next();
    }

    return $ok;
}

Avantaje:

• Număr de linii mai mic ocupat de cod

Dezavantaje:

• Lizibilitatea este scăzută
• Codul este greoi de urmărit, un factor fiind chiar poziţionarea acoladelor pe diagonală

Pentru mine, cel mai bun stil de programare (şi cel pe care de altfel îl folosesc) este primul dintre cele două. Un prim factor în alegerea acestui stil a fost scrierea de cod curat şi uşor de urmărit, care să nu obosească ochii. Pe urmă, eu începând programarea cu C++, am utilizat intens acest stil şi m-am obişnuit cu el fără probleme.

Însă aceste standarde nu sunt bătute în cuie. Fiecare îşi poate defini propriul standard, pornind de la cele două şi adaptând după cum se simte mai bine. De exemplu, după cum se observă şi în a doua bucată de cod postată mai sus, eu am decis a utiliza şi o spaţiere permanentă, tocmai pentru a spori gradul de lizibilitate (pe larg despre stilul ăsta aici).

Acum ceva vreme am postat o modalitate rapidă de a preluat cursul valutar complet de la bnr. Azi un prieten căuta o modalitate la fel de rapidă de a prelua cursul valutar, însă doar pentru USD şi EURO, fără să preia toate valutele şi să verifice dacă sunt cele dorite. Cum se poate rezolva lucrul ăsta? Răspunsul este XPath.

<?php
 /*
 * initiez clasa DOMDocument, reprezentand fisierul xml incarcat
 */
 $dom = new DOMDocument();
 $dom->preserveWhiteSpace = false;

 /*
 * incarc fisierul xml, specificand adresa completa
 */
 $dom->load( "http://www.bnro.ro/nbrfxrates.xml" , 'http://www.bnr.ro/xsd');

 /*
 *  preiau intr-un obiect iterabil (DOMNodeList) lista elementelor ce indeplinesc doleantele mele
 */
 $valute = $xpath->query( "xsd:Body/xsd:Cube/xsd:Rate[@currency='USD' or @currency='EUR']" );
 /*
 * verific daca sunt elemente de acest tip
 */

 if ( $valute )
 {
 $new_valute = array();

 /*
 * in caz afirmativ, iterez prin ele si le preiau intr-un array ce-mi convine
 */
 foreach ( $valute as $valuta )
 {
 $new_valute[$valuta->getAttribute('currency')] = $valuta->nodeValue;
 }
 }
 ?>

Prin XPath putem selecta rapid doar elementele care corespund anumitor criterii, căutând după o cale (path) indicată de noi.  În cazul în care fişierul xml conţine namespace-uri (ca în cazul acesta) ele trebuie anunţate la început, pentru că altfel nu vom primi nici un rezultat. Good luck

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.

azi mi-au sosit şi ultimele 2 cărţi din cele 4 pe care le comandasem cu vreo lună înainte (happy happy, joy joy ).

books

poate o să fac şi nişte review-uri la ele în funcţie de cum le termin de citit .

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.

Azi am fost nevoit să preiau cursul valutar de pe site-ul bnr pentru a-l stoca în baza de date.  Ştiu că erau pe nu ştiu ce site-uri puse la dispoziţie coduri care fac treaba asta, însă după mine într-o manieră foarte alandala. După mine cel mai simplu de parsat un fişier xml (cum este cel pus la dispoziţie de bnr) este folosind extensiile puse la dispoziţie de php, SimpleXML şi DOM. Eu am ales să folosesc DOM, deoarece rezolvă foarte repede ceea ce am avut nevoie.

Structura fişierului xml care trebuie parsat este urătoarea:

[sourcecode language='xml']

[/sourcecode]

(evident documentul nu este valid, dar nu ne interesează asta )

După cum se observă, ce trebuie noi să facem este preluarea tuturor tagurilor cu numele „Rate”.  Apoi preluăm  numele valutei folosind metoda getAttribute, care returnează valoarea atributului cu numele specificat.

Iată codul care pune în aplicare cele spuse mai sus:

[sourcecode language='php']

/*
* initiez clasa DOMDocument, reprezentand fisierul xml incarcat
*/
$dom = new DOMDocument();
/*
* incarc fisierul xml, specificand adresa completa
*/
$dom->load( “http://www.bnro.ro/nbrfxrates.xml” );

/*
* preiau intr-un obiect iterabil lista elementelor(tagurile) cu numele specificat
*/
$valute = $dom->getElementsByTagName(‘Rate’);

/*
* verific daca sunt elemente de acest tip
*/
if ( $valute->length != 0 )
{
/*

* in caz afirmativ, iterez prin ele si le afiez

* ( evident le pot stoca intr-un array sau chiar in baza de date,

* dupa caz)
*/
foreach ( $valute as $valuta )
{
echo $valuta->getAttribute(currency). ” – ” .$valuta->nodeValue . “
“;
}
}

[/sourcecode]

Dacă nu punem la socoteală, liniile comentate, putem prelua codul bnr în doar 8 linii de cod ! În acelaşi mod se pot prelua şi diferite feed-uri de pe diverse site-uri. Baftă

Iata ce am gasit azi pe phpromania:

Ma intreb acum, oare e pe bune?! sau este doar o pacaleala de 1 Aprilie, avand in vedere ca forumul inca merge…