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).

 /*
 * 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");
/*
* initializare XPath
*/
$xpath = new DOMXpath($dom);
$xpath->registerNamespace('xsd', '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

last update: 01.2011.

În cadrul UML există 4 tipuri mari de relaţii: relaţii de generalizare, relaţii de asociere, relaţii de realizare şi relaţii de dependenţă.

1) Relaţii de generalizare

Acest tip de relaţii se referă la o structură ierarhică ce aplică principiul moştenirii. Cu alte cuvinte, moştenirea este o relaţie de generalizare care se reprezintă la modul următor: se trasează o linie cu săgeata îndreptată de la subclasă la clasa părinte, săgeata fiind închisă şi goală în interior.

relatie de moştenire

2) Relaţii de asociere

Sunt relaţiile în care o clasă se află în relaţie cu o altă clasă pe o durată mare de timp. Aceste relaţii se nasc în momentul în care o proprietate a unei clase ţine o referinţă către o instanţă a altei clase. Din această cauză, acest tip de relaţie este cel mai răspândit.

relaţie de asociere

Pentru descrierea relaţiei de asociere se folosete o linie simplă (figura 2-A). Pentru descrierea direcţiei de asociere se foloseşte o săgeată simplă, deschisă la bază. Dacă de exemplu, clasa Profesor conţine o instanţă a clasei Student, direcţia se trasează ca în figura 2-B. În cazul în care şi clasa Student ar fi avut o instanţă a clasei Profesor, ar fi rezultat o relaţie de asociere bidirecţională, linia de asociere având săgeţi la ambele capete.

În aceeaşi măsură se pot ţi specifica numărul de instanţe a unei clase având referinţe în cealaltă clasă, după cum se vede în figura 2-B. Numărul acestora se poate scrie ca un număr fix, se poate da ca un interval închis (ex. 1..10) sau ca asterisk (*), care înseamnă 0 sau mai multe.

În cadrul relaţiilor de asociere mai fac parte şi 2 tipuri speciale, agregare şi compoziţie.

relaţie de agregare/compoziţie

Asocierile de aregare descriu o situaţie în care o clasă păstrează o referinţă permanentă a altei clase. Însă unul din elemente poate exista şi în afara relaţiei respective – poate fi conţinut şi de alt obiect în acelaşi timp (figura 3-A). Relaţiile de agregare se reprezintă printr-o linie care începe cu un romb gol.

Asocierile de compoziţie sunt mai puternice decât cele de agregare. O parte nu poate exista în afara întregului. În cadrul unei astfel de relaţii obiectul conţinut poate avea referinţă doar în acea clasă. Relaţiile de acest tip sunt reprezentate de o linie care începe însă cu un romb umplut (figura 3-B).

3) Relaţii de realizare

Sunt relaţiile prin care unul dintre elemente „garantează” realizarea unor acţiuni prin intermediul celuilalt element. În cadrul UML, interfeţele sunt asociate acestui tip de relaţii. Reprezentarea se face prin trasarea unei săgeţi, asemănătoare celei din cadrul moştenirii, doar că linia este discontinuă (figura 4).

relatie de realizare - interfaţă

4) Relaţii de dependenţă

Relaţiile de dependenţă indică o relaţie semantică între două sau mai multe elemente, înă nu descriu o legătură permanentă între clase. O modificare într-unul din obiecte duce la ri semantice la celălalt obiect. Se reprezintă printr-o linie discontinuă având la capăt o săgeată deschisă (figura 5).

relatie de dependenta

Cu acestea am încheiat discuţia referitoare la modul de reprezentare în UML al relaţiilor dintre clase. În ultima parte a acestui articol o să exemplific toate aceste noţiuni pe un exemplu concret, ca să vedem la ce ne ajută practic UML-ul.

Se foloseşte de elemente grafice pentru a reda cât mai bine relaţiile între obiecte, lucru foarte util în cazul exemplelor, unde nu se poate descrie prea bine acest lucru doar prin câteva linii de cod. Unul din aceste elemente este diagrama, cea mai folositoare în asemenea cazuri.

figura 1

Reprezentarea unei clase prin intermediul unei diagrame se face printr-un simplu dreptunghi divizat în 3 compartimente. În cel de sus este trecut numele clasei, la mijloc se specifică lista atributelor, iar în ultima căsuţă operaţiile (figura 1 – A) .

După cum spuneam, numele clasei se reprezintă în prima subdiviziune în mai multe forme. Pentru o clasă normală se scrie pur şi simplu numele său, pentru o clasă abstractă se poate scrie fie italic numele, fie se poate adăuga sub nume o etichetă la modul {abstract} pentru a marca faptul că respectiva clasă este abstractă (figura 1 – B ), iar pentru o interfaţă se adaugă o etichetă la modul « interface » (figura 1 – C).

Lista atributelor se referă la proprietăţile unei clase şi după cum spuneam, acestea sunt scrise în centru (figura 2).

figura 2

După cum se vede şi în figura 2, pentru fiecare atribut se specifică:

1. nivelul de acces : acesta poate fi + (public), – (private) sau # (protected)
2. numele
3. tipul de date
4. valoarea default dacă este cazul, dacă nu, se omite

Asemănător cu lista atributelor se specifică şi operaţiile clasei.Operaţiile unei clase reprezintă metodele sale. Lista acestora se specifică precum în figura 3.

figura 3

Pentru fiecare metodă în parte se specifică următoarele:

1. nivelul de acces : acesta poate fi + (public), – (private) sau # (protected)
2. numele
3. lista parametrilor, pentru fiecare specificându-se numele şi tipul (evident pot lipsi)
4. tipul de date returnat (care de asemenea poate lipsi)

De precizat este faptul că atât în cazul atributelor, cât şi al proprietăţilor nu este necesară trecerea întregii liste, ci doar a acelora care sunt importante în contextul dat.

Acestea fiind spuse, am încheiat prima parte a acestei serii de articole pe tema UML. În următoarele voi vorbi despre modul de figurare a relaţiilor dintre obiecte şi la final voi exemplifica totul pe un exemplu practic .

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.

$data = array();

function adauga_carte( $titlu, $autor, $pagini, $editura, $pret )
{
global $data;

$data[] = array( 'titlu' => $titlu,
'autor' => $autor,
'pagini' => $pagini,
'editura' => $editura,
'pret' => $pret
);
}

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

$dom = new DOMDocument();
$xml = $dom->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ă.

//prima linie este ignorată

$first_row = true;

foreach ( $rows as $row )
{
if ( ! $first_row )
{
$titlu    = "";
$autor    = "";
$pagini   = "";
$editura  = "";
$pret     = "";
$index = 1;

$cells = $row->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:

echo '


';

foreach ( $data as $row )
{
echo '


';
}

echo '


titlu:
autor:
pagini:
editura:
pret:

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


';

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

mysql_connect( "localhost", "user", "pass" );
mysql_select_db( "db_name" );

$i = 0;

foreach ( $data as $row )
{
$inserted = mysql_query( "INSERT INTO `carti` ( titlu, autor, pagini, editura, pret )
VALUES ( '".$row['titlu']."', '".$row['autor']."', '".$row['pagini']."', '".$row['editura']."', '".$row['pret']."' )"
);

if ( $inserted ) $i++;
}

echo 'Au fost introduse ' . $i . ' carti.';

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.

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.

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.

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

National Bank of Romania
2008-09-25
DR


Reference rates
RON

2.0985
1.8802
2.4202
2.3059
0.1505
0.4930
0.4583
3.6773
4.6475
1.5275
2.3608
0.2414
0.4452
1.1040
0.1000
0.3800
0.1214
2.0194
2.5001
71.4560
3.9396

(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:

/*
* 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 . "
";
}
}

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ă