UNIVERSITATEA DE VEST TIMIŞOARA

FACULTATEA DE MATEMATICĂ ŞI
INFORMATICĂ
DEPARTAMENTUL DE INFORMATICĂ

LUCRARE DE LICENŢĂ

STUDENTĂ: COORDONATOR:
OLARU NICULINA BIANCA LECT. HORIA POPA

TIMIŞOARA
IUNIE 2007

1
 Cuprins
Introducere..............................................................................................................4
......................................................................................................................5
Capitolul 1........................................................................................................................6
1.1 Avantajele limbajului PHP......................................................................................6
1.2 Sintaxa PHP...............................................................................................................7
1.3 Comentarii.................................................................................................................8
...............................................................................................................................8
1.4 Tipuri de date în PHP.................................................................................................8
1.5 Variabile.....................................................................................................................9
1.6 Constante..................................................................................................................11
1.7 Operatori.................................................................................................11
1.8 Expresii..............................................................................................14
1.9 Tablouri...................................................................................15
1.10 Structuri de control...................................................................................16
1.10.1 Instrucţiuni conditionale..................................................................16
1.10.2 Instrucţiuni repetitive...................................................................................18
1.11 Funcţii....................................................................................................19
1.11.1 Funcţii predefinite .....................................................................20
1.11.2 Funcţii utilizator .................................................................20
............................................................................................................21
1.11.3 Transmiterea parametrilor............................................................21
1.11.4 Funcţii recursive..............................................................................................21
1.12 Clase şi obiecte.......................................................................................................21
1.12.1 Definirea unei clase.........................................................................................21
1.12.2 Constructori.....................................................................................................22
1.12.3 Moştenire........................................................................................................23
1.13 Reutilizarea codului ............................................................................................23
..................................................................................................................................23
1.13.1 Instrucţiunea require.......................................................................................23
1.13.2 Instrucţiunea include.....................................................................................24
1.14 Controlul sesiunilor................................................................................................24
Capitolul 2......................................................................................................................26
2.1 Noţiuni generale.......................................................................................................26
2.2 Proiectarea unei baze de date...................................................................................27
Normalizarea unei baze de date relaţionale.....................................................27
2.3 Elemente de limbaj ..................................................................................................28
2.3.1 Comentarii ..........................................................................28
2.3.2 Tipuri de date....................................................................................................28
.......................................................................................................................30
2.3.3 Operatori .....................................................................................................30
.......................................................................................................................................31
....................................................................................................................................31
2.4 Crearea unei baze de date şi gestiunea acesteia.......................................................31
2.4.1 Crearea unei tabele............................................................................................31

2
 2.4.2 Ştergerea unei tabele.........................................................................................32
2.4.3 Inserarea datelor în tabele....................................................................32
2.4.4 Ştergerea datelor din tabele.................................................................34
2.4.5 Extragerea informaţiilor din tabele.......................................................34
2.5 Folosirea alias-urilor................................................................................................36
2.6 Accesul la o bază de date................................................................................36
2.6.1 Utilizatori şi parole .....................................................................................36
..................................................................................................................37
2.6.2 Privilegii MySQL..........................................................................37
....................................................................................................................................39
...................................................................................................................................39
................................................................................................................................40
Capitolul 3......................................................................................................................40
3.1 Conectarea la serverul MySQL................................................................40
3.2 Interogări.................................................................................41
3.3 Căutarea şi afişarea rezultatelor........................................................................42
Concluzii........................................................................................................................43
......................................................................................................................................43
Bibliografie....................................................................................................................44

3
 Introducere

Într-o epocă modernă ca aceasta în care trăim, poţi rezolva totul cu ajutorul
internetului printr-un simplu ‘click’ – o singură apăsare a mouse-ului şi ai cumpărat
rochia pe care ţi-o doreai sau ai aflat ultimele ştiri. Nu ai mai intrat demult într-o librărie,
dar ai acasă toată colecţia semnată Coelho, fie că trăieşti într-un mare oraş sau într-un
oraşel provincial, dacă ai acces la internet poţi face orice. Totuşi, pentru ca aceste lucruri
să se întample mulţi oameni lucrează la actualizarea paginilor, la menţinerea acestora sub
o formă interesantă, care să atragă mereu vizitatori.

Cum internetul este într-o continuă dezvoltare, şi nevoia de a implementa pagini

web dinamice creşte. Ce ar fi dacă pentru un magazin online, de exemplu, ar trebui
modificate preţurile săptămânal? Asta ar însemna rescrierea sutelor de resurse HTML, şi
un timp exagerat de mare. Şi la aceasta se mai adaugă şi faptul că designul şi conţinutul
unui site sunt realizate de persoane total diferite, ceea ce îngreunează şi mai tare
realizarea de actualizări ale paginilor web.

Prin proiectarea unui site fundamentat pe o bază de date se poate rezolva

această problemă. Se realizează separarea dintre design şi conţinut, astfel că este
suficient să scrii o pagină pentru un anumit tip de informaţie, fără a fi nevoie să copiezi
mereu în vechile pagini conţinutul cel nou. Implementarea unui sistem de gestiune a
conţinutului le va permite celor ce au modificări de facut să le realizeze singuri fără să
fie nevoie de cunoştinţe HTML.
Pentru proiectarea unui astfel de site există mai multe opţiuni în ceea ce
priveste limbajul de programare, cât şi sistemul de management al bazei de date.
Trebuie avut în vedere faptul că nu toate limbajele de programare se pot conecta la
toate bazele de date. Cea mai potrivită alegere pentru realizarea unui web site dinamic
este utilizarea PHP şi MySQL .

PHP este un limbaj de scripting utilizat pe scară largă, realizat şi distribuit în

sistem Open Source, care este special realizat pentru a dezvolta aplicaţii web, prin
integrarea codului PHP în documente HTML. Acestea nu vor mai fi simple pagini web,
iar serverul care le încarcă văzând că este vorba despre pagini php le va trimite
interpretorului PHP şi va primi înapoi transformat prin interpretarea codului PHP. Acest
fişier va conţine doar cod HTML (eventual şi JavaScript) dar nu şi cod PHP.

MySQL este un limbaj de interogare standard pentru interacţiunea cu bazele

de date, un pachet software care se ocupă de organizarea şi gestiunea cantităţilor mari
de informaţie.
Apache este un server web open-source pentru UNIX, Windows 2000 sau alte
platforme. Apache a devenit în prezent cel mai popular şi des folosit Web server,
datorită caracteristicilor puternice şi a perfomanţelor excepţionale.

4
 Prin intermediul acestei lucrări voi prezenta avantajele combinării celor doua
tehnici de programare (PHP şi MySQL) şi tehnica de creare a unor pagini web cu
conţinut dinamic şi actualizat, implementate cu ajutorul acestora. Aplicaţia realizată în
scopul susţinerii acestei lucrări este o pagină de poezii online.

Lucrarea de faţă este structurată în mai multe capitole astfel :

♦ Primul capitol cuprinde noţiuni fundamentale despre limbajul PHP specificând

avantajele acestuia, tipurile de bază, proprietăţile de bază, operatori, structuri de control,
tablouri, funcţii, clase, obiecte, refolosirea codului si controlul sesiunilor.

♦ Capitolul doi prezintă bazele de date relaţionale, începând cu informaţii

introductive despre sistemul de gestiune a bazelor de date MySQL : utilitatea,
caracteristicile şi avantajele sale şi continuând cu procesul de concepere şi de proiectare a
unei baze de date relaţionale, normalizarea unei baze de date, relaţiile între tabele şi tipuri
de date. Urmează prezentarea serverul de baze de date MySQL împreună cu noţiuni SQL
legate de operatori şi funcţii, implementarea, crearea, ştergerea, modificarea, sortarea în
baze de date.

♦ Capitolul trei combină cele două tehnici de programare PHP şi MySQL si

prezintă modul de conectare la baza de date prin intermediul limbajului PHP şi diverse
operaţii efectuate asupra bazei de date.

♦ Capitolul patru prezintă dezvoltarea aplicaţiei, pagina de poezii online, de la

crearea bazei de date şi conectarea la aceasta, la forma finală în care utilizatorul poate
accesa pagina de internet.

În încheiere, există o secţiune de Concluzii şi o listă cuprinzătoare de referinţe

bibliografice.

5
 Capitolul 1

Limbajul PHP

Limbajul PHP este o modaliatate eficientă de dezvoltare a aplicaţiilor Web, în

mod dinamic. El a fost implementat în 1994 de către Rasmus Lerdorf, la început fiind
vorba numai de un proiect personal, care cuprindea câteva scripturi PERL ce
monitorizau accesul la pagina web a acestuia. În 1995 este disponibil sub numele de
Personal Home Page. Pentru a-i oferi mai multă funcţionalitate el a implementat o
varianta în C care permitea accesul la baze de date oferind astfel posibilitatea de creare a
paginilor web dinamice. Începand cu versiunea 3, din 1997, acest limbaj a început să
fie dezvoltat de o echipă de programatori, iar versiunea 4 dispune de engine-ul de
scripting al firmei Zend Techologies. Programul a fost corectat, dezvoltat şi extins
în regim open source, depăşind cu mult scopul său iniţial. Numele s-a păstrat, dar
semnificaţia este alta, şi anume : Hypertext Preprocessor.
Pentru a crea şi testa documente PHP este nevoie de instalarea lor pe un server de
web, deoarece dacă un fisier PHP este încarcat direct în navigator de pe discul local, prin
comanda File/Open, fără a apela un server de web, documentul afisat va contine codul
PHP neinterpretat.

1.1 Avantajele limbajului PHP

Un mare avantaj al limbajului PHP este faptul că este un limbaj inter-platformă şi

este gratuit.Poate fi utilizat pe orice calculator fără nici un fel de costuri.
PHP oferă programatorului libertatea de a alege un sistem de operare şi un server
de web. El poate fi folosit pe aproape toate marile sisteme de operare, incluzând Linux,
multe variante de Unix (incluzând HP-UX, Solaris şi OpenBSD), Microsoft Windows,
Mac OS X. PHP are deasemenea suport pentru majoritatea serverelor de web din
prezent: Apache, Microsoft Internet Information Server, Personal Web Server, Netscape
şi iPlanet şi altele. Pentru majoritatea serverelor PHP are un modul, iar pentru celelalte
suportă standardul CGI, PHP putând să lucreze ca un procesor CGI.
Una dintre cele mai puternice şi importante facilităţi în PHP este suportul său
pentru o gama largă de sisteme de baze de date, cum ar fi : MySQL, Oracle, Informix,
Sybase, PostgreSQL. De asemenea se pot realiza conexiuni practic cu orice sistem care
ofera un driver de ODBC (Open Database Connectivity standard).
PHP oferă posibilitatea de afişare de imagine, fişiere PDF şi chiar filmuleţe
Flash (folosind librăriile libswf şi Ming) toate generate instant. Deasemeanea,
rezultatul poate să fie orice fişier text, cum ar fi XHTML sau orice alte fişiere XML.

6
PHP poate genera automat aceste fişiere şi să le salveze în sistemul de fişiere în loc să
le afişeze, formând un cache de partea serverului pentru conţinutul dinamic.
Deoarece PHP a fost scris special pentru crearea de pagini Web dinamice, poate
efectua mult mai rapid şi mai eficient unele operaţii, în comparaţie cu competitorii săi
Perl ,VCScript, Java, care nu au fost creaţi special pentru crearea de pagini Web .Cu
toate acestea, nu înseamnă că PHP este un limbaj de programare mai bun decat celelalte,
deoarece există actiuni pe care Java, Perl le pot efectua si PHP nu este capabil să le
efectueze,însă PHP este mult mai bun pentru domeniul pentru care a fost creat.
Unul din principalele avantaje PHP este faptul că e relativ simplu şi direct, de
aceea PHP este mult mai uşor de învaţat şi de utilizat faţă, spre exemplu , de ASP.NET
care necesită cunoasterea unor noţiuni de VCScript, C# ,sau faţă de CGI care necesită
cunostinţe de Perl sau de C.
PHP nu are probleme de compatibilitate cu browserul. Scripturile PHP sunt
interpretate de server şi nimic mai mult, asadar nu trebuie să ne facem griji dacă limbajul
în care dezvoltam este recunoscut de browserele utilizate de clienti. PHP permite o
încarcare mai rapidă pe partea clientului. JavaScript ar incetini afişarea unei pagini web
pe calculatoare mai slabe, deoarece browserul trebuie să ruleze scriptul mai întâi ; în
cazul interpretării de catre server, sarcina aceasta este transferată maşinii serverului web.
Un alt mare avantaj alt limbajului PHP este acela că oferă posibilitatea de a
alege programarea procedurală sau programarea orientată obiect, sau chiar ambele. Cu
toate acestea, nu orice facilitate a standardului POO este prezentă în versiunea curentă
PHP-ului, multe librării de cod şi aplicaţii mari (incluzând şi librăria PEAR) sunt scrise
folosind doar cod POO.

1.2 Sintaxa PHP

Pentru generarea dinamică de conţinut pentru paginile web, scripturile sunt
incluse în pagini HTML.Când primeşte un script de la serverul web, interpretorul PHP
caută anumite tag-uri speciale care anunţă existenţa codului PHP, pe care o
interpretează, lăsând nemodificat codul HTML existent. Există mai multe modalitaţi de
a insera codul PHP într-o pagina HTML.
Cea mai simplă varianta este cea scurtă, care oferă o viteză mai mare de scriere
a codului :
<? Cod_PHP ?>
O altă posibilitate este cea în stil XML, acesta fiind compatibilă cu documentele
XML (Extensible Markup Language) :
<?php Cod_PHP ?>
O a treia variantă este cea a stilului SCRIPT, destinată în special celor obişnuiţi
cu scrierea de cod JavaScript sau VBScript.
<SCRIPT LANGUAGE='php'> Cod_PHP </SCRIPT>
Ultima posibilitate este cea în stil ASP, şi este utilă doar dacă se foloseste un
editor HTML care genereaza cod ASP pentru serverele Microsoft:
<% Cod_PHP %>
Din toate aceste posibilităţi doar doua (<?php. . .?> şi <script language="php">
. . .</script>) sunt întotdeauna valabile; celelalate pot fi oprite din fişierul de
configurare php.

7
 În dezvoltarea aplicaţiei am folosit stilul XML care tinde să fie utilizat tot mai
des.
La scrierea codului, instrucţiunile PHP din script vor fi terminate printr-un
separator punct şi virgulă ';' asemănător celor din limbajul C, C++ sau Java. Omiterea
acestui separator va genera o eroare de sintaxă. Interpretorul de PHP va ingnora în
schimb spaţiile dintre instrucţiuni sau dintre elementele unei instrucţiuni.
Exemplu :
1 : <?php echo "Hello"; echo "world !"; ?>
2 :<?php echo "Hello";
echo "world !" ;?>
Rezultatul va fi acelaşi.
1.3 Comentarii
Pentru claritatea codului programatorii obişnuiesc să explice rolul anumitor linii
din cadrul programului incluzând anumite comentarii. Interpretorul de PHP va ignora
textul din comentarii.
O modalitate de a insera un comentariu este cea în stilul C, când comentariul se
poate întinde pe mai multe linii şi este cuprins între semnele '/*' şi '*/'. El se poate insera
chiar şi în mijlocul unei expresii dar nu poate fi imbricat în alt comentariu.
Exemplu : < ?php /* linii de cod*/ ?>
Pentru un comentariu care se întinde până la sfarşitul liniei curente există două
posibilităţi : stilul C++ şi stilul Shell.
Exemplu : < ?php //linie de cod ?>
< ?php #linie de cod ?>

1.4 Tipuri de date în PHP

Fiecare limbaj de programare are diferite tipuri de date.Limbajul PHP suportă
opt tipuri primitive de date, dintre care patru scalare :

Boolean este cel mai simplu şi conţine o valoare de adevar. Poate conţine unul
din urmatoarele cuvinte cheie : TRUE sau FALSE.
Integer ia valori din mulţimea Z= {…,-2,-1, 0, 1, 2,…}, adică sunt numere fără
parte fracţionară.
Double reprezintă numerele reale, valori numerice care includ fracţii zecimale.
Numerele duble sunt stocate folosindu-se standardul IEEE-64, pe 64 de biţi. Acest
format permite valori care pot merge până la 1,8 x 10308 şi furnizează aproximativ 14
cifre semnificative după virgulă.
String reprezintă un sir de caractere. Spre deosebire de datele numerice care
conţin cu precădere cifre, şirurile (datele de tip string) pot conţine orice caracter. Ca
atare şirurile sunt utile pentru stocarea datelor care nu pot fi calculate, precum nume,
adrese, comentarii, etc.Nu este o problemă dacă un string devine prea mare. Nu există
practic nici o limită de dimensiune impusă de PHP.Pentru a specifica un şir PHP,
caracterele care alcătuiesc şirul sunt incluse între ghilimele duble. PHP permite
includerea în şiruri a unor caractere speciale, precum caracterele de salt la linie nouă
sau de retur de caracter, prin furnizarea de secvenţe escape. Caracterele sunt cele
utilizate în C, C++ sau Java.

8
 Pentru a specifica un şir mai pot fi folosite şi apostroafe. Diferenţa în acest caz
constă în faptul că se inhibă evaluarea variabilelor.
O altă modalitate de a delimita un string este folosirea sintaxei « heredoc ».
Trebuie furnizat un identificator după <<<, apoi string-ul, apoi acelaşi identificator
pentru a închide citatul. Identificatorul de închidere trebuie să înceapă în prima coloană
a liniei. De asemenea trebuie să urmeze aceeaşi regulă de numire ca orice altă etichetă
PHP: trebuie să conţină doar caractere alfanumerice şi underscore şi trebuie să inceapă
cu un character diferit de o cifră sau cu underscore. Exemplu de astfel de identificatori
sunt EOD, EOT.

PHP mai suportă şi două tipuri de date compuse :

Array : un tablou în PHP este de fapt un tip care mapează în mod ordonat. Un
astfel de tip mapează valorile în chei. Tipul array este optimizat în cateva moduri, aşa
încat poate fi folosit ca o listă efectivă, ca un vector, un tablou hash, mulţime, stivă,
coadă etc.

Object este utilizat pentru a reţine obiecte – instante ale claselor

În PHP mai există doua tipuri speciale : resource şi NULL

Tipul resource desemnează o variabilă specială, care reţine o referinţă la o
resursă externă. Resursele sunt create şi utilizate de funcţii speciale.
Valoarea specială NULL reprezintă o variabilă care nu are nici o valoare, iar
NULL este singura valoare posibilă a tipului. O variabilă este considerată NULL dacă :
 a fost asignată cu constanta NULL
 nu a fost setată la nici o valoare înca
 a fost “dealocată” folosind “unset”

1.5 Variabile

Variabilele sunt locaţii de memorie desemnate printr-un identificator care începe

cu semnul $. Numele variabilelor sunt case-sensitive şi pot începe cu o litera sau
undescrore (_), urmat de oricâte cifre, litere sau caractere underscore. Variabilele permit
memorarea valorilor de diverse tipuri. PHP procesează automat tipul variabilei. O
variabilă se consideră declarată implicit prima dată când este folosită.
Pentru a atribui o valoare unei variabile este folosit semnul “egal” (=).
Exemplu: $nume = "Ina"
Mai există o metodă pentru asignarea de valori variabilelor, aparută în cadrul
PHP 4 : asignarea prin referinţă. Aceasta înseamnă că noua variabilă doar pointează
către variabila originală şi schimbările asupra noii variabile afectează originalul şi
reciproc. Pentru a determina această practică să aibă loc, trebuie doar să ataşăm
simbolul & la începutul variabilei care este asignată (variabila sursă).

Variabilele dinamice sunt o alternativă la folosirea şirurilor.Se utilizează atunci

când este necesar un număr mare, variabil, necunoscut dinainte de variabile.
Variabilele pot avea nume variabile, care pot fi setate şi folosite/schimbate dinamic.
Acest lucru se face prin utilizarea valorii unei varibile pe post de nume de variabilă.

9
Indirectarea se realizează prin utilizarea marcajului dolar '$' în faţa numelui variabilei
referinţă. De exemplu:
<?php
$var1 = 5;
$var2 = "var1";
echo "Valoarea din var1 este ";
echo $var1;
echo " sau ";
echo $$var2;
?>
Notaţia $$var2 a fost folosită pentru a desemna valoarea reţinută de variabila $var1.

Există mai multe tipuri de variable în funcţie de domeniul de valabilitate al

acesteia, adică de locul în care poate fi folosită după ce a fost creată:
Variabile locale: o variabilă definită în interiorul unei funcţii nu va putea fi
accesată decât de instrucţiunile din interiorul acelei funcţii.
Variabile globale: o variabilă definită în exteriorul unei funcţii nu va putea fi
accesată în interiorul funcţiei.
Variabile globale în interiorul unei funcţii: o variabilă definită în afara unei
funcţii trebuie redeclarată ca variabilă globală în interiorul funcţiei.

Fiecărui script pe care îl ruleaza, PHP îi furnizează o serie de variabile

predefinite folosite pentru a afla starea serverului Web, numite variabile de mediu.
Acestea în mare măsură sunt create şi depind de serverul Web care rulează, sau sunt
variabile proprii PHP. Ele sunt de fapt o mulţime de tablouri predefinite ce conţin
variabile de pe serverul web, mediul şi input-ul utilizatorului. Aceste tablouri sunt
speciale prin faptul că sunt automate, adică disponibile în orice punct al scriptului.
Aceste variabile predefinite sunt urmatoarele :

• $_ENV conţine variabile disponibile prin intermediul mediului în care este

executat.
• $_SESSION conţine variabile care corespund sesiunii curente a script-ului.
• $_GET si $_POST conţin variabile primite de script prin intermediul unor
transferuri care folosesc metodele HTTP get, respectiv post. De exemplu, prin
intermediul acestor vectori pot fi accesate valorile câmpurilor dintr-un
formular care a fost completat şi transmis folosind una dintre cele două
metode.
• $GLOBALS - pot fi accesate toate variabilele globale care sunt accesibile
script-ului PHP curent; acest vector este indexat chiar prin numele variabilelor
globale.
• $SERVER - conţine o serie de variabile ale căror valori sunt setate de server-
ul Web; majoritatea valorilor variabilelor din acest vector depind de mediul de
execuţie al scriptului curent.
• $_COOKIE conţine valorile variabilelor ce conţin informaţii referitoare la
cookie-urile păstrate pe calculatorul utilizatorului care accesează pagina Web.
• $_FILES conţine variabile primite de script prin intermediul încărcărilor de
fişiere prin metoda POST.

10
 1.6 Constante
O constantă este un nume dat unei valori. O constantă nu îşi poate modifica
valoarea de-a lungul execuţiei scriptului. Numele de constante sunt case-sensitive. O
diferenţa notabilă faţă de variabile este aceea că numele constantelor nu sunt precedate
de semnul $.Prin convenţie constantele sunt scrise cu litere mari. Definirea unei
constante se face folosind funcţia define().
Exemplu :
<?php
define("CONSTANT", "o_constanta");
echo CONSTANT; // afiseaza "o_constanta"
echo Constant; // afiseaza "Constant"
?>
O constantă odată definită nu poate fi modificată sau dealocată.Vizibilitatea
unei constante este globală.

1.7 Operatori
Pentru a putea efectua operaţii asupra unor varibile şi constante de diverse
tipuri se folosesc anumite simboluri numite operanzi. Entităţile asupra cărora se aplică
un operator se numesc operanzi. Un operator poate avea unul, doi sau chiar trei
operanzi. Majoritatea operatorilor sunt binari (au doi operanzi). În general operatorii
sunt clasificaţi în funcţie de tipul datelor asupra cărora acţionează. Există :
Operatori aritmetici - provin din matematică ţi acţionează asupra datelor de tip
numeric. Aceştia sunt prezentaţi în tabelul urmator:

Exemplu Nume Rezultat

-$a Negaţia Opusul lui $a.
$a + $b Adunarea Suma lui $a şi $b.
$a - $b Scaderea Diferenţa dintre $a şi $b.
$a * $b Înmulţirea Produsul dintre $a şi $b.
$a / $b Împarţirea Câtul împarţirii lui $a la $b.
$a % $b Modulul Restul împarţirii lui $a la $b.

Operatorul de împarţire ("/") returnează o valoare întreagă de fiecare dată, chiar dacă
cei doi operanzi sunt întregi (sau string-uri convertite la întregi).

Operatorii de incrementare/decrementare sunt operatori unari care au ca

rezultat creşterea/descreşterea cu o unitate a varibilei operând asupra căreia se aplică.
Operatorii post se aplică după ce valoarea este evaluată în expresia din care face parte
iar operatorii pre se aplică înainte de evaluarea expresiei.

Exemplu:
$a = 1;
$b = $a++; // b = 1, a = 2

11
$c = ++$a; // c =3, a = 3
$d = 4 + --$a; // d = 6, a = 2
$e = 4 + $c--; // e =7 , c = 2

Dacă operatorii aritmetici se aplică asupra unor valori de tip string, PHP
va încerca conversia acestora în numere. Dacă conversia nu reuşeşte,
şirurile sunt convertite la valoarea 0.

Operatori de asignare - permit atribuirea de valori varibilelor. Operatorul de

asignare de bază este operatorul '=', care înseamnă operatorul din stânga ia valoarea
expresiei din dreapta. Valoarea expresiei este evaluată, apoi atribuită variabilei din
partea stanga şi, în final, returnată de operator.
Valoarea unei expresii de asignare este valoarea asignată; de exemplu valoarea lui "$a
= 3" este 3. Deoarece = nu este o instrucţiune PHP ci un operator, el poate intra în
expresii complexe de genul:
$a = $b = 4 + ($c = 3); // a = 7, b = 7, c=3
Pe langă operatorul de bază de asignare, există şi “operatori combinaţi” care
permit folosirea unei valori într-o expresie şi apoi setarea valorii la rezultatul acelei
expresii. Aceştia sunt :
Operator Utilizare Semnificaţie
+= $a += $b $a = $a + $b
-= $a -= $b $a = $a - $b
*= $a *= $b $a = $a * $b
/= $a /= $b $a = $a / $b
%= $a %= $b $a = $a % $b
.= $s1 .= $s2 $s1 = $s1 . $s2

Operatori pe biţi-ajută la prelucrarea numerelor întregi considerate ca şiruri de

biti. Aceştia sunt :

Exemplu Nume Rezultat

$a & $b Şi Biţii sunt setaţi dacă sunt setaţi atât în $a cât şi în $b
$a | $b Sau Biţii sunt setaţi dacă sunt setaţi fie în $a fie în $b
$a ^ $b Xor Biţii care sunt setaţi în $a sau $b dar nu în ambele
Biţii care sunt setaţi în $a nu sunt setaţi în rezultat, şi vice-
~ $a Negare
versa
Deplasare la Deplasează biţii lui $a cu $b poziţii spre stanga (fiecare pas
$a << $b
stanga înseamnă înmulţire cu doi)
Deplasare la Deplasează biţii lui $a cu $b poziţii spre dreapta (fiecare pas
$a >> $b
dreapta înseamnă împarţire cu doi)

Operatori logici - sunt utilizaţi pentru a combina valori logice în expresii.

12
Exemplu Nume Rezultat
$a and $b And TRUE dacă atat $a si $b sunt TRUE.
$a or $b Or TRUE dacă fie $a fie $b sunt TRUE.
$a xor $b Xor TRUE dacă fie $a fie $b sunt TRUE, dar nu ambele
! $a Not TRUE dacă $a nu este TRUE.
$a && $b And TRUE dacă atat $a cat si $b sunt TRUE.
$a || $b Or TRUE dacă fie $a fie $b sunt TRUE.

Operatori de comparare - sunt operatori binari care au ca scop compararea

valorilor operanzilor. Rezultatul acestor operatori este unul logic, având valoarea true
(adevarat) sau flase (fals).

Operatori pe şiruri de caractere- există un singur operator pe şiruri de

caractere, restul operaţiilor fiind efectuate prin intermediul unor funcţii din biblioteca
standard a limbajului. Acest operator este operatorul de concatenare - punct '.'.
Exemplu:
$s1="Ina";
$s2=$s1."are mere";// in $s2 vom avea "Ina are mere"

Operatori de referire - este un operator unar, având ca operand o variabilă şi

permite legarea unui nume de variabila de zonă de memorie a variabilei operand.
Exemplu :
$a = 2;
$b = $a; // a = 2, b = 2
$c=&$a; // a=2, c=2
$c=4; // c=4, a=4, b=2

Operatori asupra tablourilor – există un singur operator asupra tablourilor în

PHP şi anume operatorul +. Adaugă tabloul din dreapta la cel din stanga, iar cheile
duplicate nu sunt suprascrise.
Exemplu :
$a = array ("a" => "mere", "b" => "banane") ;
$b = array ("a" => "pere", "b" => "capşuni", "c" => "cireşe" ) ;
$c = $a + $b ;
Var_dump($c) ;
Va fi afisat :
array(3) {
["a"]=>
string(5) "mere"
["b"]=>
string(6) "banane"
["c"]=>
string(6) "cireşe"
}

Operatori de execuţie - poate fi folosit pentru a executa o comandă pe

interpretorul de comenzi al serverului. El constă în doua apostroafe inverse '`'între care

13
este plasată comanda. PHP va încerca să execute conţinutul apostroafelor inverse ca o
comandă shell ; rezultatul va fi returnat (poate fi asignat unei variabile). Folosirea
operatorului de execuţie este identică utilizării comenzii shell_exec().
Operatorul de execuţie acţionează doar dacă opţiunea safe_mode din php.ini
este dezactivată (Off). În general acest operator nu se foloseste datorită breselor de
securitate pe care le deschide pe server.

Operatorul de inhibare a erorilor- are sintaxa @(expresie) şi rolul de a

suprima erorile şi avertismentele generate de expresia operand. Poate fi folosit înaintea
oricărei expresii, caz în care orice mesaje de eroare ce ar putea fi generate de acea
expresie vor fi ignorate.
Exemplu :
$a = (2 / 0); // generează avertisment de împartire la zero
$a = @(2 / 0 ); // nu genereaza avertisment
Dacă opţiunea track_errors este activată, orice mesaj de eroare generat de
expresie va fi reţinut în variabila $php_errormsg. Această variabilă va fi suprascrisă la
fiecare eroare. Operatorul @ se aplică doar expresiilor. Nu poate fi adăugat în faţa
funcţiilor sau definiţiilor de clase, sau în faţa structurilor condiţionale de tipul if şi
foreach .

Operatorul condiţional sau ternar -are sintaxa : condiţie ?

valoare_adevarată : valoare_falsă. Operatorul evaluează mai întâi expresia logică
din condiţie. Se aseamană cu structura condiţională if-else. Dacă condiţia este
adevărată va întoarce valoare_adevarată iar în caz contrar valoare_falsă.
Exemplu: echo ($varsta < 18) ? "minor" : "adult";

1.8 Expresii
Expresiile sunt foarte importante în PHP. Aproape tot ceea ce scriem în limbajul
PHP reprezintă o expresie. Expresiile combina operanzi şi operatori de diverse tipuri :
constante, variabile şi nume de funcţii. Dacă scriem „$a=3”, îi atribuim lui $a valoarea
3. Alte exemple de expresii sunt prezentate mai jos:

$condiţie ? $operand1 : $operand2;

$b = $a = 3;
$i++;

După atribuirea $a=3 ne aşteptăm ca valoarea lui $a să fie 3; aşadar dacă scriem
$b = $a, ne aşteptăm să se comporte ca şi cum am fi scris $b = 3. Cu alte cuvinte, $a
este o expresie care are valoarea 3. Dacă totul funcţionează corect, comportamentul
descris mai sus este cel ce va avea loc.

În cazul şirurilor de caractere între ghilimele « » trebuie acordată o mare

atenţie. La evaluarea expresiei în care acestea apar, toate numele de variabile care apar
în interiorul lor sunt înlocuite cu valorile corespunzatoare. De exemplu:

$nume = "Ina";
$sir1 = "$nume are mere!";

14
$sir2 = '$nume are mere!';
echo $sir1; // va afisa Ina are mere
echo $sir2; // va afişa $nume are mere

1.9 Tablouri

Tabloul, aşa cum spuneam la tipul de date array, este cel care mapează valorile
în chei. Adică el reprezintă o variabilă ce stochează mai multe valori . Aceste valori
individuale se numesc elementele tabloului. În PHP tabloul va asocia fiecărei intrări o
cheie prin care aceasta poate fi regăsita. Cheile pot fi numerice (în acest caz indicii
creaţi implicit vor fi 0,1,2 ...) sau pot fi şiruri de caractere (caz în care tabloul se
numeşte asociativ). Valorile reţinute pot avea orice tip dar sunt de acelaşi fel pentru un
tablou dat.
Variabilele care au o singură valoare se numesc scalare. O variabila de tip
tablou poate fi creată prin constructorul array(). Sintaxa pentru crearea unui tablou
indexat numeric este:
$tablou = array (el0, el1, ... el_n);
Exemplu :
$fructe= array ("capşuni", "pere", "mere", "gutui", "portocale");
Accesul la elementele tabloului se face prin indecsi numerici (cu semnificaţia de
numere de ordine în tablou). Spre exemplu $fructe[0] are valoarea "capşuni", $fructe[3]
are valoarea "gutui" etc.
Pentru a afla numarul curent de elemente ale unui tablou se face cu ajutorul
funcţiei count($tablou). În PHP dimensiunea unui tablou este variabila. Pentru a
adăuga un nou element se va atribui pur şi simplu variabilei cu urmatorul indice o
anumită valoare. Spre exemplu $fructe[5]="banane" va adauga un nou element
("banane") la sfârşitul tabloului $fructe.

Tablourile în care valorilor conţinute le sunt asociate chei prin care acestea pot fi
regăsite se numesc tablouri asociative. Sintaxa pentru crearea unui astfel de tablou este:
$tablou = array( "cheie1" => el1, "cheie2" => el2, ... "cheie_n" => el_n);
Exemplu :
$pret = array ("paine albă" => 7000, "ou" => 3000, "zahăr" => 24000);
Accesul la un element se face prin cheia asociată. Spre exemplu $pret ["paine
albă"] are valoarea 7000. Şi în acest caz tabloul poate fi extins dinamic prin adaugarea
unui nou element a carei cheie nu exista în tablou. Spre exemplu $pret["miere 500g"] =
30000 va adăuga elementul 30000 cu cheia "miere 500g" la tabloul $pret, acesta având
acum patru elemente.
Ambele tipuri de tablouri reţin intern o referinţă (pointer) catre elementul
curent de prelucrat. Acest lucru permite scrierea secvenţelor pentru parcurgerea şi
prelucrarea elementelor lor. Instrucţiunea foreach este asemanatoare cu instrucţiunea
for (combină instrucţiunea FOR cu funcţia EACH) dar este destinată exclusiv
parcurgerii de tablouri, în special a celor asociative Sintaxa acestei instrucţiuni are
două forme alternative:

foreach (tablou as cheie => valoare_element_curent)

15
{
//instrucţiuni
}
foreach (tablou as valoare_element_curent)
{
//instrucţiuni
}
Prima formă permite şi extargerea şi prelucrarea cheilor asociate, pe când cea de a doua
formă permite extragerea tuturor valorilor din tablou şi prelucrarea lor individual.

1.10 Structuri de control

Pentru a putea controla fluxul de execuţie al unui program sau script sunt
folosite structurile de control. Ele pot fi grupate în structuri condiţionale (în care codul
ia decizii) şi structuri repetitive, sau cicluri. Toate scripturile PHP sunt construite
dintr-o serie de instrucţiuni. O instrucţiune poate fi o atribuire, un apel de funcţie, un
ciclu, o expresie condiţională sau o instrucţiune vidă.

1.10.1 Instrucţiuni conditionale

Instrucţiunile condiţionale permit execuţia condiţionată a secvenţelor de

program. În lipsa unor astfel de instrucţiuni ar fi practic imposil de implementat o mare
parte dintre problemele din luma reală.

Instrucţiunea IF

Instrucţiunea if permite luarea de decizii privind execuţia unei alte instrucţiuni

sau a unui bloc de instrucţiuni inclus între acolade ('{' şi '}'). Cea mai simplă sintaxă a
instrucţiunii if este:
if (expr)
instrucţiune

Expresia expr este o expresie (condiţie) logică ce se evaluează la true sau false.
Dacă evaluarea condiţiei are ca rezultat o valoare adevarată se va executa instrucţiunea
specificată, dacă nu, instrucţiunea va fi ignorată şi se va trece mai departe.
Exemplu:

if ($varsta < 18)

echo 'Esti minor !';

În cazul în care la luarea unei decizii există mai multe opţiuni trebuie testate mai
multe condiţii. Limbajul PHP pune la dispoziţia programatorilor clauza elseif. Aşa cum
îi spune şi numele această instrucţiune este o combinaţie între instrucţiunile else şi if.
În acest caz sintaxa instrucţiunii este:

16
if (expr1)
instrucţiune1
elseif (expr2)
instrucţiune2
...
elseif (exprN)
instrucţiune
Ambele variante elseif si else if (cu spatiu si fără spatiu) sunt corecte.

Instrucţiunea SWITCH

Instrucţiunea switch este similară cu o serie de instrucţiuni if care testează mai

multe valori posibile pentru o anumită expresie. Într-o instrucţiune if, condiţia poate fi
adevarată sau falsă; într-o instrucţiune switch condiţia poate avea orice număr de valori,
diferite, atâta timp cât se evaluează la un tip de bază (integer, string sau double). Este
necesară o instrucţiune case pentru a se ocupa de fiecare valoare la care trebuie să
reacţioneze şi opţional, o instrucţiune default pentru restul situaţiilor pentru care nu sunt
descrise comportamente. Se foloseşte în situaţiile când dorim să comparăm aceeaşi
variabilă cu diferite valori şi să executăm bucăţi de cod diferite pentru fiecare caz în
parte.Avantajul instrucţiunii switch este o scriere mai concisă şi mai simplu de înţeles şi
depanat. Sintaxa acestei instrucţiuni este:

switch (expr) {
case valoare_1:
instrucţiune_1;
break;
case valoare_2:
instrucţiune_2;
break;
...
case valoare_n:
instrucţiune_n;
break;
defaut:
instrucţiune_default;
}

Dupa evaluarea expresiei, valoarea obţinută este comparată cu valorile din

clauzele case. Dacă se întâlneste o potrivire se va continua cu execuţia instrucţiunilor
din clauzele case următoare, până la întâlnirea instrucţiunii break. Consecinţa este că,
dacă instrucţiunile dintr-o clauză case nu se termină cu break, se va continua execuţia
cu instrucţiunile clasei următoare.
Observaţie : Instrucţiunea continue aplicată în cadrul switch-ului acţionează similar cu
break. Dacă avem un switch într-un ciclu şi dorim să continuăm de la următoarea
iteraţie a ciclului, se foloseşte continue 2.

17
 1.10.2 Instrucţiuni repetitive
Instrucţiunile repetitive permit implementarea algoritmilor care necesită
repetarea unei secvenţe de calcul.

Instrucţiunea FOR

Instrucţiunea for este cea mai complexă instrucţiune în PHP. Permite execuţia
unei instrucţiuni sau a unui bloc de instrucţiuni inclus între acolade ('{' şi '}') şi are
sintaxa:
for (expr1; expr2; expr3)
instrucţiune

Prima expresie (expr1) este numită expresie de iniţializare şi este executată

necondiţionat o singură data la intrarea în ciclu. Ea stabileşte valoarea iniţială a
contorului. La începutul fiecărei iteraţii se evaluează expr2, o condiţie logică. Dacă
expresia este evaluată TRUE, ciclul continuă prin executarea instrucţiunii. Dacă expr2
este evaluată ca fiind FALSE execuţia ciclului se termină. Aici se compară de obicei
contorul cu o limită anume. La sfârşitul fiecărei iteraţii este executată expr3 (expresie
de iterare). Aceasta va ajusta la fiecare valoarea contorului ; are rolul de a asigura
trecerea la pasul următor (incrementarea contoarelor, citirea datelor următoare etc.).
Oricare dintre cele trei expresii pot lipsi. . Dacă expr2 lipseşte, ciclul rulează la infinit.
Pentru a ieşi forţat din ciclu se poate folosi instrucţiunea break.Dacă expr3 este vida
PHP o va considera adevărată şi va cicla la infinit. În acest caz trebuie asigurată o ieşire
forţată din bucla utilizând una dintre instrucţiunile de control pentru repetiţii.

Instrucţiunea WHILE

Ciclurile while sunt cele mai simple structuri repetitive în limbajul PHP. La fel
ca instrucţiunile if, se bazeaza pe o condiţie. Diferenţa dintre un ciclu while şi o
instrucţiune if este aceea că instrucţiunea if execută codul ce urmează odată în cazul în
care condiţia pe care o evaluează este adevarată. Un ciclu while execută blocul în mod
repetat, atâta timp cât condiţia este adevărată. De regulă, se foloseste ciclul while când
nu se cunoaşte în prealabil cate iteraţii vor fi necesare. Când este necesar un număr fix
de iteraţii de foloseşte ciclul for. Structura de bază a instrucţiunii este:

While (expr)
instrucţiune

Expresia expr este o expresie (condiţie) logică ce se evaluează înainte de

fiecare repetiţie. Dacă rezultatul evaluării condiţiei este adevărat, se va executa
instrucţiunea specificată apoi secvenţa se va relua. Dacă rezultatul evaluării este fals,
instrucţiunea va fi ignorată şi se va trece la instrucţiunea de dupa while.

Instrucţiunea DO .. WHILE

Instrucţiunea do-while este asemănătoare cu instrucţiunea while dar se

foloseste pentru a implementa o buclă repetitivă cu test final (evaluarea expresiei se

18
află la sfârşitul ciclului). Diferenţa fundamentală constă în faptul că ciclul este executat
cel puţin o dată. Se iese din ciclu în momentul în care expresia este evaluată ca fiind
FALSE.Ca şi while, ea permite execuţia unei instrucţiuni sau a unui bloc de
instrucţiuni inclus între acolade ('{' şi '}') şi are sintaxa:

do
instrucţiune
while (expr);

Expresia expr este o expresie (condiţie) logică ce se evaluează după fiecare

repetiţie. Dacă, după executarea instrucţiunii condiţia este adevarată se va relua
secvenţa de la început. În cazul în care condiţia devine falsă, repetiţia se va încheia şi
se va trece la instrucţiunea de după do-while.
În cazul buclei do-while, instrucţiunea din bucla se va executa cel puţin o dată
chiar şi în cazul în care condiţia nu este adevarată de la început.

Instrucţiuni de control pentru repetiţii

Pentru a simplifica implementarea unoeri este necesar să se iasă forţat dintr-o

iteraţie.În PHP există instrucţiuni speciale: continue, break şi return.

Instrucţiunea continue permite terminarea forţata a iteraţiei curente şi trecerea la

urmatoarea iteraţie. Ea poate fi folosită cu instrucţiunile for, foreach, while sau
do..while. Continue are rolul de a sări peste restul iteraţiei curente şi de a continua
execuţia de la începutul urmatoarei iteraţii. Continue acceptă opţional un argument
numeric ce specifică din câte structuri trebuie să iese forţat.

Instrucţiunea break permite întreruperea forţata a buclei curente. Ea poate fi

folosită cu instrucţiunile for, foreach, while, do..while sau switch. Acceptă opţional un
argument numeric ce specifică din câte structuri trebuie să iese forţat.

Instrucţiunea return permite terminarea forţata a funcţiei sau programului

curent. Ea poate fi folosită în instrucţiunile for, foreach, while sau do..while unde, prin
terminarea scriptului, termină în mod evident şi bucla curentă. Dacă este apelată dintr-
o funcţie, return încheie imediat execuţia aesteia şi returnează argumentul său ca
valoare a apelului de funcţie. Dacă se doreşte generarea unui mesaj în pagină înainte de
încheierea scriptului, în loc de return se pot folosi funcţiile exit(mesaj) sau die(mesaj) -
die fiind un alias al funcţiei exit.

1.11 Funcţii

O funcţie este un modul de cod care oferă o interfaţa de apel, rezolvă un anumit
algoritm şi opţional, returnează o valoare.Ea grupează instrucţiunile care execută un
anumit algoritm şi permite refolosirea codului ori de cate ori este nevoie de acel

19
algoritm într-un program. Funcţiile reprezintă părţi identificabile prin nume ale unui
program, care se pot lansa în execuţie la cerere prin intermediul acestor nume.
Funcţiile pot fi predefinite (existente în biblioteca de bază a limbajului) sau definite de
utilizator.

1.11.1 Funcţii predefinite

Funcţiile predefinite(de biblioteca) rezolvă cele mai comune probleme legate
de scopul în care a fost dezvoltat un limbaj şi reprezintă porţiuni de cod gata scrise care
pot fi reutilizate de catre toţi programatorii care folosesc acel limbaj. Exemplu : echo().
PHP are un număr mare de funcţii şi construcţii predefinite, majoritatea
funcţiilor de bibliotecă referindu-se la prelucrarea de texte, lucrul cu protocoalele
internet şi comunicarea cu servere de baze de date.
Numele funcţiei identifică unic codul care va fi apelat în acel loc. Spre
deosebire de variabile, numele funcţiilor nu sunt "case-sensitive" deci pot fi scrise cu
orice combinaţii de litere mari/mici. Unele funcţii PHP au argumente opţionale, care
pot fi specificate sau omise:

nume_funcţie( parametrul1, parametrul2, ... parametrul_n);

Majoritatea funcţiilor returnează valori. Se poate folosi într-o expresie valoarea

returnată de o funcţie. O situaţie foarte frecventă în care se procedează astfel o
constituie utilizarea valorii returnate de o funcţie într-o expresie de atribuire, astfel
încât valoarea să fie accesibilă în mod repetat fără a se invoca funcţia de mai multe ori.
Valorile sunt returnate folosind opţional instrucţiunea return. Poate fi returnat orice tip
de rezultat, inclusiv tablouri şi obiecte. Nu se pot returna valori multiple dintr-o
funcţie, dar rezultate asemănătoare pot fi obţinute prin returnarea unui tablou.
PHP susţine conceptul de funcţii variabile. Aceasta înseamnă că dacă numele
unei variabile este urmat de paranteze, PHP va cauta o funcţie cu acelaşi nume şi va
încerca să o execute.

1.11.2 Funcţii utilizator

Funcţiile de bibliotecă sunt limitate ca număr, de multe ori este necesar să se

definească. Funcţii specifice acelei aplicaţii, anumite funcţii utilizator. Acestea au
sintaxa:

Funcţion nume_funcţie( $arg1, $arg2, ..., $argN)

{
//linii de cod
return $retval;
}
Funcţiile utilizator sunt disponibile doar în fişierul unde sunt declarate. Este
posibil ca o funcţie să nu aibă argumente, la fel de bine cum o funcţie poate avea mai
multe argumente. Argumentele unei funcţii sunt separate între ele prin virgule. Dacă se
doreşte ca funcţia să întoarcă o anumită valoare, trebuie determinat ca funcţia să
execute o instrucţiune return.

20
 1.11.3 Transmiterea parametrilor
O problemă importantă legată de transmiterea parametrilor o reprezintă felul în
care aceasta are loc: prin referinţa sau prin valoare.
Implicit toţi parametrii sunt parametri transmisi prin valoare. La transmiterea
unui astfel de parametru, în momentul apelului se va crea o copie a parametrului
transmis, copie ce va conţine valoarea de apel. Orice modificare asupra parametrului
efectuată în interiorul funcţiei nu va fi vizibilă în exteriorul acesteia. Dacă dorim să
permitem unei funcţii să modifice argumentele sale, acestea trebuie transmise prin
referinţă. În felul acesta nu se mai realizează o copie a parametrului ci, dimpotrivă, la
parametrii transmişi prin referinţă numele parametrului din funcţie (numit parametru
formal) va referi aceeaşi zonă de memorie ca şi cea a parametrului transmis.
Pentru ca un argument al unei funcţii să fie transmis prin referinţă, trebuie să
precedăm cu un '&' numele argumentului în definiţia funcţiei, ca în exemplul de mai
jos. La apel, parametrilor transmişi prin referinţă le pot corespunde doar nume de
variabile nu şi expresii sau constante.

1.11.4 Funcţii recursive

O Funcţie recursivă este o funcţie care se auto-apelează direct sau indirect, prin
intermediul altor funcţii. Limbajul PHP oferă suport complet pentru funcţii recursive.
Utilitatea funcţiilor recursive iese în evidenţă mai ales la implementarea
algoritmilor care prin natura lor sunt recursivi. Exemple de astfel de algoritmi sunt
calculul seriilor matematice recursive sau navigarea prin structuri de date dinamice gen
liste înlanţuite sau arbori. La aplicaţiile Web utilitatea funcţiilor recursive este mai
restrânsă. Totusi, o serie de algoritmi repetitivi de prelucrare a textelor sau de
prelucrarea a tablourilor asociative pot profita de această tehnică.

1.12 Clase şi obiecte

1.12.1 Definirea unei clase

O clasă este o colecţie de variabile şi de funcţii care utilizează aceste variabile.

Principiul de bază al orientării spre obiecte îl reprezintă încapsularea sau ascunderea
datelor, cum mai este cunoscută. Un program care nu este orientat spre obiecte este
organizat ca un set de funcţii şi un set de variabile globale utilizate de acele funcţii.
Orice funcţie poate opera folosind orice variabilă globală, deci structura programului
este oarecum haotică. Prin contrast, un program orientat spre obiecte combină funcţii şi

21
variabile conexe într-o unitate, cunoscută sub numele de clasă. Accesul la datele dintr-
un obiect este posibil prin intermediul operaţiilor obiectului, care alcătuiesc interfaţa
sa.
Multe din proiectele Web evoluează de la o mulţime de hyperlink-uri la o
aplicaţie complexă. Aceste aplicaţii, fie prezentate prin cutii de dialog şi ferestre, fie
prin pagini HTML generate dinamic, au nevoie de o metodologie de dezvoltare gândită
îndeaproape.
O clasă poate fi asimilată cu un tip definit de utilizator. Proprietăţile unei
clase sunt variabile care descriu membrii clasei, iar metodele clasei sunt operaţii pe
care membrii clasei le pot efectua.
O clasă poate include o metodă specială, numită metodă constructor sau pur şi
simplu constructor. Constructorul unei clase este folosit pentru a crea instanţe sau
membri ai clasei, care sunt cunoscuţi sub numele de obiecte. O clasă se defineşte
utilizând următoarea sintaxă:

class nume_clasă
{
var nume_varibilaX ;//pot fi oricâte variabile

funcţion nume_funcţieX
{
//corpul funcţiei ; pot fi oricâte funcţii
}
}
În exteriorul claselor, instrucţiunea var este rareori folosită, deoarece PHP
defineşte în mod automat o variabilă în momentul atribuirii unei valori. Cu toate
acestea, proprietăţile claselor trebuie definite folosind instrucţiunea var. Metodele sunt
definite folosind cuvântul cheie funcţion, ceea ce este normal, deoarece metodele, ca şi
funcţiile, execută acţiuni. Diferenţa dintre metode şi funcţii este legată de amplasarea
acestora; metodele sunt definite în interiorul claselor, în timp ce funcţiile sunt definite
în exteriorul acestora.
Pentru a obţine accesul la un membru al clasei metodele vor folosi sintaxa
$this->, care are o semnificaţie similară cu aceea a pronumelui posesiv din limba
română, persoana I singular (meu). Când o metodă face o referire de forma $this->
item, se consideră că referinţa face trimitere la proprietatea $item a obiectului curent.
PHP stabileşte valoarea variabilei speciale $this la fiecare invocare a unei metode.
Clasele sunt tipuri. Pentru a crea o variabilă de tipul dorit se foloseşte operatorul new.
Instanţierea unei clase înseamna crearea unui obiect de tipul clasei respective.

1.12.2 Constructori

Un constructor este apelat atunci când este creat un obiect, şi are de obicei rolul
de a iniţializa şi seta atribute la valori de pornire sau de a crea obiecte de care are
nevoie obiectul curent. Constructorul are proprietatea cî posedî acelaşi nume cu clasa
în care este definit şi nu întoarce nici o valoare. PHP apelează automat constructorul la
invocarea operatorului new.

22
 1.12.3 Moştenire

Moştenirea permite specificarea unei clase folosind o altă clasă ca punct de

plecare. Clasa originală se numeşte clasă de bază sau clasă părinte, iar clasa
specificată mai recent se numeşte clasă derivată sau clasă copil. Moştenirea
funcţionează în sens unic, clasa copil moşteneşte proprietăţi şi metode ale clasei
părinte, dar clasa părinte nu preia trăsături de la copil. Clasa copil sau derivată posedă
toate variabilele şi funcţiile clasei de bază alături de variabilele şi funcţiile proprii,
definite în extensie. Acest lucrul se realizează utilizând cuvântul cheie extends.
Moştenirea multiplă nu este acceptată.

Exemplu: class clasa_copil extends clasa_parinte

{
var nume_varibilaX ;

funcţion nume_funcţieX
{
//corpul funcţiei
}

}
1.13 Reutilizarea codului
Posibilitatea reutilizării codului în locul scrierii de cod nou duce la reducerea
costurilor, reducerea erorilor şi creşterea standardizării programelor produse. În mod
ideal un proiect nou se crează prin combinarea componentelor reutilizabile în locul
scrierii altora noi, timpul de dezvoltare fiind redus drastic.
Acest mecanism este implementat în PHP prin instrucţiunile require, require_once şi
include.

1.13.1 Instrucţiunea require

Instrucţiunea require permite includerea unui fişier extern în interiorul unui

fişier script. Ea funcţionează asemănător clauzei #include din limbajele C şi C++.
Sintaxa de apel este:

require ( "nume_fişier_reutilizat.php" );

Aceasta instrucţiune require este prelucrată la încărcarea scriptului PHP asociat,

înaintea legării valorilor la variabilele corespunzătoare. Deşi extensia fişierului care se
include nu este obligatorie, prin convenţie ea este fie .php fie .inc. În momentul
interpretării scriptului, apelul instrucţiunii require va fi înlocuit de conţinutul fişierului
transmis ca şi parametru şi apoi acesta va fi interpretat. Fişierul poate conţine orice

23
conţine un script în mod normal, incluzând instrucţiuni PHP, tag-uri HTML, funcţii sau
clase PHP. Se poate observa necesitatea introducerii codului între taguri PHP. În
absenţa acestor taguri, codul este interpretat ca şi text (codificat HTML) şi afişat ca
atare la ieşire.
Instrucţiunea corelată require_once asigură faptul că fişierul specificat este
inclus o singură dată într-un script dat. În cazul creării de fişiere de includere care
folosesc instrucţiunea require pentru a include conţinutul altor fişiere de includere,
instrucţiunea require_once poate fi utilă.

1.13.2 Instrucţiunea include

Instrucţiunea include este asemănătoare cu require. O deosebire importantă se

referă însă la modul în care se face includerea şi interpretarea codului din fişierul inclus.
Instrucţiunea require este înlocuită cu fişierul referit la încărcarea paginii, indiferent
dacă execuţia codului va ajunge sau nu la această instrucţiune.
Instrucţiunea include va fi înlocuită doar în momentul în care execuţia a
ajuns în acel punct. O instrucţiune include este evaluată de fiecare data când este executată
instrucţiunea şi nu este evaluată deloc dacă instrucţiunea nu este executată. Din acest
punct de vedere se preferă folosirea acestei instrucţiuni, ea generând o încărcare mai mică
pe server.

1.14 Controlul sesiunilor

Dupa cum se ştie, protocolul HTTP este un protocol lipsit de informaţii de stare.
Acest lucru se traduce prin faptul că acest protocol nu are nici un mecanism propriu prin
care să trasmită datele între două tranzacţii. La cererea succesivă a doua pagini de către
un utilizator către un server de Web, nu există nici o posibilitate de transmitere spre cea
de a doua pagină faptul că este vorba despre acelaşi utilizator. Ideea de la care pleacă
controlul sesiunilor este tocmai acela de a permite urmărirea acţiunilor unui utilizator pe
parcursul unei sesiuni de accese către respectivul server de Web.
Acest lucru permite implementarea unui mecanism de tip "logging in" pentru un
utilizator, şi, implicit, posibilitatea de a limita accesul la anumite pagini cu informaţii
confidenţiale, respectiv de a pezenta conţinutul paginilor personalizat după preferinţele
utilizatorului respectiv.
Sesiunile PHP sunt gestionate prin intermediul unui numar unic (session ID)
generat aleator pe baza unui algoritm criptografic. Acest numar este generat de către
PHP şi menţinut de către clientul de Web care accesează pagini pe tot parcursul
sesiunii de lucru. Numarul de sesiune (session ID) permite înregistrarea variabilelor de
sesiune stocate pe server. Aceste variabile sunt apoi vizibile în toate paginile acelei
sesiuni.
Crearea unei sesiuni este asigurată de către PHP prin intermediul unui scrip, aşa numit
mecanism “session”, startat prin linia de program:

session_register(“global”)

24
Suportul pentru sesiuni în PHP constă din modalitatea de a păstra anumite date în
vederea accesului ulterior. Un vizitator ce accesează website-ul primeşte un id unic, aşa-
numit id de sesiune. Acest id este fie reţinut într-o « cookie », fie propagat prin URL.
Sesiunile permit înregistrarea unui numar aleator de variabile pentru a fi păstrate pentru
cereri. Când un vizitator aceesează site-ul, PHP va verifica automat (dacă
session.auto_start este setat pe 1) sau la cerere (explicit prin session_start() sau implicit
prin session_register()) dacă un anume id de sesiune a fost trimis împreuna cu cererea.
În acest caz, este recreat mediul salvat anterior.

Paşii care se fac la utilizarea unei sesiuni sunt următorii:

 crearea unei sesiuni
 înregistrarea variabilelor sesiune
 utilizarea variabilelor sesiune pentru controlul accesului său
 personalizarea paginii
 ştergerea variabilelor sesiune şi distrugerea sesiunii
Înainte de a utiliza o sesiune aceasta trebuie creată. Cel mai simplu mod de a porni o
sesiune este acela de a apela funcţia session_start(). Apelul acestei funcţii creează
automat un număr de sesiune şi permite apoi utilizarea variabilelor de sesiune. Această
funcţie trebuie apelată înainte de antetul "<HTML>".
O altă metodă, mai puţin recomandată, este metoda creări implicite a unei sesiuni în
momentul în care se înregistrează forţat o variabilă de sesiune. Funcţia session_start va
fi apelată la începutul tuturor paginilor care compun sesiunea curentă. Pentru a folosi
valori transmise între pagini diferite se vor folosi variabile sesiune. Variabilele sesiune
se înregistrază ca atare prin apelul funcţiei session_register(nume_variabila). De
exemplu:

$varSesiune1 = 10;
session_register( "varSesiune1");

Trebuie remarcat că numele variabilei se transmite funcţiei ca şi un şir de caractere, fără

a include şi semnul $. Variabila va rămâne vizibilă până când este ştearsă sau până când
sesiunea curentă se incheie. Dacă se doreşte, se pot înregistra mai multe variabile printr-
un singur apel de session_register prin sintaxa:

session_register( "v1", "v2" ...);

Pentru a utiliza variabilele sesiune în alte pagini din aceeaşi sesiune există două
metode, asemănător cu accesul la datele unui formular. Dacă opţiunea register_globals
din php.ini este setată pe On, în toate paginile sesiunii variabila va fi accesibila direct
prin nume. Dacă opţiunea este Off se poate apela variabila prin intermediul tabloului
asociativ $HTTP_SESSION_VARS. De exemplu:

$n = 4 * $HTTP_SESSION_VARS["varSesiune1"];

Pentru a testa într -o pagină dacă o variabilă a fost sau nu înregistrata în sesiunea
curentă se va folosi funcţia session_is_registered("numeVariabila"). Această funcţie
întoarce o valoare logică care poate fi ulterior testată.
Dacă se doreşte la un moment dat ştergerea unei variabile sesiune se poate apela
la funcţia session_unregister(numeVariabila).

25
Pentru a încheia sesiunea curet şi a şterge toate variabilele sesiune asociate se va apela
funcţia session_destroy(). Această funcţie nu primeşte nici un parametru şi va distruge
sesiunea curentă împreuna cu toate informaţiile asociate.

Observaţie! Pentru a Funcţiona corect mecanismul de control al sesiunii trebuie ca în

fişierul php.ini să existe setările:

session.save_path = c:/temp ; setare valabilă pentru Windows (pt. Unix:

session.save_path = /tmp)
session.cache_limiter = private

Capitolul 2
Baze de date MySQL
2.1 Noţiuni generale

O bază de date este o colecţie de informaţii organizate în aşa fel încat un

program poate selecta rapid anumite părţi din acea informaţie.Pentru a putea accesa
informaţiile stocate într-o bază de date este nevoie de un sistem de gestiune a bazelor de
date (SGBD). Unul dintre cele mai populare sisteme de gestine a bazelor de date este
MySQL.
Ca şi PHP, MySQL este distribuit în formula Open Source, deci permite oricarui
utilizator să modifice programul care să poate fi luat gratuit de pe internet. Datele sunt
organizate în tabele, între care sunt stabilite relaţii şi constrângeri de intergritate. Pentru
gestiunea datelor foloseste limbajul SQL (Structured Query Language) care este un
standard în acest domeniu.

26
 MySQL este un sistem client-server, serverul MySQL suportand o paletă largă
de programe client, scrise în diverse limbaje de programare.De obicei, serverul de date
este separat logic şi fizic de programele client care asigură interfaţa operaţiilor cu baza
de date.
MySQL este un sistem de gestiune al bazelor de date relaţional. Principiile
algebrei relaţionale au fost stabilite de F. C. Codd în 1970. Ea reprezintă
fundamentarea matematică a bazelor de date relaţionale. În concepţia relaţională o bază
de date este formată dintr-o colecţie de relaţii (tabele, fişiere de date) asupra cărora se
aplică o colecţie de operatori pentru a gestiona datele conţinute de relaţii. Un operator
relaţional se aplică asupra unor tabele şi va avea ca şi rezultat tot o tabelă. Potrivit
algebrei relaţionale nu este permis accesul direct asupra înregistrarilor dintr-o tabelă.
Avantaje ale utilizarii bazelor de date relaţionale: facilitarea partajării datelor,
asigurarea independenţei datelor, interogarea ad-hoc, organizarea datelor,
securitatea datelor, reducerea la minimum a experienţei necesare în domeniul
programării, eficienţă în prelucrarea datelor.

2.2 Proiectarea unei baze de date

Proiectarea unei baze de date este foarte importantă pentru succesul aplicaţiei
pentru care este realizată. Primul pas constă în analiza aplicaţiei, iar cel de-al doilea în
normalizarea bazei de date, un proces complex şi de durată care contribuie esenţial la
evitarea problemelor şi complicaţiilor ulterioare.

Normalizarea unei baze de date relaţionale

Normalizarea unei baze de date constă în descompunerea modelului bazei de
date în mai multe relaţii astfel încât să se reducă la maxim redundanţa datelor şi implicit
să elimine anomaliile de actualizare. Normalizarea bazei de date presupune aducerea
relaţiilor gradual pe diverse forme normale. Există şapte forme normale.Fiecare formă
normală preia constrângerile formei anterioare la care adaugă noi condiţii.

Prima formă normală

O relaţie este în prima formă normală dacă şi numai dacă fiecare atribut din fiecare
linie poate conţine numai o singură valoare.
A doua formă normală
O relaţie este în a doua formă normală dacă şi numai dacă ea este în prima
formă normală şi orice atribut non cheie este dependent funcţional complet de cheia
primară.
A treia formă normală
O relaţie este în a treia formă normală dacă şi numai dacă ea este în a doua forma
normală şi nici un atribut non cheie nu este dependent tranzitiv de cheia primară.
Forma normala Boyce-Codd
O relaţie este în forma normală Boyce-Codd dacă fiecare deteminant este cheie
candidată.
A patra formă normală
O relaţie este în a patra formă normală dacă şi numai dacă ori de câte ori există o
dependenţă multivalorică de un determinant, toate atributele sunt dependente funcţional
de determinant.

27
 A cincea formă normală
O relaţie este în a cincea formă normală dacă şi numai dacă ea nu poate fi spartă în
relaţii mai mici si apoi reunită fără a-şi schimba faptele şi semnificaţiile.
A sasea formă normală
Cea de-a sasea formă normală a fost definită de curând şi este definită doar cand este
luată în considerare şi dimensiunea temporală.

Factori care influenţează, de asemenea, proiectarea sunt de căutare a

informaţiilor, factor esenţial care cere uneori repetarea datelor în tabele şi deci,
încălcarea unor forme normale şi viteza de adăugare şi modificare a datelor, care cere
uneori reorganizarea datelor. Nu în ultimul rând spaţiul pe disc este şi el un criteriu
important în cadrul proiectării unei baze de date. Chiar dacă în zilele noastre discurile
au capacităţi foarte mari, o bază de date cu redundanţă mare, pe langă ca ocupă inutil
foarte mult spaţiu, este şi foarte greu de accesat (viteza de cautare în tabele este în
general proporţională cu dimensiunea acesteia).
Proiectarea bazei de date se face folosind procedeul cunoscut sub numele de
modelare entitate-relaţie sau modelare E-R. În acest context, o entitate este similară cu
un tablou relaţional. Modelarea E-R este un proces în cadrul căruia coloanele, entităţile
şi relaţiile între entităţi sunt descoperite şi organizate. Un model E-R poate fi folosit cu
uşurinţă, pentru a genera o structură a bazei de date, care poate fi transformată într-o
bază de date relaţională efectivă.

2.3 Elemente de limbaj

2.3.1 Comentarii

Comentariile pentru explicarea codului în MySQL sunt de doua feluri: pentru

comentarea codului pana la sfarşitul liniei: comentarii care încep cu semnul # sau
comentarii care încep cu semnul – ( este necesar cel puţin un spaţiu după semnul --) şi
comentarii pe mai multe linii care încep cu /* şi se încheie cu */ .

2.3.2 Tipuri de date

Tipurile de date în MySQL pot fi împărţite în mai multe categorii : numerice,

logice, dată calendaristică, timp, şiruri de caractere şi date binare mari (BLOB - binary
large object).

Tipuri de date numerice

1. TINYINT : reprezintă un număr întreg foarte mic. Intervalul de valori posibile

este [-128..127].
2. SMALLINT : repezintă un număr întreg mic. Intervalul de valori posibile este
[-32768..32767].
3. MEDIUMINT : reprezintă un număr întreg mediu. Intervalul de valori posibile
este [-8388608..8388607].

28
4. INT sau INTEGER: reprezintă un număr întreg normal. Intervalul de valori
posibile este [-2147483648..2147483647].
5. BIGINT : reprezintă un număr întreg mare. Intervalul de valori posibile este [-
9223372036854775808..9223372036854775807].
6. FLOAT : reprezintă un număr în virgulă flotantă, simplă precizie (număr real).
Intervalul de valori posibile este [-3.402823466E+38.. -1.175494351E-38,
0,1.175494351E-38..3.402823466E+38].
7. REAL sau DOUBLE : reprezintă un număr real în virgula flotantă, dublă
precizie.
8. DECIMAL (L) sau NUMERIC (L): reprezintă un număr în virgulă flotantă
neîmpachetat. L- lungimea, care spre deosebire de celelalte tipuri la care nu
trebuie specificată.

Tipuri de date de tip dată calendaristică şi timp

1. DATE : reprezintă o dată calendaristică stocată în formatul 'YYYY-MM-DD'

(an-luna-zi). Intervalul de valori posibile este ['1000-01-01'..'9999-12-31'].
2. DATETIME : reprezintă o combinaţie de dată calendaristică şi timp stocată în
formatul 'YYYY-MM-DD HH:MM:SS' (an-luna-zi ora:minut:secundă).
Intervalul de valori posibile este ['1000-01-01 00:00:00'..'9999-12-31
23:59:59'].
3. TIMESTAMP : reprezintă o semnatură de timp stocată după lungimea
specificată, care poate fi 14, 12, 8 sau 6 : YYYYMMDDHHMMSS,
YYMMDDHHMMSS, YYYYMMDD sau YYMMDD.
4. TIME : reprezintă ora, minutul şi secunda. Intervalul de valori posibile este [-
838:59:59'..'838:59:59']. Poate reţine intervalul de timp dintre două
evenimente, de aceea poate fi şi negativ.
5. YEAR : reprezintă anul calendaristic pe doua sau patru cifre. Intervalul de
valori posibile este [1901..2155] pentru 4 cifre, respectiv [1970..2069] pentru
2 cifre (70-99..00-69).

Tipuri de date şir de caractere

1. CHAR (L) : reprezintă un şir de caractere de lungime fixă. Lungimea L a şirului

poate lua valori în intervalul [1..255].
2. BIT, BOOL, CHAR –sinonime cu delaraţia CHAR(1).
3. VARCHAR (L) : reprezintă un şir de caractere de lungime variabilă.Lungimea
L a şirului poate lua valori între [1..255].

Tipuri de date binare mari (BLOB)

1. TINYBLOB, TINYTEXT : reprezintă valori BLOB, TEXT cu lungime maximă

de 255 elemente.
2. BLOB, TEXT : reprezintă valori BLOB, TEXT cu lungime maximă de 65535
(64K) elemente.
3. MEDIUMBLOB, MEDIUMTEXT : reprezintă valori BLOB, respectiv TEXT
cu lungime de max. 16777215 (16 MB) elemente.

29
 4. LONGBLOB, LONGTEXT : reprezintă valori BLOB, TEXT cu lungime de
maxim 4294967295 (4 TB) elemente.

Tipuri de date speciale

1. ENUM ('value1','value2',...) : reprezintă o enumerare de elemente de tip şir de

caracter. Un obiect de acest tip poate avea la un moment dat o singură valoare
dintre cele enumerate sau valoarea NULL. Valoarea " " (şir vid) este considerată
valoare de eroare. Un tip enumerare poate defini maxim 65535 de valori
distincte.

2. SET ('value1','value2',...) : reprezintă o mulţime de elemente de tip şir de

caracter. Un obiect de acest tip poate conţine la un moment dat mai multe
valori distincte dintre cele definite sau poate fi gol (nu conţine nici o valoare).
Un tip mulţime poate defini maxim 65 de valori membru.

2.3.3 Operatori

Operatori aritmetici : operează asupra numerelor întregi cu precizia BIGINT (pe 64

biti). Sunt disponibili urmatorii operatori:
+ : adunare;
- : scădere;
* : înmulţire;
/ : împărţire; dacă se împarte la 0 rezultatul va fi NULL.

Operatori logici : întorc 1 pentru adevarat şi 0 pentru fals.

1. NOT:
! - Negaţie logică. Întoarce 1 dacă argumentul este 0, altfel întoarce 0.
Excepţie: NOT NULL întoarce NULL.
2. OR:
|| - SAU logic. Întoarce 1 dacă cel puţin un argument nu este 0 sau
NULL
3. AND :
&& - ŞI logic. Întoarce 0 sau NULL dacă cel puţin un argument este
0 sau NULL, altfel Întoarce 1.

Operatori de comparare : returnează 1 pentru adevărat, 0 pentru fals şi NULL dacă nu

se poate efectua comparaţia. La compararea a doua şiruri nu se va ţine cont de litere
mari/mici.

= egalitate; la compararea cu NULL întoarce NULL;

<> sau != inegalitate;
< - mai mic;

30
 <= - mai mic sau egal;
> - mai mare;
>= - mai mare sau egal;
<=> - echivalenţă; la compararea cu NULL întoarce 0 sau 1 (1 doar la
NULL <=> NULL); dacă ambii operanzi sunt diferiţi de NULL se comportă ca şi =;

2.4 Crearea unei baze de date şi

gestiunea acesteia

Înainte de a putea crea tabele şi de a introduce date în acestea trebuie creată o

bază de date şi de a o alege ca fiind bază de date curentă.Crearea unei baze de date se
realizează cu ajutorul unui sub-limbaj SQL care se numeste DDL (Data Definition
Language). Comanda care realizează crearea unei baze de date este:

CREATE DATABASE nume_bd;

Pentru ca baza de date db_name să devină curentă, se emite o instrucţiune USE:

USE nume_bd ;

Această instrucţiune este una din puţinele care nu necesită caracterul punct şi
virgulă ca terminare a instrucţiunii, deşi poate fi adăugat.

2.4.1 Crearea unei tabele

Crearea unei tablele se realizează cu comanda :

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name

[(nume_campX tipX [NOT NULL | NULL] [DEFAULT default_value]
[AUTO_INCREMENT] [PRIMARY KEY])]

TEMPORARY - specifică crearea unei tabele temporare care va fi ştearsă

automat la închiderea conexiunii în care a fost creată; doua conexiuni pot crea doua
tabele temporare cu aceleaşi nume, ele nu vor interfera.

31
 IF NOT EXISTS - inhibă mesajul de eroare care se generează dacă la încercarea
de a crea o tabelă care mai există.

NOT NULL / NULL - nu se permit valori NULL în acest camp (campul trebuie
completat în orice situaţie) /permite valori NULL în camp (opţiune implicită dacă nu se
specifică nimic)

DEFAULT default_value - completează câmpul lasat liber cu valoarea implicită

default_value

AUTO_INCREMENT - dacă nu se inserează nimic în câmp, se va genera

automat o valoare mai mare cu o unitate faţă de cea mai mare valoare din acel câmp.
Poate fi specificată o singură coloană cu acest parametru într-o tabelă. Coloanele
specificate astfel trebuie indexate.

PRIMARY KEY - specifică cheia primară pentru tabelă. Un singur câmp din
tabelă poate avea acest parametru. Coloana declarată ca şi cheie primară este indexată
automat.

UNSIGNED – precizat dupa un tip întreg înseamnă că poate avea o valoare

pozitivă sau 0.

Exemplu :

CREATE TABLE persoană (

nume CHAR(30),
prenume CHAR(30),
vârstă INT(3))

2.4.2 Ştergerea unei tabele

Ştergerea unei tabele se realizează cu comanda:

DROP TABLE [IF EXISTS] nume_tabelă

IF EXISTS – este un parametru care va inhiba mesajul de eroare care apare dacă
tabela nu există.

2.4.3 Inserarea datelor în tabele

Comanda INSERT : permite inserarea (adăugarea) de noi înregistrări într-o

tabelă. Deoarece sistemul mySQL este pur relaţional, nu există nici o diferenţă între

32
inserarea de noi date sau adăugarea lor. În ambele situaţii, locul în care se face
adăugarea nu este precizat, nefiind relevant.
Sintaxa comenzii INSERT este urmatoarea :

INSERT [LOW_PRIORITY | DELAYED] [IGNORE]

[INTO] nume_tabelă [(col_nume,...)]
VALUES (expresie,...),(...),...

LOW_PRIORITY – este folosit pentru a întârzia scrierea efectivă a datelor în

tabela până când alţi utilizatori nu mai citesc date din tabelă. Acest lucru avantajează
citirea dar întârzie, semnificativ pentru o tabelă foarte utilizată, scrierea. Efectul este
blocarea execuţiei până când se reuşeşte scrierea efectivă.

DELAYED - are acţiune opusă parametrului precedent. Înregistrarea care trebuie

adăugată este pusă într-o coadă de aşteptare pe server şi controlul revine la client, ca şi
cum scrierea ar fi fost făcută efectiv. Avantajul constă în timpul mic de execuţie a
comenzii INSERT pe o tabelă utilizată intensiv. Dezavantajul constă în încărcarea
serverului cu o operaţie în plus şi în pierderea datelor dacă serverul se opreşte
neaşteptat. Din această cauză parametrul este folosit doar când este cu adevărat necesar.

IGNORE - este util dacă se inserează mai multe înregistrari simultan (în acest
caz lista de după VALUES va conţine mai multe seturi de date în paranteze, despărţite
prin virgulă). De obicei, MySQL raportează eroare şi nu execută comanda care încearcă
adăugarea a cel puţin unei înregistrări care duplică cheia primară sau câmpuri cu valori
unice. Prin folosirea parametrului IGNORE înregistrările greşite sunt ignorate, dar
restul sunt adăugate fără raportarea unei erori. După execuţia comenzii se va raporta
doar numărul de înregistrări a căror adăugare a reuşit.

INTO - este opţional, se foloseşte pentru compatibilitate cu alte sisteme SQL.

Datorită clarităţii mai mari a interogării se preferă totuşi utilizarea lui.

col_nume,... - este o listă de coloane care specifică ordinea în care se vor adăuga
datele în tabelă. Prin aceasta se pot insera doar datele considerate esenţiale, restul
primind valorile implicite specificate la declararea tabelei. Dacă lista lipseşte, setul de
date furnizat trebuie să aibă valori pentru toate câmpurile, în ordinea din declararea
tabelei.

VALUES (expresie, ...),(...) - specifică datele ce vor fi adăugate în tabelă. Ele

trebuie să respecte numarul şi ordinea coloanelor de la declararea tabelei sau, dacă e
specificat, numarul şi ordinea câmpurilor din lista de coloane (col_nume,...)
prezentată anterior.

Exemplu:
INSERT INTO persoană
VALUES ("Olaru", "Niculina",22) ;

33
 Comanda UPDATE - permite actualizarea valorilor dintr-o tabelă. Sintaxa acestei
comenzi este:

UPDATE [LOW_PRIORITY] [IGNORE] nume_tabelă

SET col_nume1=expr1, col_nume2=expr2,...
[WHERE condiţie] [LIMIT NUMBER]

LOW PRIORITY - este folosit pentru a întarzia scrierea efectivă a datelor în

tabelă până când alţi utilizatori nu mai citesc date din tabelă.
IGNORE - este util dacă se inserează mai multe înregistrări simultan (în acest
caz lista de după VALUES va conţine mai multe seturi de date în paranteze, despărţite
prin virgulă).
SET col_nume1=expr1, col_nume2=expr2,... atribuie noile valori expr1, expr2..
la col_nume1, col_nume2 unde (WHERE) are loc conditie. Dacă clauza WHERE
lipseşte, vor fi actualizate toate înregistrările.
LIMIT permite setarea numărului de înregistrări care vor fi afectate de
comanda UPDATE.
Exemplu :

UPDATE persoană
SET nume="Popescu" ;

2.4.4 Ştergerea datelor din tabele

Comanda DELETE – este folosită pentru ştergerea anumitor date dintr-o tabelă.
Aceasta are sintaxa :

DELETE [LOW_PRIORITY] FROM nume_tabelă

[WHERE condiţie_ştergere] [LIMIT NUMBER]

Parametri au aceeaşi semnificaţie ca şi în cazul comenzilor INSERT şi

UPDATE. Folosind comanda DELETE simplş, sub forma “delete from nume_tabelş”,
se vor şterge toate înregistrarile din tabela nume_tabelă. Pentru a prezica care valori să
fie şterse se va folosi clauza WHERE.

Exemplu:

DELETE FROM persoană

WHERE nume="Popescu";

2.4.5 Extragerea informaţiilor din tabele

Comanda SELECT este cea mai utilizată comandă SQL, deoarece permite atât
regăsirea şi vizualizarea datelor din tabelele bazei de date cât şi calcularea unor expresii
care nu au legătură cu datele din tabele. Sintaxa de bază a comenzii este:

34
SELECT itemi FROM nume_tabelă
[ WHERE condiţie ]
[ GROUP BY {colană | expresie} ]
[ HAVING condiţie_includere_grup]
[ ORDER BY tip_ordonare ]
[LIMIT criteriu_de_limitare ] ;

FROM - specifică tabela sau tabelele din care se selectează datele. În cazul în
care referinţa cuprinde mai multe tabele operaţia este una de JOIN.

WHERE - specifică condiţia de includere a datelor în selecţie. Permite selecţia

doar a datelor care interesează la un moment dat. În cazul operaţiunii de JOIN aici se
vor adăuga şi constrângerile date de relaţiile dintre tabele. Condiţia de selecţie constă
dintr-o expresie logică simplă sau complexă.

ORDER BY tip_ordonare {intreg_pozitiv | nume_col | formula} [ASC | DESC] -

permite ordonarea rezultatului dupa anumite coloane sau formule. Dacă se specifică o
listă de numere, acestea vor fi interpretate ca numere de ordine a coloanelor specificate
în SELECT (începând cu 1). Ordonarea se face după prima coloană din listă. În cazul în
care două înregistrări au aceiaşi valoare pentru coloana respectiva se va lua în
considerare a doua coloană din listă (dacă este specificată) etc. Parametrii ASC şi
DESC specifică ordonarea crescătoare, respectiv descrescătoare a înregistrărilor în
rezultat.

Pentru a selecta toate înregistrările dintr-o tabelă se va folosi * :

SELECT * FROM nume_tabelă ;

Dacă se doreşte enumerarea tuturor înregistrărilor ce satisfac o anumită condiţie

se va proceda în felul urmator :
SELECT * FROM nume_tabela WHERE condiţie ;

Clauza GROUP BY specifică dupa ce valoare se va face gruparea. În majoritatea

cazurilor expresia de grupare este reprezentată de o singură coloană. Toate înregistrările
cu aceeaşi valoare pentru expresia de grupare vor fi considerate ca făcând parte din
acelaşi grup.

Clauza HAVING permite selectarea grupurilor care sunt luate în considerare.

Condiţia din HAVING se aplică după constituirea grupului, pe când condiţia din clauză
WHERE în timpul selectării înregistrărilor. În plus, acestă clauză poate cuprinde doar
referinţe la câmpuri şi aliasuri de câmpuri din lista de câmpuri a comenzii SELECT sau
funcţii de sumarizare pe grup. MySQL include funcţii care permit raportarea valorilor
agregate, precum un număr al rândurilor tabelului.
Exemple de funcţii de agregare:

-count(*) = numărul rândurilor din tabel

-avg(coloana) = valoarea medie a coloanei numerice specificate
-min(coloana) = valoarea minimă pentru coloana specificată

35
 -sum(coloana) = suma valorilor din coloana respectivă

2.5 Folosirea alias-urilor

Scrierea instrucţiunilor poate fi simplificată prin folosirea unor denumiri
prescurtate, numite alias-uri. Adesea este de ajutor şi uneori chiar esenţial să ne putem
referi la tabele folosind alte nume. Alias-urile pot fi folosite atât pentru a desemna
tabele cât şi coloane. Ele pot fi create la începutul unei interogari şi folosite pe tot
parcursul ei.
Sintaxa de definire a unui alias este următoarea:

SELECT nume_tabelă.col_nume [AS] alias_c1,... FROM nume_tabelă

ORDER BY alias_c1 ...;

Alias-urile definite pentru tabele pot fi folosite în partea de specificare a

coloanelor, iar alias-urile coloanelor pot fi folosite în clauze ORDER BY sau HAVING.
Alias-urile trebuie folosite şi atunci când dorim să efectuăm un JOIN între o
tabelă şi ea insăsi. Acest lucru suna dificil, dar nu este chiar aşa. Este folositor, de
exmplu, dacă dorim să regăsim înregistrări dintr-o aceeaşi tabelă care au valori în
comun.

2.6 Accesul la o bază de date

2.6.1 Utilizatori şi parole

MySQL suportă un sistem de privilegii sofisticat, există diferenţe semnificative

între sistemul de utilizatori şi parole MySQL şi sistemul Unix-ului sau Windows-ului.
Una dintre acestea este faptul că numele unui utilizator MySQL poate avea 16 caractere
semnificative pe când în majoritatea implementărilor UNIX această valoare este de 8
caractere. O altă diferenţă ar fi aceea ca numele utilizatorilor şi parolele sunt păstrate
separat de mySQL şi nu au nimic în comun cu cele din sistemul de operare.
Nu în ultimul rând, MySQL criptează parolele folosind un algoritm diferit de cel
utilizat de UNIX sau Windows. Algoritmul de criptare este ireversibil.
La instalarea sistemului este creat implicit un utilizator numit "root" care are
toate drepturile activate. Acest utilizator trebuie folosit, din motive de securitate, doar
pentru administrare. Pentru fiecare utilizator care va interacţiona cu serverul trebuie creat
un utilizator.
Un sistem MySQL poate avea mai mulţi utilizatori. Utilizatorul « root » ar
trebui folosit în principiu doar pentru scopuri administrative, din motive de securitate.
Pentru fiecare utilizator care are nevoie să folosească sistemul, acesta trebuie să creeze
un cont cu parola. O idee bună ar fi ca acestea să fie diferite de username-ul şi parola
folosite în afara MySQL (de exemplu cele pentru UNIX sau Windows).

36
 2.6.2 Privilegii MySQL

Privilegiile în MySQL se referă în principal la autentificarea şi autorizarea

utilizatorilor conectaţi la server. Autorizarea se referă la permisiunea de a rula interogări
precum SELECT, INSERT, UPDATE sau DELETE.
Pentru a spori securitatea oricărui calculator, nu numai a serverului MySQL se
aplică principiul "minimului de privilegii necesare".Deşi este foarte simplu, este foarte
important :

Un utilizator (sau proces) trebuie să aibă cel mai scăzut nivel de privilegii,
suficient pentru a putea executa sarcinile care i-au fost alocate.

Informaţiile despre privilegii sunt stocate în tabelele user, db, host, tables_prv şi
columns_priv din baza de date mysql. Serverul va citi conţinutul acestor tabele ori de
câte ori sistemul de privilegii trebuie să acţioneze. Există trei tipuri de bază de
privilegii: privilegii pentru utilizatorii obişnuiţi, privilegii pentru administratori şi
câteva privilegii speciale.

Privilegiile pentru utilizatorii obişnuiţi se leagă direct de comenzile SQL şi de

dreptul de a le executa. Acestea sunt:

SELECT –care se aplică la tabele şi coloane şi permite utilizatorilor să selecteze

înregistrări din tabele.
INSERT - se aplică la tabele şi coloane şi permite utilizatorilor să insereze date
în tabele.
UPDATE - se aplică la tabele şi coloane şi permite utilizatorilor să modifice
valorile existente în tabele.
DELETE - se aplică tabelelor şi permite utilizatorilor să şteargă înregistrări din
tabele.
INDEX - se aplică tabelelor şi permite utilizatorilor să creeze şi să insereze
indecşi în tabele.
ALTER - se aplică tabelelor şi permite utilizatorilor să modifice structura
tabelelor exsiente prin adăugare de coloane, redenumire de coloane ori tabele,
schimbarea tipului de date al coloanelor.
CREATE - se aplică bazelor de date şi tabelelor şi permite utilizatorilor să
creeze baze de date sau tabele.
DROP - se aplică tabelelor şi bazelor de date şi permite utilizatorilor să şteargă
baze de date sau tabele.
GRANT – se aplică bazelor de date şi tabelelor şi permite utilizatorilor
delegarea privilegiilor către un alt utilizator.

Drepturile administratorului sunt :

37
 PROCESS - permite administratorului să vadă procesele care rulează pe server
şi să le oprească. Este utilizat pentru a vedea conţinutul interogarilor ce se executa în
acel moment, inclusiv cele de setare a parolei. De asemenea el dă posibilitatea opririi
forţate a conexiunilor altor utilizatori.
RELOAD - permite administratorului să reîncarce tabele alocate şi să
actualizeze privilegiile, gazdele, logurile şi tabelele.
SHUTDOWN - permite administratorului să opreasca serverul de MySQL de la
distanţă.
FILE - permite administratorului să citească informatii sensibile de pe server; să
insereze date în tabele din fisiere şi reciproc.

Privilegiile speciale sunt doua :

ALL - oferă toate privilegiile. Se poate folosi ALL PRIVILEGES în loc de

ALL.
USAGE - nu oferă nici un privilegiu. Va fi creat un utilizator căruia i se va
permite să se logheze dar nu va avea nici un drept. De obicei se adaugă pe parcurs
privilegii.

Orice utilizator poate avea oricare din aceste privilegii, dar se obişnuieşte să se
restricţioneze cele proprii administratorului doar acestuia.

Comanda GRANT - permite crearea utilizatorilor şi/sau stabilirea, respectiv

codificarea privilegiilor acestora pe patru nivele de privilegii:

Global – este aplicată tuturor bazelor de date existente pe un server

Database - este aplicată tuturor tabelelor dintr-o bază de date
Table - este aplicată tuturor coloanelor dintr-o tabelă
Column - este aplicată doar coloanelor specificate explicit

Sintaxa comenzii GRANT este:

GRANT privilegii [coloane]

ON componentă
TO nume_utilizator [IDENTIFIED BY 'parolă']
[WITH GRANT OPTIONS]

Unde:
privilegii - peprezintă o listă de privilegii desparţite prin virgulă, ce pot fi alese
dintre cele prezentate anterior plus clauza specială ALL are specifică toate privilegiile
posibile.
coloane - o listă optională de una sau mai multe coloane. Permite stabilirea
privilegiilor la nivel de coloane.
componenta - este numele unei baze de date sau tabele asupra cărora vor fi
stabilite privilegiile. Toate bazele de date se pot specifica prin *.*, şi este nivelul
Global. Nivelul Database se poate specifica prin nume_bd.*, iar nivelul Table prin
nume_bd.nume_tabelă. Dacă se specifică doar nume_tabelă se va interpreta ca fiind o
tabelă a bazei de date selectate. Nivelul Column se va obţine prin folosirea
unei liste de coloane nevide.

38
 nume_utilizator - este numele utilizatorului căruia i se atribuie privilegiile. El
poate conţine şi un nume de staţie de pe care are dreptul să se conecteze.
parola - specifică parola cu care utilizatorul se va conecta. Parola trebuie în
general să nu fie uşor de ghicit (să nu fie chiar numele contului sau un cuvânt din
dicţionar). Opţiunea IDENTIFIED BY este obligatorie deoarece dacă lispseşte,
utilizatorul se va putea conecta fără parolă.
WITH GRANT OPTION - dă dreptul utilizatorului să dea privilegii echivalente
cu ale sale altor utilizatori. Acestă opţiune poate fi utilizată pentru a delega dreptul de
administrare, inclusiv creare de utilizatori, unor administratori ale unor baze de date
particulare de pe server. Aceşti administratori nu vor putea însă să interacţioneze cu
alte baze de date.

Există posibilitatea vizualizării privilegiilor. Aceasta se realizează cu ajutorul

comenzii:

SHOW GRANTS FOR utilizator;

Deasemenea, există posibilitatea de a retrage drepturile cuiva. Sintaxa acestei

comenzi este:

REVOKE privilegii [coloane]

ON componenta
FROM nume_utilizator

Pentru a retrage privilegiul acordat prin clauza WITH GRANT OPTION,

se va utiliza sintaxa:

REVOKE GRANT OPTIONS

ON componenta
FROM nume_utilizator

39
 Capitolul 3

PHP şi MySQL

În PHP sunt implementate o serie de funcţii pentru conectarea şi comunicarea cu

server-ul MySQL. Folosind aceste funcţii, un program PHP poate obţine accesul
la bazele de date rezidente într-o bază de date MySQL şi le poate modifica.
Pentru a utiliza cu success funcţii PHP pentru a comunica cu serverul MySQL, trebuie
ca MySQL să ruleze pe o locaţie la care serverul web folosit să se poată conecta (nu
neapărat aceeaşi maşina cu cea a serverului web). De asemenea e necesar un cont de
utilizator (protejat de o parolă) şi trebuie să ştim numele bazei de date la care vrem să
ne conectăm.

3.1 Conectarea la serverul MySQL

O pagină PHP nu poate interoga o bază de date dacă nu este conectată la

aceasta. O conexiune poate fi privită ca un canal de comunicaţie prin care programul
transmite cereri SQL, iar serverul returnează raspunsurile corespunzătoare. Din PHP se
pot stabili două tipuri de conexiuni către un server MySQL: persistente şi nepersistente.
O conexiune persistentă se păstrează după prima utilizare chiar şi după
terminarea paginii curente sau după apelul mysql_close. Orice deschidere a unei noi
conexiuni cu aceiaşi parametrii va reutiliza pe cea veche în locul creării uneia noi. Ele
se realizează prin apelul funcţiei mysql_pconnect. Un avantaj al conexiunilor pemanente
este viteza de stabilirea a conexiunilor, resimţită în timpi de răspuns mai buni către
utilizatori. Ca dezavantaj putem menţiona blocarea îndelungată a unei conexiuni către
server, afectând numărul de clienţi care sunt acceptaţi spre a fi serviţi.

40
 O conexiune nepersistentă va fi distrusă la terminarea paginii sau la apelul
mysql_close. Se realizează prin apelul mysql_connect. Avantajele conexiunilor
temporare: nu blochează conexiunea decât pe perioada interpretării scriptului, iar
dezavantajul este timpul mai mare de răspuns datorat creării unei noi conexiuni la
fiecare apel.
Ambele tipuri de conexiuni asigură aceiaşi funcţionalitate. Singura diferenţă
dintre ele constă în eficienţa cu care se tratează deschiderea unei conexiuni raportată la
cantitatea de resurse blocate. Sintaxa lor este asemănătoare:

resource mysql_pconnect ( string server , string utilizator , string parolă )

resource mysql_connect ( string server , string utilizator , string parolă )

Parametri au următoarea semnificaţie:

server - specifică numele maşinii pe care rulează serverul de mySQL. Dacă

serverul de Web şi cel de mySQL rulează pe aceiaşi maşină, numele poate fi
"localhost". În cazul în care serverul de mysQL s-a instalat pe alt port decât cel standard
(3306), numarul portului se specifică după numele serverului, spre exemplu
"loalhost:3371".
utilizator - specifică numele utilizatorului pentru care se realizează conexiunea.
Deoarece prin nume serverul va stabili drepturile pe care programul le are asupra unei
anumite baze de date, acest parametru poate fi folosit pentru a creşte securitatea site-
ului.
parola - este un şir de caractere cuprinzând parola în clar a utilizatorului
specificat. Deoarece liniile php nu traverseză serverul Web, această parola nu poate fi
citită de utilizator prin comanda View Source a navigatorului Web. Singura problemă
apare dacă cineva neautorizat are acces local la sistemul de fişiere de pe server şi poate
citi direct fişierul php.

Pentru închiderea conexiunii, după ce nu mai este necesară, se va utiliza

comanda:

bool mysql_close ( resource identificatorBD );

Parametrul identificatorBD trebuie să fie un identificator valid de conexiune

returnat în prealabil de comada mysql_connect (sau mysql_pconnect).
Pentru a putea accesa datele din tabelele unei anumite baze de date de pe server,
după realizarea conexiunii, aceasta trebuie selectată prin comanda mysql_select_db:

bool mysql_select_db ( string numeBazaDeDate );

Funcţia returnează false în caz de eşec.

3.2 Interogări

În cadrul limbajului PHP interogările sunt emise cu ajutorul comenzii:

41
resource mysql_query ( string query );

şi există două categorii de interogări: interogările SELECT, şi interogările UPDATE,

INSERT şi DELETE.

Pentru a adăuga informaţii în baza de date trebuie transmisă din pagina de PHP
o interogare INSERT spre serverul de mySQL. Transmiterea unei interogări SQL spre
server se poate face cu ajutorul funcţiei mysql_query. Aceasta funcţie presupune
existenţa unei conexiuni deschise spre server, selecţia prealabilă a bazei de date şi
existenţa unor drepturi suficiente pentru rularea interogării.
Dacă interogarea transmite înapoi un rezultat (SELECT, DESCRIBE,
EXPLAIN sau SHOW), funcţia returnează un identificator spre resursa reprezentată de
rezultat. În cazul interogărilor acţiune (INSERT, DELETE, UPDATE etc.) funcţia va
retura TRUE dacă s-a executat corect interogarea. În ambele situaţii funcţia returnează
FALSE dacă interogarea nu a putut fi executată de server.

Spre deosebire de interogările UPDATE, INSERT şi DELETE, interogările

SELECT returnează rânduri de tabel. Rândurile unui tabel sunt incluse într-o structură
numită set de rezultate. Prelucrarea setului de rezultate returnat de o interogare
SELECT implică parcurgerea prin iteraţie a rândurilor setului de rezultate. Pentru a
obţine valoarea numărului de rânduri se foloseşte funcţia mysql_num_rows(). Funcţia
mysql_fetch_row() se poate folosi pentru a obţine următorul rând din secvenţa setului
de rezultate.
Pentru a evita problemele care apar din cauza caracterelor speciale interpretate
diferit de mySQL şi PHP, valorile variabilelor trebuie transformate corespunzător prin
utilizarea funcţiei addslashes: string addslashes ( string parametru) .Pentru a afla
numarul înregistrărilor afectate de o interogare acţiune se poate folosi funcţia
mysql_affected_rows:

int mysql_affected_rows ( );

3.3 Căutarea şi afişarea rezultatelor

Pentru a căuta informaţii într-o bază de date se vor utiliza interogări SELECT.
Procedura de transmitere a unor astfel de interogări este asemănătoare cu cea pentru
interogări acţiune. Diferenţa majoră la interogările de tip SELECT constă în necesitatea
de a afişa rezultatul interogării. În urma rulării unei interogări de căutare se va folosi
funcţia mysql_num_rows() pentru a afla numărul de înregistrări din rezultat. Acestei
funcţii i se va transmite ca şi parametru referinţa rezultata în urma apelului funcţiei
mysql_query().
Există trei metode diferite de a interpreta şi prelucra rezultatul unei interogări SELECT:

 Rezultatul este preluat prin funcţia mysql_fetch_array() şi interpretat ca un

tablou asociativ. Acest tablou are ca şi chei numele coloanelor selectate iar ca şi
valori, valorile corespondente din rezultat. Fiecare apel succesiv al funcţiei

42
 mysql_fetch_array() va returna urmatoarea înregistrare din rezultat. Când nu
mai sunt disponibile înregistrări, funcţia va retuna valoarea FALSE.
 Rezultatul este preluat prin funcţia mysql_fetch_row() şi interpretat ca un tablou
indexat numeric. Acest tablou are ca şi indexi numerele 0,1,2 etc. iar ca şi valori,
valorile corespondente coloanelor de pe poziţiile respective din rezultat. Fiecare
apel succesiv al funcţiei mysql_fetch_row() va returna urmatoarea înregistrare
din rezultat. Când nu mai sunt disponibile înregistrări, funcţia va retuna valoarea
FALSE.
 Rezultatul este preluat prin funcţia mysql_fetch_object() şi interpretat ca un
obiect. Acest obiect are ca şi atribute numele coloanelor selectate iar ca şi valori
ale acestora, valorile corespondente din rezultat. Fiecare apel succesiv al funcţiei
mysql_fetch_object va returna urmatoarea înregistrare din rezultat. Când nu mai
sunt disponibile înregistrari, funcţia va retuna valoarea FALSE.

Concluzii

Prima întrebare pe care cititorul acestei lucrări ar gândi-o, probabil, este

referitoare la faptul că prin intermediul aplicaţiei nu poţi cumpăra nimic şi poate părea
fără folos. Dar înainte de a întreba şi-ar da seama că majoritatea aplicaţiilor dezvoltate
cu ajutorul tehnologiilor PHP şi MySQL sunt magazinele online şi bibliotecile-librării
virtuale, de unde poţi cumpăra orice. Deşi există multe cărţi ce pot fi cumpărate, nu
mereu ne permitem să cumpărăm; şi dacă ne permitem să cumpărăm, nu avem timp să
le răsfoim.

Prin intermediul acestei lucrări am încercat să evidenţiez utilitatea combinării

celor două tehnologii PHP si MySQL pentru obtinerea de pagini Web cu continut
dinamic. Am ales limbajul PHP deoarece este special conceput pentru crearea de pagini
Web şi este un limbaj inter-platformă, sursă gratuită şi uşor de invăţat. De asemenea el
oferă suport pentru o gama largă de sisteme de baze de date. Am ales sistemul MySQL
deorece este un sistem de gestiune al bazelor de date relaţional şi este distribuit in regim
gratuit, ca şi PHP-ul. Alegerea a fost influenţată şi de facilitatea realizării unei intefeţe
prietenoase şi uşor de inteles.

Aplicaţia este realizată pentru a folosi tuturor, atât celor care vor deveni membrii
fideli şi vor ajuta la imbunătăţirea paginii de internet, cât şi celor care, pentru a evada
din rutină, se vor relaxa pentru câteva minute citind o poezie. Bine înteles, pe internet
există multe pagini pe care se pot găsi poezii, dar aceasta pagină va destinată întru totul
domeniului literar. Membrii vor putea să îşi împărtăşească gândurile, să îşi spună
părerea despre o anumită poezie, vor putea veni cu noi idei pentru această pagină.
Sistemul de notare existent are rolul de a spori interesul şi dorinţa membrilor de
a posta noi poezii care să fie printre primele în topul poeziilor. Următorul pas in cadrul
paginii va fi realizarea unui forum unde utilizatorii să poată discuta pe baza poeziilor, şi
nu numai. Părerile si ideile utilizatorilor vor fi importante pentru dezvoltarea continuă a
acestei pagini.

43
 Bibliografie
Nr. Titlu
crt.
1 PHP-Portal
2 Dynamic site with PHP_MySQL
3 PHP 4 A BEGINNER'S GUIDE
4 PHP Manual
5 PHP/MySQL Tutorial
6 PHP and MySQL. Web
Development
7 Beginning PHP, Apache,
MySQL Web Development
8 Kevin Yank
44
Autor
http://www.php.maelvi.ro/pgs/tut_mysql_date.php
Ashraful Anam
Bill McCarty, traducere de Mihai Mănăstireanu
2002 Teora
Stig Sæther Bakken, Alexander Aulbach, Egon
Schmid, Jim Winstead
Lars Torben Wilson
Rasmus Lerdorf
Andrei Zmievski
Jouni Ahto
or http://www.php.net/docs.php
Graeme Merral
Luke Welling and Laura Thomson
Michael Glass, Yann Le Scouarnec, Elizabeth
Naramore, Gary Mailer, Jeremy Stolz, Jason
Gerner
Build your own database driven website using
PHP and MySql
SitePoint, August 2001