PREFAȚĂ………………………………………………………………………………………………………………….. 7… [624153]
CUPRINS
PREFAȚĂ………………………………………………………………………………………………………………….. 7
Capitolul 1:Introducere……………………………………………………………………………………………. 9
1.1Ce este PHP?…………………………………………………………………………………………… 10
1.2Istoria limbajului PHP ………………………………………………………………………………. 10
1.3Îmbunătățirile aduse de PHP4 ……………………………………………………………………. 11
1.4Motorul Zend………………………………………………………………………………………….. 11
1.5Îmbunătățirile aduse de PHP5 ……………………………………………………………………. 12
1.6Avantaje ale dezvoltării aplicațiilor cu PHP ………………………………………………… 13
1.6.1Viteza…………………………………………………………………………………………………. 13
1.6.2Free și Open Source ……………………………………………………………………………… 13
1.6.3Performanța…………………………………………………………………………………………. 13
1.6.4Portabilitate…………………………………………………………………………………………. 13
1.7Instalare și configurare ……………………………………………………………………………… 13
1.8Rezumat…………………………………………………………………………………………………. 14
Capitolul 2:Primul script PHP………………………………………………………………………………… 15
2.1Primul script PHP……………………………………………………………………………………. 16
2.2HTML și PHP în același document ……………………………………………………………. 18
2.3Comentarii în PHP …………………………………………………………………………………… 18
2.4Rezumat…………………………………………………………………………………………………. 19
Capitolul 3:Sintaxa de bază. Tipuri de date PHP ……………………………………………………….. 20
3.1Variabile PHP…………………………………………………………………………………………. 21
3.1.1Variabile cu nume dinamic ……………………………………………………………………. 22
3.2Tipuri de date………………………………………………………………………………………….. 22
3.2.1Tipul boolean………………………………………………………………………………………. 22
3.2.2Tipul integer………………………………………………………………………………………… 23
3.2.3Tipul float……………………………………………………………………………………………. 23
3.2.4Tipul string………………………………………………………………………………………….. 23
3.2.5Tipul array…………………………………………………………………………………………… 24
3.2.6Tipul object…………………………………………………………………………………………. 25
3.2.7Tipul NULL………………………………………………………………………………………… 25
3.3Operatori și expresii …………………………………………………………………………………. 26
3.3.1Operatori de atribuire ……………………………………………………………………………. 26
3.3.2Operatori aritmetici ………………………………………………………………………………. 26
3.3.3Operatori pe biți…………………………………………………………………………………… 26
3.3.4Operatori de comparare …………………………………………………………………………. 27
3.3.5Operatori de incrementare/decrementare …………………………………………………. 27
3.3.6Operatori logici……………………………………………………………………………………. 28
3.3.7Operator pentru controlul erorilor …………………………………………………………… 28
3.3.8Operator pe string-uri ……………………………………………………………………………. 28
3.3.9Operatori pe array-uri …………………………………………………………………………… 28
3.3.10Operatori de cast………………………………………………………………………………….. 29
3.4Precedența și asociativitatea operatorilor …………………………………………………….. 29
3.5Constante………………………………………………………………………………………………… 30
3.6Rezumat…………………………………………………………………………………………………. 30
Capitolul 4:Structuri de control ………………………………………………………………………………. 31
4.1Instrucțiuni de decizie ………………………………………………………………………………. 32
4.1.1Instrucțiunea if…………………………………………………………………………………… 32
3
4 CUPRINS
4.1.2Instrucțiunea switch………………………………………………………………………….. 33
4.1.3Instrucțiunea break…………………………………………………………………………….. 34
4.1.4Instrucțiunea continue……………………………………………………………………… 34
4.2Instrucțiuni repetitive ……………………………………………………………………………….. 34
4.2.1Instrucțiunea while…………………………………………………………………………….. 35
4.2.2Instrucțiunea do-while……………………………………………………………………… 35
4.2.3Instrucțiunea for………………………………………………………………………………… 36
4.2.4Instrucțiunea foreach………………………………………………………………………… 37
4.3Rezumat…………………………………………………………………………………………………. 38
Capitolul 5:Funcții PHP…………………………………………………………………………………………. 39
5.1Ce este o funcție?…………………………………………………………………………………….. 40
5.2Apelul unei funcții …………………………………………………………………………………… 40
5.3Definirea unei funcții ……………………………………………………………………………….. 41
5.4Variabile globale……………………………………………………………………………………… 44
5.5Funcții cu nume dinamic …………………………………………………………………………… 45
5.6Rezumat…………………………………………………………………………………………………. 46
Capitolul 6:Preluarea datelor dintr-un formular ………………………………………………………… 47
6.1Formulare HTML…………………………………………………………………………………….. 48
6.2Manipularea datelor dintr-un formular ……………………………………………………….. 49
6.2.1Variabila superglobală $_GET………………………………………………………………. 50
6.2.2Variabila superglobala $_POST…………………………………………………………….. 51
6.2.3Variabila superglobala $_REQUEST………………………………………………………. 51
6.3Validarea datelor din formular …………………………………………………………………… 52
6.4Cod HTML și PHP într-o singură pagină ……………………………………………………. 53
6.5Rezumat…………………………………………………………………………………………………. 57
Capitolul 7:Cookie-uri…………………………………………………………………………………………… 58
7.1Despre cookie-uri…………………………………………………………………………………….. 59
7.2Management-ul cookie-urilor ……………………………………………………………………. 59
7.2.1Crearea unei cookie ………………………………………………………………………………. 59
7.2.2Accesul la valorile unui cookie ………………………………………………………………. 60
7.2.3Ștergerea unei variabile cookie ………………………………………………………………. 61
7.3Array de cookie-uri ………………………………………………………………………………….. 61
7.4Rezumat…………………………………………………………………………………………………. 61
Capitolul 8:Sesiuni………………………………………………………………………………………………… 62
8.1Ce este o sesiune?……………………………………………………………………………………. 63
8.2Pornirea unei sesiuni ………………………………………………………………………………… 64
8.3Lucrul cu variabile sesiune ……………………………………………………………………….. 65
8.4Distrugerea unei sesiuni ……………………………………………………………………………. 66
8.5Rezumat…………………………………………………………………………………………………. 67
Capitolul 9:Lucrul cu fișiere…………………………………………………………………………………… 68
9.1Deschiderea fișierelor și crearea fluxurilor de lucru cu fișiere ………………………..69
9.2Operații elementare cu fișiere ……………………………………………………………………. 70
9.2.1Citirea din fișier…………………………………………………………………………………… 70
9.2.2Scrierea în fișier…………………………………………………………………………………… 72
9.3Gestionarea lucrului cu fișiere …………………………………………………………………… 73
9.3.1Copierea fișierelor………………………………………………………………………………… 73
9.3.2Ștergerea fișierelor ……………………………………………………………………………….. 73
9.3.3Redenumirea fișierelor ………………………………………………………………………….. 73
CUPRINS 5
9.4Lucrul cu directoare …………………………………………………………………………………. 74
9.5Operații pe fișiere…………………………………………………………………………………….. 74
9.5.1Verificarea existenței unui fișier …………………………………………………………….. 74
9.5.2Fișier sau Director? ………………………………………………………………………………. 74
9.5.3Funcții ce returnează atributele unui fișier ……………………………………………….. 75
9.5.4Funcții de lucru cu pointer-ul unui fișier …………………………………………………. 75
9.6Colectarea datelor dintr-un formular ………………………………………………………….. 75
9.7Încărcarea fișierelor …………………………………………………………………………………. 76
9.8Rezumat…………………………………………………………………………………………………. 79
Capitolul 10:Clase și obiecte în PHP5 ……………………………………………………………………. 80
10.1Concepte de bază…………………………………………………………………………………….. 81
10.1.1Constructorul……………………………………………………………………………………….. 82
10.1.2Destructorul…………………………………………………………………………………………. 82
10.1.3Modificatori de vizibilitate ……………………………………………………………………. 82
10.1.4Membri statici……………………………………………………………………………………… 84
10.2Atribute cu valori constante ………………………………………………………………………. 85
10.3Crearea obiectelor din clasa predefinită stdClass……………………………………. 86
10.4Parcurgerea atributelor unei clase cu foreach………………………………………….. 86
10.5Moștenirea………………………………………………………………………………………………. 86
10.5.1Constructorul clasei derivate ………………………………………………………………….. 87
10.5.2Destructorul clasei derivate ……………………………………………………………………. 87
10.5.3Modificatorul de vizibilitate protected………………………………………………. 88
10.6Clase și metode finale ………………………………………………………………………………. 88
10.7Clase abstracte………………………………………………………………………………………… 88
10.8Interfețe………………………………………………………………………………………………….. 90
10.9Operatorul instanceof………………………………………………………………………… 91
10.10Funcții cu argumente de tip impus ……………………………………………………………… 92
10.11Funcții “magice”……………………………………………………………………………………… 93
10.11.1Getter-i și setter-i……………………………………………………………………………… 93
10.11.2__toString()……………………………………………………………………………………… 95
10.11.3__isset()…………………………………………………………………………………………… 95
10.11.4__unset()…………………………………………………………………………………………. 95
10.11.5__call()……………………………………………………………………………………………. 96
10.12Obiecte și referințe …………………………………………………………………………………… 96
10.13Clonarea obiectelor ………………………………………………………………………………….. 97
10.14Compararea obiectelor ……………………………………………………………………………… 99
10.15Rezumat…………………………………………………………………………………………………. 99
Capitolul 11:Excepții…………………………………………………………………………………………. 100
11.1Procesarea excepțiilor …………………………………………………………………………….. 101
11.2Clasa Exception…………………………………………………………………………………….. 102
11.3Excepții derivate……………………………………………………………………………………. 103
11.3.1Excepții predefinite PHP ……………………………………………………………………… 103
11.3.2Excepții definite de utilizator ……………………………………………………………….. 104
11.4Tratarea excepțiilor în mod specific PHP ………………………………………………….. 104
11.4.1Funcția set_exception_handler() ……………………………………………. 105
11.4.2Erori tratate ca excepții ……………………………………………………………………….. 106
11.5Rezumat……………………………………………………………………………………………….. 107
Capitolul 12:Persistența datelor cu PHP ……………………………………………………………….. 108
6 CUPRINS
12.1Conectarea la server-ul MySQL ………………………………………………………………. 109
12.2Selectarea unei baze de date ……………………………………………………………………. 110
12.3Detectarea erorilor …………………………………………………………………………………. 110
12.4Operații fundamentale asupra unei baze de date …………………………………………. 111
12.4.1Expedierea unei cereri catre MySQL …………………………………………………….. 111
12.4.2Numărul de rânduri afectate de o cerere ………………………………………………… 113
12.4.3Obținerea valorii unui câmp care se autoincrementează …………………………… 113
12.4.4Interogări ale bazei de date ………………………………………………………………….. 114
12.5Accesarea unui ResultSet ………………………………………………………………………… 114
12.5.1Numărul de rânduri al rezultatului unei interogări ………………………………….. 114
12.5.2Parcurgerea unui ResultSet ………………………………………………………………….. 115
12.5.3Poziționarea indicatorului de tabel ………………………………………………………… 117
12.5.4Numărul de coloane al rezultatului unei interogări ………………………………….. 117
12.5.5Numele câmpurilor unei interogări ……………………………………………………….. 117
12.5.6Lungimea unui câmp din tabela rezultat al unei interogări ………………………..118
12.5.7Tipul unui câmp din tabela rezultat al unei interogări ……………………………… 118
12.5.8Atributele unui câmp din tabela rezultat al unei interogări ………………………..118
12.6Informații despre baza de date …………………………………………………………………. 119
12.6.1Listarea bazelor de date ………………………………………………………………………. 119
12.6.2Listarea tabelelor dintr-o bază de date …………………………………………………… 119
12.7Rezumat……………………………………………………………………………………………….. 120
Bibliografie…………………………………………………………………………………………………………….. 121
PREFAȚĂ
PHP (acronim pentru Php Hypertext Preprocessor) este un limbaj de scripting de uz general,
cu cod-sursă deschis (open source), utilizat pentru dezvoltarea aplicațiilor web.
Un avantaj major al acestui limbaj este simplitatea extremă în utilizare, dar care conține și
multe facilități și extensii pentru programatorii profesioniști. PHP oferă libertatea alegerii
sistemului de operare și a server-ului web. Pe de altă parte, PHP oferă posibilitatea utilizării
programării orientate pe obiect (POO). Începând cu PHP 5, POO este un model complet. În
sfârșit, una dintre cele mai puternice și semnificative facilități ale PHP este posibilitatea
interacționării cu un mare număr de servere de baze de date.
Această carte începe prin a descrie modul de funcționare a limbajului PHP, apoi trece la
detalierea modului de creare si de încărcare a programelor PHP.
Cele douăsprezece capitole ale cărții abordează în mod controlat o prezentare gradată a
conceptelor folosite în activita tea de programare și a elementelor specifice limbajului PHP.
Fiecare modul conți ne elemente destinate a reîmprospăta memoria și înțelegerea cititorului.
În primele module am evidențiat câteva din caracteristicile limbajului PHP. Am discutat
despre diverse tipuri de variabile, tipuri de date în PHP, despre câțiva din cei mai importanți
operatori și posibilitatea de a îi combina pentru a obține expresii. Am studiat apoi structurile
de control și modul în care ele sunt folosite în scripturile PHP pentru crearea paginilor
flexibile și dinamice, am discutat despre funcții, despre cum să le apelăm, cum să le declarăm
și cum să le definim.
Am continuat discuția cu elemente mai avansate: lucrul cu formulare, variabile superglobale,
cookie-uri și sesiuni. Am făcut apoi un alt pas important în crearea paginilor web dinamice și
anume organizarea fișierelor sursă astfel încât să permită soluții flexibile de navigare și
validare. Am studiat modul în care PHP poate interacționa cu fișiere externe aplicației.
Un capitol important este dedicat modului în care PHP implementează principalele
caracteristici ale programării orientate pe obiect. Astfel, am discutat despre clase, funcții,
moștenire, funcții magice și compararea obiectelor.
Partea finală a cărții s-a referit la tratarea excepțiilor și la persistența datelor. Discuțiile au fost
legate de gestiunea bazelor de date cu ajutorul conexiunii dintre server-ul PHP și server-ul
MySQL, funcții de conectare, funcții de expediere a unor cereri și funcții de manipulare a
rezultatului cererii.
7
8
Capitolul 1:Introducere
În acest capitol vom aborda următoarele subiecte:
PHP, considerații generale
Istoria limbajului PHP
Îmbunătățirile aduse de PHP4
Motorul Zend
Îmbunătățirile aduse de PHP5
Avantajele dezvoltării aplicațiilor cu PHP
Instalare și configurare
9
10 Capitolul 10: Clase și obiecte în PHP5
1.1 Ce este PHP?
Inițial, PHP a fost acronimul de la Personal Home Page, dar a fost modificat pentru a se
alinia conversiei de nume a sistemului de operare GNU1 și acum reprezintă acronimul pentru
PHP Hypertext Preprocessor.
Pentru a întelege la ce și de ce folosim limbajul PHP vom da în continuare câteva dintre
principalele sale caracteristici:
este un limbaj de script, adică un limbaj de programare ce permite controlul uneia sau
mai multor aplicații software , și este folosit pentru crearea aplicațiilor web dinamice.
Spre exemplu, codul surs ă PHP poate fi inclus în cod HTML2 sau poate fi cod gazd ă
pentru cod HTML;
este un limbaj server-side, adică operațiile cerute de client se execută pe un server. În
cazul PHP-ului, server-ul, cunoscut și sub numele de web server, reprezintă un
program software ce rulează pe un calculator ce poate fi accesat de către calculatorul
client. Operațiile se execută server-side pentru că pe calculatorul client nu există
resursele necesare executării acestora;
pentru a rula o aplicație PHP avem nevoie a șadar de un server web pe care avem
instalat interpretorul PHP, reprezentat de CGI3 sau un modul de server, precum și de
un navigator web instalat pe calculatorul client. Codul sursă PHP este interpretat de
server-ul web, care generează cod HTML, cod ce va fi vizualizat de client prin
intermediul navigatorului;
include în nucleul de bază librării open source , adică colecții de funcții a căror
implementare poate fi modificată și redistribuită;
este free software , adică utilizarea sa este gratuită;
are module predefinite pentru accesul FTP4 al server-elor, pentru accesul la servere de
baze de date, șamd;
poate fi folosit pe aproape toate sistemele de operare, incluzând Linux , multe variante
de Unix , Microsoft Windows , Mac OS X sau RISC OS ;
1.2 Istoria limbajului PHP
PHP a fost conceput în anul 1994 și a fost inițial munca unui singur om, Rasmus Lerdorf , care
a rescris mici părți din script-uri Perl cu scopul a-și gestiona mai ușor pagina web. Lerdorf
este cel care a creat primul CGI pentru PHP, pe care l-a scris în limbajul C.
Următoarea versiune importantă a fost PHP3, apărută în 1997, și a fost realizată prin munca
mai multor programatori. PHP3 a reprezentat practic rescrierea PHP-ului, cu un interpretor
nou realizat de Zeev Suraski și Andi Gutmans , cu diferențe de sintaxă și noi facilități. Acea
versiune a făcut ca PHP să devină unul din cele mai puternice limbaje server-side.
Principalele atuuri ale acelei versiuni erau date de folosirea server-ului web Apache și a
server-ului de baze de date MySQL, care i-au asigurat PHP-ului, de altfel, și popularitatea.
Apache era, încă de atunci, unul dintre cele mai folosite web servere din lume, iar PHP3 putea
fi compilat ca un modul Apache. La rândul său MySQL era, și în parte mai este, un server de
1 GNU reprezintă acronimul recursiv pentru “GNU Nu-i Unix”
2 HTML – HyperText Markup Language
3 CGI – The Common Gateway Interface, reprezintă un protocol prin care soft-urile externe apelează un server web pentru a obține conținut
dinamic.
4 FTP – File Transfer Protocol
10.9 Operatorul instanceof 11
baze de date puternic, care putea fi folosit gratis, iar PHP3 oferea o multitudine de funcții
pentru interacționarea cu servere de baze de date relaționale.
Dacă în domeniul server-elor web PHP folosește aproape exclusiv Apache, astăzi PHP
interacționează cu o mulțime de servere de baze de date. În continuare, vom da o listă cu
aceste servere:
Adabas D Ingres Oracle
dBase InterBase Ovrimos
Empress FrontBase PostgreSQL
FilePro (doar citire) mSQL Solid
Hyperwave Direct MS-SQL Sybase
IBM DB2 MySQL Velocis
Informix ODBC Unix dbm
Figura 1.1: Servere de Baze de Date cu care poate interac ționa PHP
1.3 Îmbunătățirile aduse de PHP4
Următoarea versiune importantă a fost PHP4, apărută în mai 2000. Aceasta introduce o serie
de noi funcționalități pe care le vom prezenta în cele ce urmează:
o nouă instrucțiune, foreach, pentru parcurgerea datelor de tip array;
mai multe funcții pentru lucrul cu date de tip array: array_intersect() ,
array_keys() , array_merge() , explode() , sort() etc;
tipul de date boolean;
o funcționalitate importantă din PHP3 era capabilitatea de a numi tag-urile de tip
form ca și cum ar reprezenta elementele unui array. Această funcționalitate a fost
extinsă în PHP4 pentru a suporta șiruri multidimensionale;
suportul pentru programarea orientată pe obiecte era rudimentară în PHP3. În PHP4
aceasta este semnificativ extinsă. Spre exemplu, acum este posibil să apelăm o metodă
suprascrisă dintr-o clasa derivată;
PHP4 oferă suport pentru sesiunile utilizator, folosind atât variabilele cookie cât și
variabilele sesiune. În PHP4 putem defini variabile într-o sesiune și apoi accesa sau
modifica valoarea lor în orice pagină din sesiunea curentă;
noul operator de comparație “ ===”, care a fost introdus pentru a testa egalitatea
variabilelor atât din punct de vedere al tipului cât și al valorii.
PHP4 oferă suport predefinit pentru JavaScript și XML5.
1.4 Motorul Zend
A fost creat de aceiași Zeev Suraski și Andi Gutmans la începutul anilor 2000. Zend este un
motor de scripting , open source, adică o mașină virtuală, care stă la baza modulelor PHP
pentru servere web.
Zend este construit pentru a îmbunătăți performanța, dar și pentru a spori flexibilitatea.
Comunicarea cu server-ele cu care PHP interacționa a fost, de asemenea, îmbunătățită.
5 XML – eXtensible Markup Language
12 Capitolul 10: Clase și obiecte în PHP5
Motorul Zend a contribuit la succcesul lui PHP4 și, mai mult, a asigurat portabilitatea, adică o
mare parte din codul scris în PHP3 putea rula și cu PHP4, fără modificări, dar cu performanță
de viteză și de 200 de ori mai mare.
Versiunea curentă a acestei mașini virtuale este motorul Zend II și reprezintă nucleul pentru
versiunea 5 a PHP-ului.
1.5 Îmbunătățirile aduse de PHP5
A fost creat în 2004 și are la rândul său mai multe subversiuni. Ultima, 5.3.0, a fost introdusă
în iunie 2009. Ca și pentru PHP4 vom da principalele functionalități pe care 5.3.0 le introduce
față de PHP4.
conține suport pentru tratarea excepțiilor;
conține librăria standard PHP6, ce cuprinde clase predefinite:
opentru structuri de date: stive, cozi, heap-uri, cozi de prioritate, liste dublu
înlănțuite;
opentru iteratori: iteratori de array-uri, cu filtru, multipli, etc;
ointerfețe predefinite;
suport XML îmbunătățit: XML-Parser, XML-Reader, XML-Writer, etc;
web services;
implementarea standardului MIME7 pentru e-mail;
PHP5 introduce suport pentru MySQL4.1 precum și diferite extensii cum ar fi
MySQLi8. Extensia MySQLi este practic o colecție de clase ale căror instanțe crează
obiecte pentru lucrul cu server-ul MySQL. Spre exemplu:
oclasa mysqli este folosită pentru a crea obiecte conexiune și are abilitatea de a
deschide și închide conexiuni. De asemenea, preia contextul și starea
informației de pe server;
oclasa mysqli_stmt oferă posibilitatea de a crea prepared statement -uri,
multiple statemen t-uri sau tranzacții precum și suport pentru executarea
interogărilor în baza de date;
una din cele mai importante îmbunătățiri este introducerea claselor și interfețelor.
PHP5 include trei cuvinte noi: final, abstract și interface pentru a facilita
folosirea moștenirii și a interfețelor. Când o metodă este declarată final, atunci nu
poate fi suprascrisă de o clasă derivată. Când o metodă este declarată abstract , ea
trebuie să fie definită în clasa derivată. Folosite în combinație, clasele abstracte și
interfețele permit un design la nivel înalt și suport adecvat obiectelor. Ele reprezintă
cele mai puternice unelte pentru programarea orientată pe obiecte.
tot în domeniul programării orientate pe obiect în PHP5 se implementează clonarea și
reflexivitatea. Clonarea obiectelor permite implementarea metodei __clone() pentru
a defini exact ce se întâmplă cu un obiect atunci când este clonat (cât de mult se
copiază din datele unui obiect atunci când acesta este clonat). Programarea reflexivă
este gestionată de clasele reflexive ce oferă programatorilor procesul de reverse-
engineering în mod programatic.
6 SPL – Standard PHP Library
7 MIME – Multipurpose Internet Mail Extensions
8 i – provine de la improved
10.9 Operatorul instanceof 13
1.6 Avantaje ale dezvoltării aplicațiilor cu PHP
Vom da în continuare succint câteva motive importante pentru care putem alege PHP ca
limbaj de dezvoltare al aplicațiilor web, așa cum, pe larg, am argumentat în paragrafele
anterioare.
1 Viteza
PHP permite separarea codului HTML de elementele scriptului și astfel se reduce timpul de
dezvoltare pentru multe proiecte. În multe cazuri putem separa etapa de “coding” de cea de
design și cea de “build”. Astfel, se elimină obstacolele care stau în calea unui design flexibil
și eficient.
2 Free și Open Source
Aceasta înseamnă fără costuri și cu posibilitatea modificării surselor anumitor biblioteci de
funcții.
3 Performanța
Din cauza motorului puternic Zend, PHP este rapid si flexibil.
4 Portabilitate
PHP este gândit să ruleze pe multe sisteme de operare și să interacționeze cu multe servere
web și servere de baze de date.
1.7 Instalare și configurare
Sunt trei modalități principale în care se poate folosi PHP-ul:
1. Scripturi ce rulează pe partea de server
2. Scripturi ce rulează din linia de comandă
3. Aplicații GUI9 ce rulează la client
Pentru prima și cea mai utilizată dintre modalități avem nevoie de următoarele: interpretorul
PHP, un server web și un navigator web. În plus, pentru aplicații ce folosesc baze de date, este
necesar și un server de baze de date cu care server-ul web să comunice. În principiu,
conexiunea la server-ul de baze de date se realizează exclusiv prin server-ul web. Pentru
editarea script-urilor PHP avem nevoie de un editor mai performant, de un IDE10.
Observația 1.1: Întreaga prezentare a acestei cărti se bazează pe resurse free și open source.
Vom indica în continuare resursele cu ajutorul cărora am dezvoltat și rulat aplicațiile din
această carte. Cititorul le poate foarte ușor schimba cu cele pe care le consideră mai potrivite.
Portabilitatea și flexibilitatea PHP-ului permite ușor realizarea acestui lucru.
Pentru instalarea p ărții de servere vom utiliza pachetul XAMPP11. XAMPP necesită un fișier
zip, tar sau exe ce poate fi descărcat și rulat fără prea multe configurări (de obicei deloc).
Adresa la care îl putem găsi este: http://www.apachefriends.org/en/xampp-windows.html ,
pentru versiunea în limba engleză și sistemul de operare Windows . Putem găsi versiuni și
9 GUI – Graphical User Interface
10 IDE – Integrated Development Environment
11 XAMPP – X – cross-platform, A – Apache HTTP Server, M – MySQL, P – PHP, P – Perl
14 Capitolul 10: Clase și obiecte în PHP5
pentru Linux , Solaris și Mac OS X . Versiunea de PHP folosită în rularea tuturor exemplelor
acestei cărți este 5.2.9.
Pentru editarea aplicațiilor PHP vom folosi platforma de dezvoltare Eclipse ce conține un IDE
și un sistem de plug-in -uri pentru extinderea capabilităților. Adresa web este:
http://www.eclipse.org/downloads , de unde descărcăm Eclipse for PHP Developers (Galileo ,
apărut în iunie 2009). Există variante disponibile pentru Windows, Linux și Mac. Dacă se
respectă condițiile instalării predefinite, după dezarhivarea zip-ului, nu mai trebuie făcute alte
configurări.
În cazul folosirii PHP-ului în linie de comandă, facilitate ce a fost introdusă începând cu
versiunea 4.3.0, trebuie să apelăm la interfața numită CLI12. Aceasta este disponibilă în mod
predefinit începând cu versiunea anunțată. În linia de comandă putem rula script-uri care să
genereze automat imagini offline sau să proceseze fișiere text, dependent de argumentele
transmise.
În cazul folosirii PHP-ului pentru scrierea aplicațiilor GUI, ce rulează de partea clientului, se
folosește extensia PHP-GTK. Aceasta este o abordare total diferită decât cea a scrierii
paginilor web deoarece nu vom avea un rezultat HTML ci vom manevra ferestre și obiecte.
PHP-GTK nu este inclus în distribuția oficială a PHP-ului.
Ultimele două modalități de utilizare a PHP-ului nu sunt tratate în această carte.
1.8 Rezumat
În acest capitol am făcut o scurtă trecere în revistă a caracteristicilor de bază ale limbajului
PHP, am urmărit istoria PHP-ului și am marcat principalele deosebiri ce există între versiunile
PHP4 și PHP5. În final, am dat o modalitate de instalare și configurare a PHP-ului și a unui
mediu de dezvoltare a aplicațiilor PHP.
12 CLI – Command Line Interface
10.9 Operatorul instanceof 15
Capitolul 2: Primul script PHP
În acest capitol vom aborda următoarele subiecte:
Crearea, încărcarea și rularea unui script PHP
Scrierea de cod HTML și PHP în același document
Utilizarea comentariilor în PHP.
16 Capitolul 10: Clase și obiecte în PHP5
2.1 Primul script PHP
Pentru început creăm o aplicație simplă ce va afișa textul: hello world! într-un browser
web.
Așa cum am anunțat deja în Capitolul 1 , editarea este făcută în Eclipse. Pașii care trebuie
urmați pentru aceasta sunt:
1.Deschiderea unui workspace . Recomandăm ca workspace-ul să fie creat în directorul
htdocs (htdocs este spațiul de pe server-ul Apache în care se găsesc aplicațiile PHP),
din pachetul xampp (xampp este chiar numele directorului în care a fost instalat
pachetul). În plus, pentru a evita intersectarea cu alte aplicații deja existente
recomandăm și crearea unui subdirector cu numele aplicației curente. Noi am numit
acest director carte. (Recomandăm, de asemenea, ca numele directorului să
folosească exclusiv acele caractere ASCII acceptate în adresele URL. Numele
directorului va apare în adresa web a paginilor aplicației).
2.Crearea unui proiect . În Eclipse alegem din meniul File->New->PHP Project (acest
director este un subdirector al directorului aplicației, carte, și trebuie să aibă un nume
supus acelorași reguli ca și cel al aplicației). Vom numi acest proiect exemplul21 .
3.Crearea fișierului sursă . În Eclipse alegem File->New->PHP File . Denumim acest
fișier, ex.php, ținând cont de regula de nume anterior recomandată. Extensia pentru
fișierele sursă PHP este .php. Extensia este foarte importantă pentru că îi transmite
server-ului faptul că acest fișier conține cod PHP și trebuie interpretat ca atare.
Edităm, în continuare, fișierul:
<?php
echo "hello world!";
?>
4.Încărcarea și rularea aplicației. Odată editarea încheiată fișierul trebuie încărcat pe
server. Simpla salvare a fișierului, datorită spațiului de lucru corect creat anterior,
determină încărcarea acestuia pe server. În cazul Eclipse-ului încărcarea pe server se
face automat, la rulare. La prima rulare însă în Eclipse, trebuie să creăm o configurație
specifică aplicației curente. Apoi, simpla acționare a opțiunii Run->Run As->PHP Web
Page determină rularea aplicației pe baza configurației anterior stabilite. Fereastra de
configurare se obține din Run->Run configurations și în cazul aplicației noastre
trebuie sa aibă următorul conținut:
10.9 Operatorul instanceof 17
Pentru că aplicația nu se află direct în directorul htdocs, ci într-un subdirector al
acestuia, vom modifica adresa URL a aplicației, de pe server, acționând butonul
Configure… din dreptul PHP Server .
5.După rulare, conținutul fișierului, transformat în cod HTML, va fi afișat în browser.
Eclipse permite setarea tipului de browser. Aceasta poate fi facută din Window->Web
browser. Pagina va fi deschisă cu browser-ul curent. În cazul aplicației noastre
adresa URL va fi: http://localhost/carte/exemplul21/ex.php . localhost ,
care desemnează faptul că serverul se află pe calculatorul curent. Uneori în locul
cuvântului rezervat localhost putem folosi adresa 127.0.0.1 . Dacă serverul se află
pe un alt calculator, în loc de localhost vom introduce adresa IP13 a acestuia.
Așa după cum am observat în algoritmul de editare prezentat anterior, codul PHP a fost
delimitat de două marcatoare, unul de început și unul de sfârsit. În mod predefinit acestea sunt
<?php respectiv ?>. Avem însă la dispoziție mai multe posibilități de marcare a codului PHP.
Unele sunt date în Exemplul 2.1 .
Exemplul 2.1 : Moduri de marcare a codului PHP
<?php
echo "hello world!";
?>
––––––––-
<SCRIPT LANGUAGE= "php">
echo "hello world!";
</SCRIPT>
––––––––-
<?
echo "hello world!";
?>
Primele două sunt predefinite și unanim acceptate. Din cauza sintaxei greoaie, cea de-a doua
este mai rar întrebuințată. Ce-a de-a treia nu este întotdeauna acceptată. Ea poate fi activată
sau nu din fișierul php.ini. Există și o a patra variantă, folosind tag-uri ASP, dar aceasta nu
este recomandată, mai mult, ea trebuie explicit activată în php.ini.
În Exemplul 2.1 am folosit funcția echo, ce determină afișarea în browser, sub forma unui șir
de caractere, a parametrilor săi.
13 IP – Internet Protocol
18 Capitolul 10: Clase și obiecte în PHP5
O instrucțiune PHP se termină de obicei cu caracterul “ ;” (punct și virgulă). Excepțiile de la
această regulă vor fi discutate în capitolele următoare. În cele mai multe cazuri dacă omitem
“;” interpretorul va returna o eroare.
2.2 HTML și PHP în același document
Pentru că atât HTML cât și PHP sunt limbaje de script, putem include cod PHP în cod HTML
și invers. În oricare dintre cazuri fișierul va trebui sa aibă extensia .php.
În primul caz includerea se face prin intermediul marcatorilor înainte amintiți ( Exemplul 2.2 ).
Cazul invers, al includerii codului HTML într-un bloc PHP, va fi descris în capitolele
următoare.
Exemplul 2.2 : Cod PHP inclus într-un script HTML
<html>
<head>
<title>
Exemplul 2.2: Cod PHP inclus intr-un script HTML
</title>
</head>
<body>
<b>
<?php
echo "hello world!";
?>
</b>
</body>
</html>
Rezultatul este un text formatat, prin îngroșarea literelor. Dacă în browser am vizualiza codul
sursă al paginii, atunci ceea ce am obține ar fi cod pur HTML.
Într-un fișier putem serializa oricâte blocuri de cod PHP având cod HTML intercalat.
2.3 Comentarii în PHP
În general, comentariile sunt folosite pentru a face codul sursă mai ușor de înțeles sau pentru a
delimita zone de cod greșite sau inutile. Comentariile reprezintă zone de cod ce nu vor fi luate
în considerare de către intrepretor. Din acest motiv conținutul comentariilor, ca sintaxă și
semantică, stă în responsabilitatea programatorului, singurele restricții fiind includerea
marcatorilor pentru comentarii.
În PHP pentru delimitarea comentariilor se folosesc caracterele // (dublu slash), sau #
(diez). Tot textul care urmează acestor caractere (până la sfârșitul liniei) reprezintă un
comentariu. Pentru a comenta mai multe linii se folosește perechea de marcatori /* si */.
Exemplul 2.3 : Cod PHP cu comentarii
<?
// Acesta este primul meu comentariu
# si acesta este un comentariu pe o linie
/*
10.9 Operatorul instanceof 19
tot ce scriem intre aceste simboluri este
un comentariu si nu va avea efect la executarea
programului.
*/
echo "hello world!";
?>
2.4 Rezumat
În acest capitol am creat primul script PHP. Am învățat cum să folosim un editor de text ca să
scriem, să încărcăm și să rulăm un document PHP. Am examinat câteva moduri de a începe și
sfârși blocuri de cod PHP. Am învățat cum să folosim funcția echo pentru a afișa date în
browser, și cum să scriem cod HTML și PHP în același script. La final am învățat cum să
adăugăm comentarii în codul PHP.
Capitolul 3:Sintaxa de bază. Tipuri de date PHP
În acest capitol vom aborda următoarele subiecte:
Variabile PHP
Definirea și accesarea variabilelor
Tipuri de date în PHP
Operatori și expresii în PHP. Precedența și asociativitatea
Definirea și utilizarea constantelor
3.1Variabile PHP
În general, o variabilă reprezintă un container special identificat printr-un nume și care
înmagazinează o valoare.
Din punct de vedere sintactic numele este un identificator, adică o succesiune de litere, cifre
sau liniuța de subliniere (underscore), dar întotdeauna primul caracter este litera sau liniuța de
subliniere. În plus, în PHP identificatorul unei variabile este precedat întotdeauna de semnul
dolar (“$”).
Din punct de vedere semantic în spatele numelui unei variabile se află adresa de memorie la
care aceasta este depozitată.
Observația 3.1: Numele unei variabile în PHP este case-sensitive, adică se face deosebirea între
literele mari și cele mici. Spre exemplu $var și $Var reprezintă două variabile distincte .
Exemplul 3.1: Nume de variabile
$a;
$var;
$numeTitularCont;
$123; //nume invalid, incepe cu o cifra;
$_alpha1; //nume valid;
Pentru a folosi o variabilă trebuie în prealabil să o definim. În general, definirea cuprinde
două etape, uneori suprapuse, și anume declararea variabilei și inițializarea acesteia. La
declarare asociem variabilei un tip, iar la inițializare o valoare.
Spre deosebire de alte limbaje de programare în PHP nu există o secțiune de definire a
variabilelor. Declararea și inițializarea se pot face oriunde în program, și pot fi considerate ca
două procese distincte.
Pentru că în PHP nu există cuvinte rezervate pentru tipuri, variabilei i se asociază un tip în
momentul inițializării după tipul valorii cu care a fost inițializată.
Pe lângă tip și valoare, o altă caracteristică importantă a unei variabile este domeniul de
vizibilitate care, în mod predefinit, este contextul în care a fost definită. Prin context
înțelegem fișierul curent sau blocul de definire al unei funcții. Putem modifica domeniul de
vizibilitate utilizând, spre exemplu, cuvântul rezervat global. Exemple și alte posibilități de
modificare a domeniului de vizibilitate vor fi date în capitolele următoare.
Variabilele în PHP sunt în mod predefinit alocate prin valoare, adică fiecărui nume de
variabilă îi corespunde o zonă distinctă (independentă) de memorie. Ilustrăm ultima afirmație
prin Exemplul 3.2:
Exemplul 3.2: Atribuirea de valori variabilelor
$var1 = 'mere'; //variabila $var1 conține textul 'mere'
$var2 = $var1; //variabila $var2 conține de asemenea textul 'mere'
$var2 = 'pere'; //variabila $var2 conține textul 'pere'
//continutul variabilei $var1 ramane tot 'mere'
Pe lângă acest mod de alocare, începând cu PHP4, avem și alocarea variabilelor prin referință.
Aceasta înseamnă că noua variabilă referă (indică) aceeași adresă ca și variabila originală.
Altfel spus este un sinomin al aceleiași adrese. Modificările făcute noii variabile vor afecta și
conținutul variabilei originale și invers. Pentru o astfel de atribuire se folosește operatorul de
adresare “&” atașat numelui variabilei din membrul drept. Exemplul 3.3 și Exemplul 3.4 susțin
cele mai sus menționate.
Exemplul 3.3: Atribuire de valori variabilelor prin referință
$a='rosu'; //variabila $a contine textul 'roșu'
$b=&$a; //variabila $b refera variabila $a
//va contine tot textul 'rosu'
$b='verde';//variabila $b va contine textul 'verde'
//variabila $a de asemenea
Exemplul 3.4: Atribuire prin referință incorectă
$y=&(25+18); //atribuire incorecta, variabila nu are nume valid
3.1.1Variabile cu nume dinamic
În PHP chiar numele unei variabile poate fi stocat într-o variabilă, iar procesul este iterativ.
Exemplul 3.5: Variabile cu nume dinamic
$hello = "world"; //variabila cu numele hello contine textul ‘world’
//Putem scrie echivalent:
$a = "hello"; //numele variabilei hello il atribuim variabilei a
$$a = "world"; //continutul variabilei hello va fi textul ‘world’
Observația 3.2: Se poate folosi un șir constant pentru a defini o variabilă cu nume dinamic în
loc de a folosi o variabilă. Pentru aceasta, avem următoarea sintaxa:
${"hello"} = "world";
3.2Tipuri de date
PHP folosește, în mod curent, următoarele categorii de tipuri de date. Tipurile din categorii nu
reprezintă cuvinte cheie PHP:
Tipuri scalare reprezentate de:
boolean
integer
float
string
Tipuri compuse
array
object
Tip generic
NULL.
5Tipul boolean
O variabilă de tip boolean poate avea doar două valori, reprezentate de cuvinte rezervate PHP:
TRUE respectiv FALSE. În plus, ca și în limbajul C, orice valoare 0, șir vid sau NULL înseamnă
FALSE, iar orice altă valoare înseamnă TRUE.
Exemplul 3.6: Variabile de tip boolean
ce au valoare TRUE explicit sau prin conversie implicită
$var = TRUE;
$var = 1;
$var = -1;
ce au valoarea FALSE
$var = FALSE;
$var = 0;
$var = ""; //sirul vid
6Tipul integer
Variabilele de tip integer sunt numere întregi reprezentate, în general, pe patru octeți.
Lungimea reprezentării, și de aici și domeniul de valori, este dependentă însă de platformă. Ea
poate fi aflată prin valoarea variabilei predefinite PHP_INT_SIZE. Valorile asociate tipului
integer pot fi zecimale(succesiune de cifre de la 0 la 9, eventual semn), hexazecimale
(precedate de 0x și succesiune de cifre de la 0 la 9 și literele a, A, b, B, c, C, d, D, e, E, f, F,
eventual semn) sau octale(precedate de 0 și succesiune de cifre de la 0 la 7, eventual semn).
Exemplul 3.7: Variabile de tip integer
$var = 1234; //numar intreg zecimal
$var = -123; //numar intreg negativ
$var = 0123; //numar intreg in format octal
$var = 0x1AB; //numar intreg in format hexazecimal
7Tipul float
Desemnează numerele reale reprezentate în virgulă mobilă, care pot fi specificate folosind
oricare dintre sintaxele următoare:
Exemplul 3.8: Variabile de tip float
$var = 1.23;
$var = 1.2e3; //formatul stiintific
$var = -7E-10;
Dimensiunea reprezentării în memorie este în mod obișnuit de 64 de biți, iar precizia
reprezentării este de maxim 14 cifre.
8Tipul string
Tipul string reprezintă șiruri de caractere ASCII. Aceasta înseamnă doar 256 de caractere
posibil a fi reprezentate. Până în prezent, în variantele stabile, PHP nu are suport pentru
caractere Unicode.
Există mai multe moduri de reprezentare externă a valorii variabilelor de tip string, dar numai
2 sunt folosite în mod uzual:
reprezentarea cu ghilimele simple: $var = 'Acesta este un string' ;
reprezentarea cu ghilimele duble: $var = "Acesta este un string" ;
Observația 3.3: În cazul primei modalități de reprezentare pentru afișarea caracterului apostrof,
în cadrul textului, acesta trebuie precedat de caracterul backslash (\'). La fel se procedează
pentru afișarea caracterului backslash (\\). Folosirea oricăror alte secvențe escape determină
și afișarea caracterului backslash.
Exemplu 3.9: Variabile de tip string reprezentate între apostrofuri
$var = 'Andrei a raspuns: "Acu\'!" ';
//Va afisa: Andrei a raspuns: "Acu'!"
Observația 3.4: Cea de-a doua modalitate permite interpretarea tuturor secvențelor escape
(Tabelul 3.1). Mai mult, dacă în cadrul textului apare o variabilă, aceasta va fi înlocuită cu
valoarea sa (Exemplul 3.10).
Secvenț ă
escapeInterpretare
\n linie nouă (line feed)
\rîntoarcere la începutul liniei (carriage
return)
\t Tab
\\ Backslash
\$ semnul dolar
\"Ghilimele
Tabelul 3.1: Secvențe escape acceptate în interiorul string-urilor
Exemplul 3.10 : Variabile de tip string reprezentate între ghilimele
$a = 40;
$b = "Sunt $a participanti prezenti in clasa.";
//Va afisa: Sunt 40 participanti prezenti în clasa.
Una dintre opera țiile frecvent utilizate cu string-uri este concatenarea. Aceasta se realizează
prin intermediul operatorului punct ( Exemplul 3.11 ). Despre alte opera ții pe string-uri vom
discuta în capitolele urm ătoare.
Exemplul 3.11: Concatenarea a două string-uri
/* Atribuirea unei valori de tip string. */
$str = "Acesta este un string";
/* concatenarea a doua string-uri. */
$str = $str . " cu ceva mai mult text";
9 Tipul array
În general, acest tip de date este cunoscut sub numele de tip tablou sau șir și reprezintă o
structură ordonată cu una sau mai multe dimensiuni.
În PHP datele conținute într-un array pot fi de tipuri diferite. Logica unei astfel de structuri în
PHP este că fiecărui element i se asociază o cheie și o valoare. Astfel, această structură aduce
o anumită generalitate față de un tablou clasic și metode de acces diferit la date. Prin acest tip
putem defini stive, cozi, liste, colecții, hash-uri, matrici sau vectori.
PHP oferă mai multe posibilități de a construi o variabilă de tip array:
Sintaxa cu paranteze drepte:
$nume_array[cheie] = valoare;
unde: cheie – poate fi de tip string, integer nenegativ sau poate lipsi;
valoare – o valoare de orice tip de dată.
Exemplul 3.12 : Atribuirea de valori unui array
$a[0] = "abc"; //elementul de indice 0 din a primeste valoarea abc
$a[1] = "def"; //elementul de indice 1 din a primeste valoarea def
$b["sir"] = 13;//elementul de cheie șir din b primeste valoarea 13
$a[] = "hello";//elementul de indice 2 din a primeste valoarea hello
$b[] = "world";//elementul de indice 0 din b primeste valoarea world
Așa cum reiese din Exemplul 3.12 lipsa explicită a cheii determină crearea unui nou
element, în șir, de indice egal cu ultimul indice + 1 sau de indice 0 dacă nu a existat
vreunul creat deja . Astfel, în cazul lui b nu există un indice explicit așa că a fost creat
primul, de valoare 0.
Sintaxa folosind funcția predefinită array():
$nume_array = array (cheie => valoare, …);
cu semnificațiile date anterior.
Exemplul 3.13: Definirea unui array folosind funcția array()
$a = array('culoare' => 'rosu', 'gust' => 'dulce', 'forma' =>
'rotund', 'nume' => 'mar', 4);
// echivalent cu
$a['culoare'] = 'rosu';
$a['gust'] = 'dulce';
$a['formă'] = 'rotund';
$a['nume'] = 'mar';
$a[] = 4; // cheia este 0
//sau
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// echivalent cu
$b = array( 0 => 'a' , 1 => 'b' , 2 => 'c');
// sau mai simplu
$b = array('a', 'b', 'c');
Referirea la o variabilă de tip tablou se face prin numele tabloului, iar la un element din tablou
prin nume și cheia sau indicele cuprinse de paranteze drepte.
Referitor la tablouri există multe funcții și operatori care să le modifice și controleze starea
(vezi paragraful dedicat operatorilor sau capitolele următoare).
10Tipul object
O variabilă de tip object se obține prin crearea unei instanțe a unei clase (vezi capitolul
dedicat claselor și obiectelor).
11Tipul NULL
Are o singură valoare și anume NULL. O variabilă de tip NULL reprezintă o variabilă fără nici
o valoare.
Sintaxa de atribuire a acestei valori unei variabile este următoarea:
$a = NULL;
3.3Operatori și expresii
Operatorii sunt simboluri care fac posibilă folosirea uneia sau a mai multor valori pentru a
crea o nouă valoare. O valoare care este operată de către un operator se numește operand.
O expresie este orice combinație validă de funcții, valori și operatori cu scopul de a obține o
nouă valoare.
Principalii operatori ai limbajului PHP vor fi analizați în continuare.
12Operatori de atribuire
Până acum am folosit operatorul de atribuire pentru inițializarea variabilelor. Sintaxa de bază
pentru atribuire este:
$variab = expresie;
Modul de execuție este următorul: se evaluează expresia iar valoarea este atribuită variabilei
din membrul stâng.
Pe lânga acesta există și operatorii de atribuire compuși, pentru aproape toate operațiile
(Exemplul 3.14).
Exemplul 3.14: Utilizarea operatorilor de atribuire compuși
$a = 3;
$a += 5; // seteaza $a cu valoarea 8, ca si cum am fi scris :
// $a = $a + 5;
$b = "Hello ";
$b .= "world!"; // seteaza $b cu valoarea "Hello world!"
// echivalent cu $b = $b . "world!";
13Operatori aritmetici
Operatorii aritmetici sunt folosiți în expresii aritmetice. În Tabelul 3.2 este prezentată lista
acestor operatori.
OperatorNume
operatorObserva ții
+ adunare
-scădere
semn Operator binar
Operator unar
* înmultire
/ împartireRezultatul este întreg doar dacă ambii operanzi sunt întregi
sau convertibili la întregi, iar rezultatul este fără rest
% moduloRestul este returnat indiferent dacă operanzii sunt float (se
face conversia la integer). Restul este negativ doar dacă
operandul stâng este negativ iar cel drept pozitiv.
Tabelul 3.2: Operatori aritmetici
14 Operatori pe biți
Operanzii sunt, în general, numere întregi, iar utilizarea lor este pentru cre șterea vitezei de
execu ție a evalu ării.
Operator Exemplu Nume operator
& $a & $b și, pe biți
| $a | $b sau, pe biți
^ $a ^ $b sau exclusiv, pe biți
~ ~ $a negare
<< $a << $b shiftare stânga
>> $a >> $b shiftare dreapta
Tabelul 3.3: Operatori pe biți
15 Operatori de comparare
OperatorNume
operatorObservații
== egalReturnează 1(echivalentul lui TRUE) dacă valoarea
operandului stâng este egală cu cea a operandului drept și
NULL (echivalentul lui FALSE) altfel.
=== identicReturnează 1 dacă valoarea operandului stâng este egală
cu cea a operandului drept și sunt de acelasi tip, NULL
altfel.
!=
<>diferitReturnează 1 dacă valoarea operandului stâng nu este
egală cu cea a operandului drept și NULL altfel. Diferența
între cei doi operatori constă în prioritate.
!== neidenticReturnează 1 dacă valoarea operandului stâng nu este
egală cu cea a operandului drept sau nu sunt de același
tip, NULL altfel .
< mai micReturnează 1 dacă valoarea operandului stâng este strict
mai mică decât cea a operandului drept și NULL altfel.
> mai mareReturnează 1 dacă valoarea operandului stâng este strict
mai mare decât cea a operandului drept și NULL altfel.
<=mai mic sau
egal Returnează 1 dacă valoarea operandului stâng este mai
mică sau egală cu cea a operandului drept și NULL altfel.
>=mai mare sau
egal Returnează 1 dacă valoarea operandului stâng este mai
mare sau egală cu cea a operandului drept și NULL altfel.
Tabelul 3.4: Operatori de comparare
16 Operatori de incrementare/decrementare
Operator Nume operator Observații
++ incrementareÎn funcție de momentul în care se face incrementarea avem
pre-incrementare ( ++$a) și post-incrementare ( $a++)
– decrementareÎn funcție de momentul în care se face decrementarea avem
pre-decrementare ( –$a) și post-decrementare ( $a–)
Tabelul 3.5: Operatori de incrementare/decrementare
Pentru a înțelege diferen țele care exist ă între pre și post vom da urm ătorul exemplu.
Exemplul 3.15: Utilizarea operatorilor de atribuire compuși
$a=1;
$b=2;
$c=$a++ + ++$b;
În Exemplul 3.15 după executarea ultimei instrucțiuni, $a va avea valoarea 2, $b va avea
valoarea 3 iar $c valoarea 4 (ca suma dintre 1 și 3, $a a fost mai întâi evaluat și apoi
incrementat).
17 Operatori logici
OperatorNume
operatorObservații
and
&&șiDiferența între cei doi operatori constă în prioritate (vezi
Tabelul 3.8 )
or
||sauDiferența intre cei doi operatori constă în prioritate (vezi
Tabelul 3.8 )
xor sau exclusiv
! negație
Tabelul 3.6: Operatori logici
18 Operator pentru controlul erorilor
Operatorul “ @” are rolul de a suprima afișarea unor erori în timpul evaluării unei expresii.
Exemplul 3.16: Utilizarea operatorului pentru controlul erorilor
@$a=3/0;
Dacă în Exemplul 3.16 operatorul „@” nu ar apărea în fața atribuirii am avea afișat un mesaj de
eroare: division by zero .
19Operator pe string-uri
Operatorul punct (.) este operatorul de concatenare a două string-uri.
20Operatori pe array-uri
OperatorNume
operatorObservații
== egalReturnează 1(echivalentul lui TRUE) dacă valoarea operandului
stâng este egală cu cea a operandului drept, însemnând egalități pe
perechi cheie/valoare indiferent de ordine, și NULL (echivalentul lui
FALSE) altfel.
=== identicReturnează 1 dacă valoarea operandului stâng este egală cu cea a
operandului drept, elementele apar respectiv pe aceeași poziție și au
același tip, NULL altfel.
!=
<>diferitReturnează 1 dacă valoarea operandului stâng nu este egală cu cea a
operandului drept și NULL altfel. Diferența dintre cei doi operatori
este data de prioritate.
!==neidenticReturnează 1 dacă valoarea operandului stâng nu este egală cu cea a
operandului drept, sau nu sunt de același tip, sau nu apar pe aceeași
poziție, NULL altfel.
+reuniuneAdaugă elemente operandului stâng dintre cheile inexistente, aflate
în operandul drept, cu valorile corespunzătoare. Cheile duplicat nu
vor fi suprascrise.
Tabelul 3.7: Operatori pe array-uri
Exemplul 3.17: Utilizarea operatorului de reuniune pentru array-uri
$a=array( 1=>"unu", 2=>"doi","index"=>"trei");
$b=array( 2=>"sase","index"=> 9,8);
$a+=$b;
În Exemplul 3.17 $a va conține 4 elemente, cele de cheie 1, 2 și index rămîn neschimbate, dar
se adaugă un element de cheie 3 și valoare 8.
21 Operatori de cast
Se folosesc pentru conversii explicite. Sintaxa generală este:
(tip)
ceea ce determină conversia către tipul indicat între paranteze. PHP permite următoarele
conversii explicite:
(int) sau (integer) către integer
(bool) sau (boolean) către boolean
(float), (double) sau (real) către float
(string) către string
(array) către array
(object) către object
(unset) către NULL
3.4Precedența și asociativitatea operatorilor
Prin precedență înțelegem ordinea de evaluare a operațiilor în cadrul unei expresii, expresie ce
nu conține paranteze, dar are operatori de diferite tipuri.
Prin asociativitate înțelegem ordinea de evaluare a operațiilor într-o expresie ce nu conține
paranteze, dar are operatori de același tip.
Operator Asociativitate
clone new non-asociativ
[] stânga-dreapta
++ – non-asociativ
~ – (tip) @ non-asociativ
instanceof non-asociativ
! dreapta-stănga
* / % stânga-dreapta
+ – . stânga-dreapta
<< >> stânga-dreapta
< <= > >= <> non-asociativ
== != === !== non-asociativ
& stânga-dreapta
^ stânga-dreapta
| stânga-dreapta
&& stânga-dreapta
|| stânga-dreapta
?: stânga-dreapta
= += -= *= /= .= %= &= |= ^= <<= >>= dreapta-stânga
and stânga-dreapta
xor stânga-dreapta
or stânga-dreapta
Tabelul 3.8: Ordinea descrescatoare a priorității și asociativitatea operatorilor
3.5 Constante
Constantele sunt identificate printr-un nume și au o singură valoare. Numele este un
identificator (care nu va fi precedat de semnul $), dar exprimă adresa unei zone de memorie
nemodificabilă. Odată valoarea constantei stabilită, aceasta nu mai poate fi modificată. Prin
convenție, numele constantelor se scriu cu majuscule.
Definirea unei constante se poate face utilizând funcția define() (Exemplul 3.18 ).
Exemplul 3.18 : Definirea unei constante cu define(nume, valoare)
define("CONSTANTA", "o constanta");
echo CONSTANTA; // Afiseaza: "o constanta"
Constantele pot avea valori doar de tipul: boolean, integer, float sau string.
Domeniul de vizibilitate al unei constante este întregul fișier în care a fost definită.
3.6Rezumat
În acest capitol am evidențiat câteva din caracteristicile limbajului PHP. Am discutat despre
variabile, declararea și inițializarea lor, despre variabile dinamice, precum și despre variabile
referință și valoare. Am discutat apoi despre tipuri de date în PHP, despre câțiva din cei mai
importanți operatori și posibilitatea de a îi combina pentru a obține expresii. Discuția despre
operatori s-a incheiat cu evidențierea priorității și asociativității acestora. În final, am supus
atenției modul în care să definim și să accesăm constantele.
Capitolul 4:Structuri de control
În acest capitol vom aborda următoarele subiecte:
Instrucțiunea de decizie: if
Instrucțiunea de decizie multiplă: switch
Instrucțiuni de salt: break și continue
Instrucțiuni repetitive: cu test inițial while, cu test final do-while
Instrucțiunea repetitivă complexă: for
Instrucțiunea repetitivă pentru array-uri: foreach
Toate scripturile prezentate în exemplele de până acum executau instrucțiunile în mod
secvențial începând cu prima și terminând cu ultima, în cazul în care datele erau corecte.
Aceasta formează structura secvențială. Există, însă, multe alte situații în care anumite
secvențe de instrucțiuni nu se execută sau se execută repetat de un număr oarecare de ori. Mai
avem și cazuri în care anumite secvențe de instrucțiuni se execută incomplet. Asupra tuturor
acestora ne vom opri în acest capitol.
Observația 4.1: Vom defini un bloc ca fiind o secvență de instrucțiuni scrise între acolade.
Majoritatea exemplelor din acest manual vor ține cont de această observație. În PHP blocurile
pot fi delimitate și cu ajutorul marcajului „:” (două puncte), dar acest caz va fi tratat explicit
ori de câte ori va fi întâlnit.
4.1Instrucțiuni de decizie
Instrucțiunile de decizie fac ca pe baza unor condiții, exprimate prin expresii logice, anumite
secvențe de cod să fie executate iar altele nu.
22Instrucțiunea if
Sintaxa generală a instrucțiunii este:
if(expresie){
//cod care se execută dacă expresie este adevarată
}
else{
//cod care se execută altfel
}
Modul de execuție este următorul: mai întîi, instrucțiunea if evaluează expresie, ce este
scrisă între paranteze. Dacă aceasta are valoarea TRUE, se execută blocul de cod imediat
următor. Altfel, se va executa blocul de cod următor lui else. Este posibil ca else să nu existe
și atunci, în cazul în care valoarea expresie este FALSE, se va trece la următoarea instrucțiune
din secvența curentă de program, fără a se mai executa ceva din if.
Exemplul 4.1: Instructiunea if – else
<html>
<head>
<title>
Exemplul 4.1
</title>
</head>
<body>
<?php
$stare= "trist";
if ( $stare == "vesel" ){
echo "Uraaa, sunt vesel!";
}
else{
echo "Nu sunt vesel, ci $stare";
}
?>
</body>
</html>
Folosim operatorul de comparatie „ ==” (dublu egal) pentru a compara conținutul variabilei
$stare cu textul vesel. Dacă se potrivesc, atunci textul: ” Uraaa, sunt vesel! ” va fi afișat
în browser. Dacă schimbăm valoarea variabilei $stare="trist" și rulăm scriptul, atunci
primul bloc de cod va fi sărit și se va executa cel de-al doilea, cel din clauza else, iar textul
„Nu sunt vesel, ci trist ” va apărea scris în browser.
Observația 4.2: În cazul în care pe ramura else a unui if este imediat un nou if, iar marcajul
de bloc este format din perechi de două puncte, atunci trebuie ținut cont de regula potrivit
căreia elseif trebuie să fie un singur cuvânt ( token). Dacă marcajul de bloc este dat de o
pereche de acolade, atunci această regulă este opțională.
23Instrucțiunea switch
Este cunoscută și sub numele de instrucțiunea de selecție multiplă. Este posibil ca dintr-o
succesiune de secvențe de cod doar o parte dintre ele să se execute pentru anumite date de
intrare. Orice instrucțiune switch poate fi scrisă echivalent prin mai multe instrucțiuni if, dar
switch oferă o sintaxă mai compactă, mai clară și mai flexibilă.
Sintaxa generală este:
switch(expresie){
case rezultat1:
// cod care se execută dacă expresie are valoarea
// rezultat1
break;
case rezultat2:
// cod care se execută dacă expresia are valoarea
// rezultat2
break;
.
.
.
default:
// cod care se execută dacă expresia nu a avut nici una
// dintre valorile enumerate mai sus
}
unde:
expresie poate fi orice expresie ce returnează o valoare integer, float, boolean sau
string;
rezultat1, rezultat2… reprezintă expresii de oricare dintre tipurile anunțate
anterior, dar compatibile cu expresie, și nu neapărat de valori distincte;
case este cuvânt rezervat PHP, ce precede fiecare dintre selecțiile instrucțiunii. Mai
multe case-uri pot fi urmate de o singură secvență de cod, dar trebuie despărțite de
caracterul “:” (două puncte);
default este cuvânt rezervat PHP, ce indică o secvență ce urmează a fi executată
atunci când niciunul dintre case-urile anterioare nu a fost selectat. default este
opțional;
break este cuvânt rezervat PHP și reprezintă instrucțiunea de întrerupere (vezi
secțiunea dedicată acestei instrucțiuni).
Modul de execuție al instrucțiunii este următorul: se evaluează expresie, și se execută
secvența de cod corespunzătoare primului case care are valoarea egală, dar și secvențele
următoare, corespunzătoare celorlalte case-uri, până la primul break întâlnit sau până la
sfârșitul instrucțiunii. Dacă nici o valoare corespunzătoare vreunui case nu este egală cu
valoarea expresie și default există, atunci se execută secvența de cod corespunzătoare lui
default.
Exemplul 4.2: Instrucțiunea switch
Să presupunem că avem o valoare reprezentând o categorie de dimensiune. Dacă aceasta este
l, atunci dorim să afișăm mesajul mic, pentru 2 dorim să afișăm mediu iar pentru 3 dorim să
afișăm mare. Orice altă valoare vrem să producă mesajul nepotrivit.
$numar=2;
switch($numar){
case(1):
echo "mic ";
break;
case(2):
echo "mediu ";
break;
case(3):
echo "mare ";
break;
default:
echo "nepotrivit";
}
În contextul dat mai sus în browser se va afișa mediu. Dacă în Exemplul 4.2 instrucțiunea
break ar lipsi și am păstra valorea variabilei $numar, atunci în browser s-ar afișa „ mediu
mare nepotrivit”.
Încheiem acest paragraf cu două instrucțiuni frecvent utilizate în secvențele neliniare, numite
și instrucțiuni de salt.
24Instrucțiunea break
Este folosită pentru întreruperea execuției instrucțiunilor for, foreach, while, do-while sau
switch.
Sintaxa generală este:
break numar;
unde, numar este opțional, dar în cazul în care este prezent va indica numărul de instrucțiuni
încuibate, dintre cele amintite, care vor fi întrerupte de break.
25Instrucțiunea continue
Este folosită pentru salt la următoarea repetiție, dacă aceasta mai există, într-o instrucțiune
repetitivă.
4.2Instrucțiuni repetitive
Instrucțiunile repetitive fac ca pe baza unor condiții, exprimate prin expresii logice, anumite
secvențe de cod să fie executate de mai multe ori.
26Instrucțiunea while
Este cunoscută ca instrucțiunea repetitivă cu test inițial și are următoarea sintaxă generală:
while(expresie){
// cod care se execută cât timp expresie este adevărată
}
Modul de execuție este următorul: se evaluează expresie. Atât timp cât aceasta are valoarea
TRUE se execută blocul de cod. În interiorul acestui bloc se efectueză, de obicei, schimbări
care influențează evaluarea expresiei; altfel, ciclul poate continua la infinit.
Exemplul 4.3: Instructiunea while
<html>
<head>
<title>
Exemplul 4.3
</title>
</head>
<body>
<?php
$indicator = 1;
while ( $indicator <= 12 ){
echo "$indicator * 2 = ".($indicator* 2)."<br>";
$indicator++;
}
?>
</body>
</html>
În Exemplul 4.3 inițializăm cu valoarea 1 variabila $indicator. Instrucțiunea while testează,
mai întâi, dacă valoarea variabilei este mai mică sau egală cu 12. Dacă este adevărat, atunci se
execută blocul de cod prin care se afișează un mesaj și se incrementează valoarea variabilei
$indicator. Incrementarea valorii variabilei $indicator este foarte importantă pentru că ea
este implicată în condiția ce testează abandonarea ciclului. Blocul de cod se va executa atât
timp cât condiția este îndeplinită, adică valoarea variabilei $indicator este mai mică sau
egală cu 12.
27Instrucțiunea do-while
Este cunoscută sub numele de instrucțiune repetitivă cu test final . Principala deosebire față de
instrucțiunea repetitivă cu test inițial este că blocul de cod din corpul instrucțiunii se execută
măcar o dată. Sintaxa generală este:
do{
// cod care se execută cât timp expresie este TRUE
}
while(expresie);
Modul de execuție este următorul: se execută blocul de cod, se evaluează expresie și cât
timp valoarea este TRUE se execută blocul de cod.
Exemplul 4.4: Instrucțiunea do-while
<html>
<head>
<title>
Exemplul 4.4
</title>
</head>
<body>
<?php
$numar = 1;
do{
echo "Executia nr.: $numar<br>\n";
$numar++;
}
while ( $numar > 1 && $numar < 10 );
?>
</body>
</html>
În Exemplul 4.4 variabila $numar se inițializează cu 1. Scriptul apoi va afișa: ” Executia nr.:
1”, după care valoarea variabilei $numar va fi incrementată. Instrucțiunea do-while va evalua
condiția, adică dacă valoarea variabilei $numar este mai mare ca 1 și mai mică ca 10. Cum
condiția este îndeplinită, se va reveni la execuția blocului de cod. Procesul se continuă până
când valoarea variabilei $numar va fi 10. În acest moment expresia logică va avea valoarea
FALSE și execuția ciclului va fi întreruptă.
28Instrucțiunea for
Poate fi asemănată cu o instrucțiune repetitivă cu test inițial. Totuși, instrucțiunea for este o
reuniune de mai multe instrucțiuni. Sintaxa generală este:
for(expr1; expr2; expr3){
// cod care se execută cât timp valoarea expr2 e TRUE
}
unde:
expr1 reprezintă o succesiune de instrucțiuni, separate prin virgulă, care se execută o
singură dată și unde, de regulă, se fac inițializări;
expr2 este o expresie logică care determină continuarea ciclului;
expr3 este o succesiune de instrucțiuni, separate prin virgulă, în care, de regulă, se
execută operații la sfârșitul fiecărei iterații, după terminarea blocului de cod din
interiorul instrucțiunii și înaintea evaluării expr2.
Toate cele 3 expresii pot să lipsească. Obligatorii sunt doar cele două “ ;” (punct și virgulă). În
cazul în care expr2 lipsește, valoarea sa este considerată tot timpul TRUE. În acest caz, ieșirea
din ciclu trebuie făcută altfel, spre exemplu prin instrucțiunea break. Și blocul de cod poate
lipsi. În acest caz instrucțiunea for trebuie urmată de “;”.
Exemplul 4.5: Instrucțiunea for
<html>
<head>
<title>
Exemplul 4.5
</title>
</head>
<body>
<?php
for ( $i=1; $i<=12; $i++ ){
echo "$i * 2 = ".($i* 2)."<br>";
}
?>
</body>
</html>
Rezultatele Exemplelor 4.3 și 4.5 sunt la fel. Se observă însă că instrucțiunea for are un cod mai
compact.
Când compilatorul ajunge la instrucțiunea for, variabila $i este inițializată, iar apoi expresia
logică este evaluată. Dacă valoarea ei este TRUE, atunci blocul de cod este executat. Apoi
valoarea variabilei $i este incrementată și expresia logică este evaluată din nou. Acest proces
continuă până când rezultatul expresiei logice este FALSE.
Exemplul 4.6: Folosirea instrucțiunii break într-o instrucțiune for
<html>
<head>
<title>Exemplul 4.6</title>
</head>
<body>
<?php
for ($i =10 ; $i >= 0; $i– ){
if ( $i <= 0 )
break;
$rezultat = 4000/$i;
echo "4000 impartit la $i este… $rezultat<br>";
}
?>
</body>
</html>
Exemplul 4.6 inițializează variabila $i cu 10. Expresia logică verifică dacă valoarea variabilei
$i este mai mică sau egală cu 0. În cadrul blocului de cod numărul 4000 este împărțit la $i și
se afișează rezultatul în browser. Variabila $i este apoi decrementată și se refac verificările.
La ultimul pas, atunci când $i este 0, avem împărtire la zero. Prin adăugarea instrucțiunii
break forțăm ieșirea din ciclu și evităm afișarea unor erori.
Observația 4.1: Împărțirea la zero în PHP nu va cauza o eroare fatală. Totuși, va fi generat un
mesaj de avertizare, iar execuția va continua.
29Instrucțiunea foreach
Datorită modului special în care sunt tratate array-urile în PHP, spre exemplu au domenii de
indici discontinue, s-a introdus o instrucțiune repetitivă pentru parcurgerea acestora. Sintaxa
generală este:
foreach($variab_array as $cheie => $valoare){
//cod ce se execută de atâtea ori căte elemente sunt în variab_array
}
unde:
$variab_array numele unei variabile ce conține un array;
as cuvânt rezervat PHP;
$cheie numele unei variabile în care se va depune valoarea cheii elementului curent,
variabilă ce are domeniul de vizibilitate în interiorul instrucțiunii foreach;
$valoare numele unei variabile în care se va depune valoarea elementului curent,
variabilă ce are domeniul de vizibilitate în interiorul instrucțiunii foreach.
Modul de lucru este următorul: se crează o copie a șirului de parcurs, pe această copie se
poziționează indicatorul care parcurge șirul de pe prima poziție, se trece valoarea cheii în
variabila $cheie și a elementului curent în variabila $valoare, se execută blocul de cod. Se
procedează asemănător, prin parcurgere consecutivă, a fiecărui element din șir până la ultima
poziție.
Exemplul 4.7: Folosirea instrucțiunii foreach
<html>
<head>
<title>Exemplul 4.7</title>
</head>
<body>
<?php
$a=array(2,"unu"=>6,7,"indice"=>10);
foreach($a as $b => $c){
echo "elementul cu cheia: $b are valoarea $c<br>";
}
?>
</body>
</html>
Observația 4.2: Deoarece se lucrează cu o copie, în cazul în care se fac modificări ale valorilor
șirului, acestea nu vor fi recunoscute decât în interiorul instrucțiunii foreach. În afara
acesteia valorile elementelor șirului vor fi cele de dinaintea parcurgerii. Pentru ca eventualele
modificări să fie recunoscute și în exteriorul instrucțiunii se va folosi variabila referință,
&$valoare.
Observația 4.3: Instrucțiunea foreach poate fi folosită și la parcurgerea atributelor unui obiect
(vezi capitolul dedicat obiectelor PHP).
4.3Rezumat
În acest capitol am studiat structurile de control și modul în care ele sunt folosite în scripturile
PHP pentru crearea paginilor flexibile și dinamice. Astfel, am discutat despre cum să folosim
instrucțiunea if și cum putem crea alternative ale acesteia cu ajutorul clauzelor elseif și
else. Am discutat despre cum să folosim instrucțiunea de selecție multiplă switch în cazul
unor situații cu teste multiple. Am discutat despre cicluri, în particular despre ciclul while,
do-while și for și cum să folosim instruțiunea break pentru a întrerupe execuția ciclului. În
final am discutat despre cum să folosim instrucțiunea foreach pentru parcurgerea variabilelor
de tip array.
Capitolul 5:Funcții PHP
În acest capitol vom aborda următoarele subiecte:
Definiția funcțiilor și necesitatea folosirii acestora
Apelul funcțiilor
Definirea funcțiilor, argumentele unei funcții, rezultatul unei funcții
Variabile globale
Funcții cu nume dinamic
5.1Ce este o funcție?
Funcțiile reprezintă modalitatea de bază de implementare a conceptului de modularizare a
programelor, în PHP. Prin modularizare programele devin mai flexibile, mai lizibile de către
programator și mai ușor de depanat. Modularizarea stă la baza conceptului de programare
orientată de obiecte despre care vom discuta în capitolele următoare.
Iată un prim exemplu de utilizare a unei funcții: presupunem că, în cadrul unui script, dorim
să executăm o anumită acțiune de mai multe ori, dar nu intr-un ciclu. Soluția eficientă este ca
acea acțiune să fie definită într-o funcție și apelată ori de câte ori avem nevoie.
O funcție este, așadar, un bloc de cod care poate fi apelat de către programele apelante.
Funcția poate primi valori din programul apelant, execută blocul de instrucțiuni și apoi,
eventual, returnează rezultatele.
PHP oferă mai multe modalități de lucru cu funcții și anume: funcții definite de către limbaj
(built-in, predefinite ) sau funcții definite de către utilizator ( user-defined).
5.2Apelul unei funcții
Prin apelul unei funcții înțelegem preluarea controlului execuției programului de către blocul
de cod al funcției. Apelul funcției poate determina și inițializarea argumentelor sale,
argumente ce pot avea valori disticte la fiecare apel. Inițializarea se face prin lista parametrilor
actuali ai funcției.
Sintaxa generală de apel a unei funcții este:
nume_functie(lista_parametri_actuali);
unde:
nume_functie reprezintă un identificator, ce trebuie precizat anterior apelului, la
definirea funcției (indiferent că este funcție predefinită sau definită de utilizator) sau
declararea funcției (cazul funcțiilor autoapelate). Conform convenției de nume PHP
identificatorul va fi scris cu litere mici, iar cuvintele vor fi separate cu liniuța de
subliniere (underscore)
lista_parametri_actuali trebuie să coincidă cu număr și poziție cu cei din lista de
parametri formali (cei din declarația funcției). Cum în PHP tipul nu este impus la
declararea funcțiilor, tipurile nepotrivite vor genera erori doar la execuție. Numărul
parametrilor este însă foarte important să fie egal ca număr în lista actuală și în cea
formală. Inegalitatea va duce la eroare încă din faza de precompilare. Lista poate fi
formată din constante, variabile sau apeluri ale altor funcții .
Observația 5.1: lista_parametri_actuali poate fi vidă, dar parantezele rotunde sunt
obligatorii.
Observația 5.2: Dacă funcția returnează un rezultat atunci apelul funcției poate fi operand într-o
expresie compatibilă cu tipul returnat de funcție.
Exemplul 5.1: Apelul funcțiilor
PHP conține o bibliotecă vastă de funcții predefinite. Exemplificăm apelul a două dintre ele,
folosite pentru lucrul cu variabile array: unset()și count().
Funcția predefinită unset() permite eliminarea unor elemente dintr-un array. Argumentul
acestei funcții indică elementul ce urmează a fi eliminat.
Funcția predefinită count() va returna numărul de elemente ale șirului argument.
<html>
<head>
<title>Exemplul 5.1</title>
</head>
<body>
<?php
$a=array(2,3);
unset($a[1]);
echo count($a);
?>
</body>
</html>
În Exemplul 5.1 creăm variabila șirul $a ce are două elemente de valoare 2 respectiv 3. Apelul
funcției unset() determină eliminarea elementului al doilea din șir, de index 1, iar prin apelul
funcției count() funcția echo va afișa numărul de elemente din șir, adică 1.
5.3Definirea unei funcții
În momentul în care definim o funcție îi facem cunoscute numele, lista parametrilor formali și
codul sursă care va prelua controlul execuției programului în momentul apelului. Pentru a
defini o funcție folosim următoarea sintaxă generală:
function nume_functie(lista_parametri_formali){
// codul funcției
}
unde:
function este cuvânt rezervat PHP și precede orice definire sau declarare de funcție;
nume_functie este un identificator, cu următoarele remarci:
oPHP nu permite supraîncărcarea numelui funcțiilor;
oDomeniul de vizibilitate al numelui unei funcții este global;
lista_parametri_formali reprezintă o listă de variabile, separate prin virgulă, ce
vor primi valori în momentul apelului. Lista poate fi vidă, dar parantezele rotunde sunt
obligatorii(Exemplul 5.2). Asupra parametrilor formali, în PHP, putem face următoarele
aprecieri:
oTransmiterea parametrilor unei funcții se face în mod predefinit prin valoare,
adică orice modificare a valorilor parametrilor produsă în interiorul funcției nu
este recunoscută după revenirea la programul apelant. PHP permite pentru
eliminarea acestui neajuns folosirea parametrilor referință, ceea ce înseamnă că
fiecare dintre parametri referință vor fi precedați de operatorul de referențiere,
“&”. Apelul nu face deosebire între parametri referință și parametri valoare
(Exemplul 5.3);
oPHP permite atribuirea predefinită a valorilor parametrilor formali. Astfel,
dacă în momentul apelului omitem atribuirea unei valori pentru un parametru
ce are o valoare predefinită, atunci valoarea acestuia va fi cea din definiția
funcției. Trebuie remarcat că parametrii cu valori predefinite trebuie
pozitionați grupat în lista parametrilor formali, în partea finală a acesteia
(Exemplul 5.4);
codul functiei conține orice secvență validă de instrucțiuni. Printre acestea se poate
afla și instrucțiunea return. Aceasta determină întreruperea executării funcției,
preluarea controlului de către programul apelant și returnearea către acesta a
rezultatului funcției (Exemplul 5.5).
Exemplul 5.2: Definirea și apelul unei funcții fără parametri
<html>
<head>
<title>Exemplul 5.2</title>
</head>
<body>
<?php
function helloWorld(){
echo "HELLO WORLD!";
}
helloWorld();
?>
</body>
</html>
În scriptul din Exemplul 5.2 definim funcția helloWorld() care nu necesită nici un argument,
iar în blocul său de cod afișăm textul „ HELLO WORLD!”. În momentul apelului textul va fi
vizualizat în browser.
Exemplul 5.3: Funcție cu parametri valoare și parametri referință
<html>
<head>
<title>Exemplul 5.3</title>
</head>
<body>
<?php
$a=1;
$b=2;
function interschimb($a, $b) {
$aux=$a;
$a=$b;
$b=$aux;
}
interschimb($a,$b);
echo "a=$a, b=$b";
?>
</body>
</html>
În Exemplul 5.3 am definit funcția cu doi parametri interschimb(), care ar fi trebuit să
interschimbe valorile variabilelor $a și $b. După rularea aplicatiei se constată că valorile
acestora ramân neschimbate. Aceasta deoarece cei doi parametri sunt parametri valoare.
Pentru ca modificările făcute în interiorul funcției să fie vizibile și în exteriorul ei va trebui să
declarăm parametri referință, ca în scriptul următor:
<html>
<head>
<title>Exemplul 5.3</title>
</head>
<body>
<?php
$a=1;
$b=2;
function interschimb(&$a, &$b) {
$aux=$a;
$a=$b;
$b=$aux;
}
interschimb($a,$b);
echo "a=$a, b=$b";
?>
</body>
</html>
Se constată aceeași formă a apelului funcției interschimb().
Exemplul 5.4: Funcție cu argumente cu valori implicite
<html>
<head>
<title>Exemplul 5.4</title>
</head>
<body>
<?php
function afiseaza($mesaj="salut"){
echo $mesaj."<br>";
}
afiseaza(); // va afisa salut
afiseaza("mesaj nou");// va afisa mesaj nou
?>
</body>
</html>
În Exemplul 5.4, la primul apel al funcției afiseaza() va fi considerată valoarea implicită a
parametrului și anume salut. La cel de-al doilea apel, pentru că se specifică o valoare, va fi
luată în considerare aceasta.
Observația 5.3: Dacă dorim ca în cazul unor argumente cu valori predefinite să nu fie luate în
considerare, la execuția funcției, valorile predefinite, atunci vom atribui la apel valoarea NULL
acelor argumente.
Observația 5.4: PHP posedă o bibliotecă de funcții predefinite pentru controlul argumentelor
funcțiilor (spre exemplu funcția func_num_args() ce returnează numărul argumentelor
transmise funcției curente etc).
Exemplul 5.5: Funcție care returnează pătratul valorii argumentului
<html>
<head>
<title>Exemplul 5.5</title>
</head>
<body>
<?php
function laPatrat ($numar){
return $numar * $numar;
}
echo laPatrat (4); // va afisa valoarea 16
?>
</body>
</html>
După cum se observă, în Exemplul 5.3, valoarea returnată de instrucțiunea return este obținută
în urma evaluării unei expresii .
Observația 5.5: PHP permite apelul unei funcții în timpul definirii sale (funcții recursive) sau
definirea unei funcții în interiorul altei funcții ( Exemplul 5.6).
Exemplul 5.6: Funcție definită în interiorul altei funcții
<html>
<head>
<title>Exemplul 5.6</title>
</head>
<body>
<?php
function f1() {
function f2() {
echo "salut";
}
}
f1();//apelul lui f1 trebuie facut pentru a
//avea acces la f2
f2();
?>
</body>
</html>
5.4Variabile globale
Așa după cum am afirmat, în capitolul despre variabile, domeniul implicit de existență
(vizibilitate) al variabilelor este blocul în care au fost definite. Astfel, în cazul unei funcții, o
variabilă definită în programul apelant nu este recunoscută, în mod predefinit, în definiția
funcției. Pentru a modifica domeniul predefinit de vizibilitate al variabilelor se folosește
cuvântul rezervat PHP global (Exemplul 5.7) sau variabila superglobală, de tip array,
predefinită, $GLOBALS (Exemplul 5.8). Această variabilă este indexată după numele variabilelor
globale reținute ca elemente.
Exemplul 5.7: Variabile globale definite prin globals
<html>
<head>
<title>Exemplul 5.7</title>
</head>
<body>
<?php
$a = 1;
$b = 2;
function sum(){
global $a, $b;
$b = $a + $b;
}
sum();
echo $b;
?>
</body>
</html>
Exemplul 5.7 va afișa mesajul 3. Prin declararea global a variabilelor $a și $b în interiorul
funcției, toate referințele către ele vor referi versiunea globală. Dacă nu am fi folosit global,
$a și $b nu ar fi existat (ar fi avut valoarea NULL) în interiorul funcției. Nu există nici o limită
pentru numărul de variabile globale pe care le poate manipula o funcție.
Exemplul 5.8: Variabile globale definite prin $GLOBALS
<html>
<head>
<title>Exemplul 5.8</title>
</head>
<body>
<?php
$a = 1;
$b = 2;
function sum(){
$GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}
sum();
echo $b;
?>
</body>
</html>
Observația 5.6: PHP deține mai multe variabile superglobale. Printre ele: $_SERVER, $_GET,
$_POST, $_REQUEST, $_SESSION, $COOKIE, $_ENV sau $_FILES. Discuții despre acestea vom
avea în capitolele următoare.
5.5Funcții cu nume dinamic
Ca și în cazul variabilelor, avem și pentru funcții conceptul de nume dinamic. Aceasta
înseamnă că dacă numele unei variabile este urmat de o pereche de paranteze rotunde, atunci
PHP va căuta o funcție având numele egal cu valoarea variabilei și o va apela (Exemplul 5.9).
Exemplul 5.9: Funcții cu nume dinamic
<html>
<head>
<title>Exemplul 5.9</title>
</head>
<body>
<?php
function f1(){
echo "apel funcția f1<br>";
}
$func='f1';
$func();
function f2($mesaj){
echo "apel funcția f2 cu $mesaj<br>";
}
$func='f2';
$func("salut");
?>
</body>
</html>
5.6Rezumat
În acest capitol am discutat despre funcții, despre cum să le apelăm, cum să le declarăm și
cum să le definim. Am discutat despre argumentele unei funcții și legat de aceasta despre
parametri formali și parametri actuali. Am făcut distincția între parametri valoare și parametri
referință. Am dat valori implicite argumentelor și am definit funcții în interiorul altor funcții.
Am discutat, de asemenea, despre rezultatul întors de o funcție. În final, am adus câteva
completări capitolului de variabile, întelegând modul în care putem modifica vizibilitatea
acestora și am discutat despre numele dinamic al funcțiilor.
Capitolul 6:Preluarea datelor dintr-un formular
În acest capitol vom aborda următoarele subiecte:
Transmiterea datelor între paginile web: formulare HTML
Manipularea datelor dintr-un formular
Validarea datelor din formulare
În capitolele precedente valorile variabilelor erau atribuite în urma evaluării unor expresii.
Aplicațiile aveau o singură pagină, iar datele proveneau doar din resursele interne ale paginii.
Nu se trimiteau și nu se recepționau date la, respectiv de la, resurse externe paginii curente
sau aplicației. Aceasta nu este o situație tipică pentru o aplicație internet de tip client-server,
unde comunicația între diversele resurse este esențială. În acest capitol vom analiza situația
transmiterii datelor între paginile unei aplicații folosind formularul, respectiv prelucrarea
datelor recepționate de la un formular HTML. În capitolele următoare vom lărgi modalitatea
de comunicație.
6.1Formulare HTML
Un formular reprezintă un ansamblu de zone active alcătuit din butoane, casete de selecție,
câmpuri de editare etc. O sesiune de lucru cu o pagină web ce conține un formular și
interacționează cu un server PHP cuprinde următoarele etape:
clientul completează formularul și îl expediază server-ului PHP;
aplicația PHP de pe server analizează formularul și efectuează operațiile necesare;
server-ul trimite clientului eventual un răspuns.
Un formular este definit într-un bloc delimitat de etichetele:
<form method=”metoda” action=”url” >
…
</form>
unde:
atributul method precizează metoda utilizată de browser pentru expedierea datelor și
poate fi una dintre:
oget (implicită); datele introduse în formular sunt trimise prin adăugarea la
sfârșitul adresei URL, specificată de atributul action, a unor perechi de forma
nume=valoare. Între adresa URL și date este inserat “?” (semnul întrebării) .
Între diferitele seturi de date este introdus caracterul “&”. Astfel, datele trimise
prin metoda get pot fi vizualizate de către cel care accesează pagina. Aceasta
prezintă avantajul că adresa poate fi marcată ca bookmark în browser-ele
actuale, dar are dezavantajul că datele nu pot conține caractere non- ASCII. De
asemenea, cantitatea de date care poate fi procesată prin metoda get este
limitată la aproximativ 1kB;
opost; datele introduse în formular sunt expediate separat și astfel nu pot fi
vizualizate explicit de către cel care accesează pagina. Totodată, nu există o
limită a cantității de date trimise sau a tipului de caractere introduse;
atributul action specifică adresa URL a scriptului PHP care prelucrează datele
formularului. Adresa URL poate fi o adresă completă, care include protocolul, numele
gazdei și calea de acces, respectiv o adresă parțială, care specifică doar locație relativă
față de pagina curentă.
Majoritatea elementelor unui formular sunt introduse prin intermediul etichetei input ce are
următoarea sintaxă simplificată:
<input type=”tip” name=”nume” value=”valoare”>
unde:
atributul type indică tipul elementului ce urmează a fi introdus în formular. Printre
valorile posibile sunt: text (implicit), password, checkbox, radio, submit, reset,
file, hidden, image sau button
atributul name atașează elementului din formular un nume. Numele poate fi unic sau
mai multe elemente pot avea același nume (ex. cazul familiilor de radio butoane).
Valoarea atributului este trimisă server-ului prin perechea nume=valoare. Dacă
atributul lipsește din sintaxă, i se va atașa predefinit unul de către sistem.
atributul value este de obicei opțional. Un element care necesită în mod obligatoriu
acest atribut este checkbox. Atunci când este prezent atașează o valoare predefinită
elementului afișat. Valoarea atributului, eventual modificată de utilizator, este trimisă
server-ului prin perechea nume=valoare.
O altă etichetă frecvent utilizată pentru introducerea de elemente într-un formular este
select. Prin select introducem liste de selecție. Sintaxa simplificată a acestei etichete este:
<select name=”nume” size=”numar”>
…
</select>
unde:
atributul name are aceeași semnificație ca în cazul lui input;
atributul size precizează câte elemente din listă sunt vizibile la un moment dat
(valoarea implicită este 1), celelalte devenind vizibile prin acționarea barelor de
defilare.
Elementele din lista de selecție sunt introduse prin eticheta option ce are următoarea sintaxă
simplificată:
<option value=”valoare” selected> text
unde:
atributul value este opțional și valoarea sa va fi expediată server-ului. Dacă lipsește
server-ul va recepționa text-ul ce urmează etichetei;
atributul selected nu are valori și este opțional. Dacă este prezent determină
vizualizarea selectată a respectivei opțiuni din listă.
Alte etichete ce introduc elemente în formular vor fi explicate în momentul în care apar în
exemple viitoare.
6.2Manipularea datelor dintr-un formular
Informația introdusă într-un formular este expediată serverului web prin acționarea butonului
de expediere (în care type="submit"), prin acționarea tastei “enter”, acolo unde formularul
permite acest lucru, sau prin oricare alte tehnici definite de programator. Destinația de pe
server a aplicației ce prelucrează datele este dată de valoarea atributului action al etichetei
form.
Datele sunt transmise serverului ca o serie de perechi de formă nume-valoare.
PHP include mai multe modalități de a accesa datele introduse de utilizator într-un formular
dependent și de metoda cu care au fost expediate aplicației de pe server.
30Variabila superglobală $_GET
Aceasta reprezintă o variabilă de tip array care conține valorile elementelor transmise de la
formular scriptului PHP, ce le prelucrează, prin metoda GET. Cheia unui element din variabilă
este numele unui element al formularului iar valoarea este valoarea acelui element, transmise
prin perechea nume=valoare.
Exemplul 6.1: Formular în care informațiile sunt expediate prin metoda get
<html>
<head>
<title> Exemplul 6.1</title>
</head>
<body>
<form action="prelucrare.php" method="get">
Numele: <input type= "text" name="nume"/><br>
Prenumele: <input type= "text" name="prenume"/><br>
Localitatea: <input type= "text" name="localitate"/><br>
Judetul: <input type= "text" name="judet"/><br>
Universitatea absolvita: <br>
<select name= "universitate" size="3">
<option>Universitatea din Bucuresti
<option selected>Universitatea din Brasov
<option>Universitatea din Cluj
<option>Universitatea din Iasi
</select><br>
<input type="submit" name="exped" value="Expediaza"/>
</form>
</body>
</html>
Vizualizarea acestui fișier, conținând exclusiv cod HTML, va fi făcută în browser-ul
clientului. Clientul va completa câmpurile, va selecta Universitatea absolvita (în mod
predefinit este selectată Universitatea din Brasov ) și va trimite formularul server-ului
prin acționarea butonului Expediaza. Trimiterea formularului se va face prin metoda get.
Fișierul de pe server care va prelucra datele formularului este prelucrare.php (Exemplul 6.2).
Observația 6.1: Numele fisierului de pe server constituie calea relativă a acestuia. Prin
nespecificarea niciunei alte informații, cele două fișiere (cel în care se găsește formularul și
cel în care se fac prelucrările) sunt în același director.
Exemplul 6.2: Recepționarea informațiilor transmise dintr-un formular prin variabila superglobală
$_GET
<html>
<head>
<title> Exemplul 6.2 </title>
</head>
<body>
<?php
echo "Numele tau este: " . $_GET["nume"] . "<br/>";
echo "Prenumele tau este: " . $_GET["prenume"] . "<br/>";
echo "Esti din: " . $_GET["localitate"] . "<br/>";
echo "Judetul: " . $_GET["judet"] . "<br/>";
echo "<br/>";
echo "Ai absolvit: " . $_GET["universitate"];
?>
</body>
</html>
Acest fișier va afișa în browser-ul clientului răspunsul prelucrării (practic o succesiune de
instrucțiuni echo). Browser-ul clientului va avea în zona de specificare a adreselor următorul
URL:
http://localhost/carte/exemplul81/prelucrare.php?
nume=Vasilescu&prenume=Vasile&localitate=Brasov&judet=Brasov&universitate=U
niversitatea+din+Brasov&exped=Expediaza
Se observă perechile nume-valoare ce caracterizează fiecare element al formularului.
Observația 6.2: PHP posedă variabila superglobală $_SERVER, variabilă de tip array, ce
furnizează informații de mediu de pe server. Nu este obligatoriu ca toate informațiile posibil a
fi expediate să poată fi într-adevăr disponibile. Printre informațiile trimise există un element
cu cheia QUERY_STRING care are ca valoare ceea ce urmează semnului „?” în adresa URL.
Aceasta poate fi o alternativă pentru $_GET. În cazul Exemplului 6.2
$_SERVER['QUERY_STRING'] are valoarea:
nume=Vasilescu&prenume=Vasile&localitate=Brasov&judet=Brasov&universitate=U
niversitatea+din+Brasov&exped=Expediaza
Observația 6.3: Valoarea elementului $_SERVER['REQUEST_METHOD'] va indica tipul de metodă
cu care au fost trimise server-ului informațiile din formular.
31Variabila superglobala $_POST
Aceasta reprezintă o variabilă de tip array care conține valorile transmise scriptului PHP prin
metoda POST, de la un formular. Cheia unui element al variabilei este numele unui element al
formularului, iar valoarea este valoarea corespuntătoare respectivului element, transmise prin
perechea nume=valoare.
Exemplul 6.3: Exemplul 6.1 se modifică prin schimbarea valorii atributului method="post", iar
în Exemplul 6.2 variabila array va schimba numele din $_GET în $_POST. Adresa URL în acest
caz este:
http://localhost/carte/exemplul81/prelucrare.php
32Variabila superglobala $_REQUEST
Aceasta reprezintă o variabilă de tip array care conține valori transmise scriptului PHP prin
metodele POST sau GET de la un formular. Cheia unui element al variabilei este numele unui
element al formularului iar valoarea este valoarea corespunzatoare respectivului element,
transmise prin perechea nume=valoare.
Exemplul 6.4: Putem păstra oricare dintre fișierele ce conțin formulare din Exemplul 6.1 sau
Exemplul 6.3. În fișierul prelucrare.php vom modifica numele variabilei superglobale din
$_GET sau $_POST în $_REQUEST.
6.3Validarea datelor din formular
Când lucrăm cu pagini care implică procesarea formularelor este deseori necesar sa validăm
datele introduse de utilizatori. PHP conține numeroase funcții predefinite pentru aceasta.
Facem o trecere în revistă a celor mai des folosite:
is_string(var), determină dacă var este de tip string. Returnează TRUE sau FALSE;
is_int(var) sau is_integer(var) , determină dacă var este de tip integer.
Returnează TRUE sau FALSE;
is_numeric(var) determină dacă var este de tip numeric. Returnează TRUE sau
FALSE;
is_double(var) sau is_float(var), determină dacă var este de tip float.
Returnează TRUE sau FALSE;
is_bool(var), determină dacă var este de tip boolean. Returnează TRUE sau FALSE;
empty(var), determină dacă var este vidă. Returnează TRUE sau FALSE. Se consideră
vidă o variabilă care are valoarea NULL, string-ul vid, string-ul nul sau valoarea 0;
isset(var), determină dacă var este definită și are valoare !NULL. Returnează TRUE
sau FALSE;
print_r(var)sau var_dump(var), afișează informații despre var;
strlen(string), returnează lungimea string-ului (numărul de caractere) .
Exemplul 6.5: Validarea datelor dintr-un formular
Considerăm un formular în care utilizatorul introduce numele, numele de utilizator și parola.
Mai mult, impunem ca numele sa fie nenumeric și nevid, numele de utilizator nevid iar parola
nevidă și de minim 6 caractere.
Acest tip de validare a formularului este foarte des intâlnită, în felul acesta ne asigurăm că
doar informațiile valide – într-un format adecvat – vor fi prelucrate.
<html>
<head>
<title> Exemplul 6.5</title>
</head>
<body>
<form method="post" action="validare.php"/>
Introduceti numele:<br>
<input type="text" name="nume"/><br>
Introduceti numele de utilizator:<br>
<input type="text" name="numeu"/><br>
Introduceti parola (trebuie sa contina minim 6 caractere):<br>
<input type="password" name="pass"/><br>
<input type="submit" name="trimite" value="Expediaza"/>
</form>
</body>
</html>
Exemplul 6.6: Fișierul de validare ( validare.php)
Când butonul Expediaza este apăsat, o serie de instrucțiuni if vor fi folosite pentru a valida
conținutul câmpurilor din formular.
<html>
<head>
<title> Exemplul 6.6 </title>
</head>
<body>
<?php
$valid = true;
//Determina daca numele a nevid si nenumeric
if (!isset($_POST['nume'])or empty($_POST['nume'])
or is_numeric($_POST['nume'])){
$valid = false;
echo "introduceti numele<br>";
}
else{
$name = $_POST['nume'];
}
//Determina daca numele de utilizator e nevid
if (!isset($_POST['numeu'])or(empty($_POST['numeu']))){
$valid = false;
echo "introduceti numele utilizator<br>";
}
else{
$username = $_POST['numeu'];
}
//Determina daca parola e nevida si are minim 6 caractere
if (!isset($_POST['pass'])or(empty($_POST['pass']))
or(strlen($_POST['pass'])< 6)){
$valid = false;
echo "introduceti o parola corecta";
}
else{
$password = $_POST['pass'];
}
//se afiseaza mesaj de avertizare daca formularul nu a fost
//completat corect sau datele introduse, altfel
if($valid){
echo "ati introdus:<br>";
echo "numele: $name<br>";
echo "numele utilizator: $username<br>";
echo "si o parola valida";
}
?>
</body>
</html>
6.4Cod HTML și PHP într-o singură pagină
În exemplele din acest capitol am folosit două fișiere separate la fiecare aplicație. Unul în care
erau scrise datele ce urmau a fi completate, ca parte a formularului, iar altul în care aceste date
erau prelucrate. Scenariul acesta simplu este mai rar întilnit. În cazul validării unui formular
(Exemplul 6.5 și Exemplul 6.6) este posibil ca un formular sa fie afișat de mai multe ori până
când utilizatorul să îl completeze cu date valide. Dacă am folosi metoda de până acum ar
trebui să folosim butonul Back din browser pentru a reveni la formular. Folosirea acestui
buton, mai ales în cazul completării formularelor, nu este indicată. Mai mult, nici facil nu
este. Ar trebui să reținem erorile, apoi să incercăm sa le identificăm în formular și în final le
corectăm.
Soluția flexibilă este să încărcăm aceeași pagină până când utilizatorul reușește să completeze
date valide. În plus, erorile pe care le produce să fie afișate în preajma câmpului ce le-a
generat. După ce întregul formular a fost valid completat trecem la pagina de prelucrare a
datelor.
Pentru a implementa această soluție va trebui să intercalăm cod HTML și cod PHP. Din punct
de vedere strict al arhitecturii softului aceasta nu este cea mai bună soluție. Dar, pentru că este
un important pas înainte din punct de vedere al functionalității avem soluții și pentru
îmbunătățirea arhitecturii soft-ului (ex. folosirea “template framework-ului” SMARTY).
Exemplul 6.7: Cod HTML și PHP într-o singură pagină
Fisierul ex.php
<?php
$gata=true;
if(isset($_POST['nume'])){
if(empty($_POST['nume']) or is_numeric($_POST['nume']))
$gata=false;
}
else
$gata=false;
if(isset($_POST['numeu']))
if(empty($_POST['numeu']))
$gata=false;
if(isset($_POST['pass']))
if(empty($_POST['pass']) or (strlen($_POST['pass'])< 6))
$gata=false;
if(!$gata)
include "formular.php";
else
include "prelucrare.php";
?>
Fișierul formular.php
<html>
<head>
<title> Exemplul 6.7</title>
</head>
<body>
<form method="post" action="ex.php"/>
Introduceti numele:<br>
<input type="text" name="nume" value=
<?php
if(isset($_POST['nume']))
print $_POST['nume'];
?>
>
<?php
if(isset($_POST['nume']))
if(empty($_POST['nume']) or
is_numeric($_POST['nume']))
print "<font color='RED'>introduceti
numele</font>";
?><br>
Introduceti numele de utilizator:<br>
<input type="text" name="numeu" value=
<?php
if(isset($_POST['numeu']))
print $_POST['numeu'];
?>
>
<?php
if(isset($_POST['numeu']))
if(empty($_POST['numeu']))
print "<font color='RED'>introduceti
numele utilizator</font>";
?><br>
Introduceti parola (trebuie sa contina minim 6
caractere):<br>
<input type="password" name="pass" value=
<?php
if(isset($_POST['pass']))
print $_POST['pass'];
?>
>
<?php
if(isset($_POST['pass']))
if(empty($_POST['pass']) or
(strlen($_POST['pass'])< 6))
print "<font color='RED'>introduceti o
parola corecta</font>" ;
?><br>
<input type="submit" name="trimite" value="Expediaza"/>
</form>
</body>
</html>
Fișierul prelucrare.php
<html>
<head>
<title> Exemplul 6.7 </title>
</head>
<body>
<?php
echo "ati introdus:<br>";
$nume=$_POST['nume'];
echo "numele: $nume <br>";
$numeu=$_POST['numeu'];
echo "numele utilizator: $numeu <br>";
echo "si o parola valida";
?>
</body>
</html>
Aplicația este organizată în 3 fișiere. Aceasta este doar o chestiune de organizare. Fără nicio
problemă puteam scrie un singur fișier și obțineam aceleași rezultate. Din punct de vedere
organizațional am preferat această împărțire pentru a oferi o anumită flexibilitate aplicației și
pentru a scoate în evidență anumite neajunsuri, care vor fi rezolvate în capitolele următoare.
Fișierul ex.php este fișierul de bază. În el se alege ce pagină va fi încărcată în browser. Dacă
datele de intrare sunt inconsistente sau suntem la prima rulare, se încarcă fișierul
formular.php. Această acțiune se repetă până când datele devin consistente (respectă
condițiile impuse). Altfel, se încarcă fișierul prelucrare.php. Decizia de încărcare revine
fișierului ex.php.
În fișierul formular.php, care conține un formular clasic, introducem datele de intrare.
Deosebirea față de Exemplul 6.5 constă în faptul că valoarea atributului value al fiecărui tag
input este stabilită dinamic. Astfel, inițial aceasta este vidă, apoi va păstra valoarea anterioară
pentru ca utilizatorul să o observe și să o corecteze, dacă este cazul. De asemenea, dacă
valoarea introdusă pentru un anumit câmp este greșită, în dreptul câmpului respectiv va apare
un mesaj de eroare, scris cu roșu, la reîncărcarea paginii formularului. Am ales ca metodă de
transmitere POST pentru că este transmisă o parolă, care trebuie sa fie secretă. Există și alte
mijloace de secretizare, dar aceasta este acum cea mai la îndemână.
În fișierul prelucrare.php facem prelucrările după ce datele au fost validate. Acestea ar
putea consta în commit pe o bază de date, upload de fișiere samd. Noi am afișat doar datele
introduse de utilizator.
Obsevația 6.4: Un inconvenient major al situației prezentate este acela că testările, făcute o dată
în formular.php, trebuie refăcute în ex.php, pentru a decide asupra fișierului ce urmează a fi
încărcat în browser. Aceasta deoarece nu avem posibilitatea de a transmite datele între pagini
decât prin intermediul formularului. Singura soluție, acum, ar fi fost un element hidden, dar
acesta are o valoare statică. Pe alte soluții de rezolvare, posibile, le vom studia în capitolele
următoare.
Observația 6.5: În Exemplul 6.7 am folosit funcția predefinită include(nume). Aceasta permite
inserare de cod PHP în alt cod PHP, deja existent. Parametrul nume al funcției reprezintă
numele fișierului (incluzând eventual calea: absolută sau relativă) în care este stocat codul ce
urmează a fi inserat. include() păstrează domeniul global al variabilelor din fișierul gazdă.
În cazul în care fișierul parametru nu este găsit se va emite un mesaj de avertizare, dar
execuția aplicației va continua. Fișierele incluse pot returna valori la fel ca și funcțiile. Ca și în
cazul funcțiilor, apelul instructiunii return încheie execuția codului fișierului inclus și
returnează o valoare (Exemplul 6.8).
Exemplul 6.8: Fișier inclus ce returnează o valoare
Fișierul ex.php
<html>
<head>
</head>
<body>
<?php
$addResult = include("pagina2.php");
print "fisierul inclus returneaza $addResult";
?>
</body>
</html>
Fișierul pagina2.php
<?php
$retval = ( 4 + 4 );
return $retval;
//daca ar exista cod, în continuare, acesta nu ar fi executat
?>
Cele două fișiere se află în același director. În fișierul ex.php calea fișierului pagina2.php
este precizată relativ.
Un comportament asemănător cu include() are funcția require() care va determina, însă,
întreruperea execuției aplicației în caz de eroare.
Observația 6.6: Validări se pot face în mai multe moduri. Cea aleasă de noi, prin PHP, are
avantajul de a comunica cu server-ul de aplicație și mai departe cu server-ul de baze de date
pentru validări complexe, dar prezintă dezavantajul că în cazul validărilor simple (ex. un
câmp este numeric) se pierde prea mult timp. O posibilitate de validare este și cu JavaScript.
Aceste validări se fac local, la client, dacă clientul permite acest lucru.
6.5Rezumat
Pe parcursul acestui capitol am studiat cum să lucrăm cu formulare, cu variabilele
superglobale $_POST, $_GET și $_REQUEST și cum să validăm formularele. Pe final am mai
făcut un pas înainte în crearea paginilor web dinamice. Am organizat fișierele astfel încât să
permită soluții flexibile de navigare și validare.
Capitolul 7:Cookie-uri
În acest capitol vom aborda următoarele subiecte:
Cookie-uri, definiție, caracteristici importante
Managementul variabilelor cookie: creare, acces, ștergere
7.1Despre cookie-uri
În toate exemplele de până acum valoarea variabilelor dispărea atunci când scriptul PHP, care
le conținea, își încheia execuția. O soluție de păstrare a valorilor pe timp îndelungat este
folosirea cookie-urilor.
Un cookie reprezintă un text, de lungime relativ mică, identificat printr-un nume și stocat pe
calculatorul client de către browser-ul web. Un cookie constă din una sau mai multe perechi
de tip nume-valoare.
Cookie-urile sunt transmise de către server-ul web browser-ului ca un HTTP header.
Browserul stochează cookie-urile în unitatea de disc locală a clientului și retransmite aceste
valori de fiecare dată când sunt accesate de server. În general, cookie-urile sunt disponibile
doar site-urilor care le-au creat. Există și cazuri exceptate, cum ar fi cross-site cooking, care
permit accesul la aceleași cookie-uri mai multor site-uri.
Cookie-urile sunt utile, spre exemplu, pentru a stoca identitatea utilizatorului sau preferințele
de vizualizare ale acestuia. Când utilizatorul revine la site-ul web, variabi lele cookie permit
browser-ului să recunoască utilizatorul și să restaureze opțiunile site-ului, selectate de către
utilizator.
Dezavantajele folosirii cookie-urilor constau din:
un utilizator poate dezactiva variabilele cookie prin stabilirea unei opțiuni a browser-
ului și atunci folosirea lor devine imposibilă;
în anumite situații, variabilele cookie pot fi vizualizate și de un alt utilizator decât cel
care le-a stocat;
un site poate stoca numai 20 de variabile cookie și numai 4KB de informații în
unitatea de disc locală a utilizatorului.
În ciuda acestor dezavantaje, variabilele cookie rămân cea mai populară tehnică pentru
stocarea de valori pe termen lung.
7.2Management-ul cookie-urilor
33Crearea unei cookie
Pentru a crea (adică a trimite către calculatorul client) o variabilă cookie apelăm funcția
setcookie(), care are următoarea sintaxă simplificată:
setcookie(nume, valoare, expirare, cale) ;
unde:
nume specifică numele variabilei cookie și este un identificator. Este singurul
parametru obligatoriu;
valoare specifică valoarea variabilei. Este parte a perechii nume-valoare reținută pe
calculatorul client;
expirare specifică momentul expirării varia bilei cookie (exprimat în secunde trecute
de la 1 ianuarie 1970, ora 0.00.00, GMT). După această oră variabila cookie nu mai
este accesibilă. În general, este convenabil să se specifice momentul expirării folosind
funcția predefinită time(), care returnează data și ora curentă, exprimate în secunde
scurse de la 1 ianua rie 1970, la care să adăugăm o valoare care să specifice numărul de
secunde cât variabila cookie va fi accesibilă. De remarcat este faprul că variabila
cookie este stocată pe calculatorul client, deci timpii implicați sunt luați de pe acesta,
nu de pe server-ul pe care se află aplicația. Implicit acest parametru are valoarea 0,
ceea ce înseamnă până la închiderea browser-ului;
cale specifică domeniul de valabilitate al cookie-ului. Astfel, dacă valoarea
parametrului este „ /”, atunci cookie-ul este disponibil întregului domeniu, dacă
valoarea este „/director/’, atunci valabilitatea este directorul specificat și toate
subdirectoarele sale. Implicit are valoarea directorului curent.
Observația 7.1: Pentru că valorile cookie se trimit prin HTTP header trebuie ca apelul lui
setcookie()să se facă înainte de orice alt răspuns trimis către browser-ul client. Ele sunt
întotdeauna printre primele linii de cod dintr-un script.
Observația 7.2: Pe lângă apelul funcției time() PHP mai pune la dispoziție și o funcție de
creare a datelor, exprimate în secunde. Sintaxa simplificată a acesteia este:
mktime(ore, minute, secunde, luna, zi, an);
În caz de dată invalidă întoarce -1.
34Accesul la valorile unui cookie
PHP deține variabila superglobală $_COOKIE, ce reprezintă o variabilă de tip array în care
cheia unui element este numele cookie-ului, iar valoarea acestuia reprezintă valoarea cookie-
ului.
De asemenea, putem accesa valoarea unui cookie prin variabila superglobală $_REQUEST, la
fel ca în cazul informațiilor trimise din formulare.
Observația 7.3: Pentru a accesa valoarea unui cookie trebuie ca acesta sa fie depusă pe discul
clientului. Așadar o aplicație care crează un cookie și îl și accesează va avea disponibilă
valoarea acestuia abia la a doua rulare ( Exemplul 7.1).
Exemplul 7.1: Crearea și afișarea unei variabile cookie
<?php
setcookie( "fruct", "mar", time()+ 3600);
?>
<html>
<head>
<title> Exemplul 7.1</title>
</head>
<body>
<?php
if ( isset( $_COOKIE['fruct'] ) )
print "<p>Ati ales fructul ".$_COOKIE['fruct']."</p>";
else
print "<p>Salut! Aceasta este prima ta vizita! </p>";
?>
</body>
</html>
Se creează o variabilă cookie fruct cu valoarea măr. Durata de viața este stabilită folosind
funcția time() pentru a afla data curentă, la care adăugăm 3600 (o oră).
35Ștergerea unei variabile cookie
Se realizează tot prin apelul func ției setcookie() care va fixa un timp de valabilitate al
variabilei mai mic decât timpul curent.
setcookie( "fruct", "", time()-60);
Astfel, la următoarea accesare a aplicației variabila cookie fruct nu va mai fi valabilă.
7.3Array de cookie-uri
Sub același nume putem avea un șir de cookie-uri. Pentru aceasta vom crea un array, în care
cheia fiecărui element reprezintă numele fiecărui cookie, iar valoarea elementului este
valoarea cookie-ului. ( Exemplul 7.2)
Exemplul 7.2: Array de cookie-uri
<?php
setcookie("cookie[unu]", "unu");
setcookie("cookie[doi]", "doi");
setcookie("cookie[trei]", "trei");
if (isset($_COOKIE['cookie'])) {
foreach ($_COOKIE['cookie'] as $nume => $val) {
echo "$nume : $val <br />\n";
}
}
?>
În Exemplul 7.2 putem observa modul de construcție al numelui unui element într-un array de
cookie-uri. Avem întai numele variabilei array, în cazul nostru cookie, și apoi cheia scrisă
între paranteze drepte, fără apostrofuri.
7.4Rezumat
În acest capitol am discutat principalele elemente ce caracterizează un cookie, am creat
cookie-uri prin apelul functiei setcookie(), am accesat valorile cookie-urilor prin variabilele
superglobale $_COOKIE și $_REQUEST, am șters cookie-uri modificând timpul de expirare
și am creat șiruri de cookie-uri.
Capitolul 8:Sesiuni
În acest capitol vom aborda următoarele subiecte:
Ce este o sesiune și la ce se folosesc sesiunile
Cum pornim și cum preluăm o sesiune
Cum folosim variabilele sesiune
Cum distrugem o sesiune
8.1Ce este o sesiune?
În general, prin sesiune întelegem perioada de activitate a unei comunicații între entităț,i spre
exemplu între client și server sau între diverse alte mijloace de comunicare.
Pentru a putea explica noțiunea de sesiune în PHP vom descrie, pe scurt, cadrul general de
lucru al aplicațiilor client-server din internet.
Principalul model ce descrie, prin implementări ale protocoalelor de rețea, comunicarea
calculatoarelor într-o rețea ca internetul este TCP/IP. Acesta este organizat pe patru nivele
abstracte, fiecare nivel conținând unul sau mai multe protocoale, și anume: nivelul de legătură
(link level), nivelul internet ( internet level), nivelul de transport ( transport level) și nivelul de
aplicație (application level).
În cadrul aplicațiilor PHP ne interesează nivelul de aplicație al modelului TCP/IP. Unul dintre
principalele protocoale la acest nivel este HTTP ( HyperText Transfer Protocol ). HTTP este
un standard de tip cerere-răspuns între un client și un server. Clientul face o cerere HTTP
folosind un web browser către un server care formulează răspunsul (server-ul web).
Observația 8.1: HTTP nu este constrâns să utilizeze exclusiv modelul TCP/IP (deși este cel mai
des folosit), ci poate folosi orice model ce pune la dispoziție un protocol de transport
compatibil.
În mod obișnuit procesul de comunicare se desfășoară astfel: clientul HTTP inițiază o cerere
(formată din cererea propriu-zisă, un header, o linie liberă și eventual un mesaj), apoi printr-
un protocol de transport (cel mai des TCP – Transmission Control Protocol ) se conectează la
un port (în mod predefinit portul 80). Server-ul, prin acel port, așteaptă cererile clientului, le
recepționează, transmite un mesaj de recepționare și apoi un răspuns la cererea clientului.
HTTP este un protocol fără stare ( stateless). Aceasta înseamnă că pe server-ul web nu se rețin
informații despre utilizatori între cereri. Totuși acesta nu este neapărat un avantaj pentru că
gestionarea informațiilor despre utilizatori revine în grija programatorului. Există mai multe
metode de rezolvare: folosind cookie-uri, sesiuni server-side sau prin parametrii adresei URL.
Sesiunile au fost integrate în PHP începând cu versiunea 4 cu rolul de a stoca și urmări datele
utilizatorilor atunci când aceștia navighează între mai multe pagini ale unui site. Una dintre
principalele caracteristici ale unei sesiuni, datorate protocolului HTTP, este identificatorul de
sesiune (ID).
Un identificator de sesiune este în mod obișnuit atribuit unui vizitator la prima vizită a unui
site. Identificatorul este deseori un string lung de caracteres, alese în mod aleator. În cazul
PHP-ului identificatorul de sesiune este generat de server și trimis clientului care îl stochează
ca pe un cookie. În afară de identificatorul de sesiune, toate celelate date aparținând sesiunii
utilizatorului curent sunt stocate pe server. Dacă identificatorul de sesiune nu este posibil a fi
înregistrat ca un cookie (browser-ul a blocat folosirea cookie-urile), atunci îl putem transmite
codificat în adresa URL a cererii client.
8.2Pornirea unei sesiuni
Pentru a putea folosi o sesiune trebuie mai întâi ca aceasta să fie pornită. În mod predefinit
sesiunile nu pornesc automat.
Pentru a realiza pornirea automată a sesiunilor trebuie ca în fișierul php.ini să setăm
valoarea opțiunii session.auto_start la valoarea 1. În mod predefinit:
session.auto_start = 0
Dacă sesiunile nu pornesc automat atunci va trebui să apelăm funcția session_start() în
fiecare script PHP ce folosește sesiuni. Pentru că session_start() se apelează atât la
pornirea unei sesiuni, cât și la confirmarea faptului că respectivul script folosește o sesiune
deja pornită, atunci este obligatoriu apelul funcției înainte de orice transmitere de date (ca în
cazul cookie-urilor).
Dupa ce o sesiune a fost pornită, vom avea acces la valoarea identificatorului de sesiune
folosind funcția session_id(). Aceasta, fără parametri, returnează valoarea identificatorului
sesiunii curente (Exemplul 8.1).
Exemplul 8.1: Pornirea unei sesiuni
<?php
session_start();
?>
<html>
<head>
<title>Exemplul 8.1</title>
</head>
<body>
<?php
print "<p>Bine ati venit, sesiunea ID este
".session_id()."</p>\n\n";
?>
</body>
</html>
În Exemplul 8.2 avem apelul funcției session_id() cu parametrul idnou. Acesta determină
modificarea identificatorului de sesiune returnând valoarea nou setată. idnou este, de fapt,
string-ul ce va constitui id-ul noii sesiuni. Dacă dorim ca acesta să fie identificatorul de
sesiune pentru întreg site-ul curent va trebui să-l înregistrăm cu
setcookie(session_name(), session_id()) (Exemplul 8.2). Funcția predefinită
session_name() va returna numele sesiunii curente. În mod predefinit, în PHP, numele
sesiunii este PHPSESSID.
Exemplul 8.2: Schimbarea și înregistrarea identificatorului de sesiune
<?php
session_id("idnou");
session_start();
setcookie(session_name(),session_id());
?>
<html>
<head>
<title>Exemplul 8.2</title>
</head>
<body>
<?php
print "<p>Bine ati venit, sesiunea ID este
".session_id()."</p>\n\n";
?>
<a href="pagina2.php">pagina 2</a>
</body>
</html>
În pagina2.php vom avea identificatorul de sesiune: idnou.
Acesta este modul cel mai frecvent utilizat și cel mai recomandat. Dacă însă browser-ul nu
acceptă cookie-uri, vom putea lucra cu sesiuni, dar vom avea dezavantajul că identificatorul
de sesiune va fi parte a URL-ului, deci va fi mai ușor de interceptat.
Lucrul cu cookie-uri este în PHP și cel predefinit. Pentru ca identificatorul de sesiune să nu
fie stocat în cookie vom modifica opțiunea:
session.use_cookies = 0
din fișierul php.ini.
Observația 8.2: În URL perechea nume-valoare, ce transmite identificatorul de sesiune, va fi
descrisă sub forma: session_name()=session_id() , cu specificarea că în mod obligatoriu
aceasta va fi prima pereche în adresa URL, dintre perechile de date ce vor fi expediate server-
ului.
Fără alte modificări sesiunea rămâne curentă atâta timp cât browser-ul este activ. Când
utilizatorul repornește browser-ul, cookie-ul ce reține valoarea identificatorului este resetat.
Putem schimba acest comportament modificând variabila session.cookie_lifetime în
fișierul php.ini, menționând și timpul după care sesiunea va expira după închiderea browser-
ului.
8.3Lucrul cu variabile sesiune
PHP posedă variabila de tip array, superglobală, $_SESSION în care cheia unui element este
numele variabilei sesiune, iar valoarea elementului este valoarea variabilei sesiune. PHP pune
la dispoziție câte un array pentru fiecare sesiune identificată prin identificatorul sesiunii.
Exemplul 8.3 ilustrează modul de lucru cu variabile sesiune, identificatorul fiind trimis prin
ambele modalități: cookie și URL.
Exemplul 8.3 : Utilizarea variabilelor sesiune
Fișierul: ex.php
<?php
session_start();
echo 'Pagina #1';
$_SESSION['culoare'] = 'verde';
$_SESSION['animal'] = 'pisica';
$_SESSION['time'] = time();
if(!SID)
// Functioneaza daca session cookie-urile sunt acceptate
echo '<br /><a href="pagina2.php">pagina 2</a>';
else
// Sau transmitem prin url
echo '<br /><a href="pagina2.php?' . SID . '">pagina 2</a>';
?>
Fișierul: pagina2.php
<?php
// pagina2.php
session_start();
echo 'Pagina #2<br />';
echo $_SESSION['culoare']."<br>"; // verde
echo $_SESSION['animal']."<br>"; // pisica
echo date('Y m d H:i:s', $_SESSION['time']);
echo '<br /><a href="ex.php">pagina 1</a>';
?>
În Exemplul 8.3, fișierul ex.php, am creat 3 elemente în șirul sesiunii curente. În fișierul
pagina2.php, care are un link în fișierul ex.php, identificatorul de sesiune se transmite prin
cookie, dacă cookie-urile sunt acceptate, sau prin URL altfel.
În cel de-al doilea caz avem la dipoziție variabila PHP predefinită SID, nevidă doar în cazul în
care session.use_cookies = 0 , și care reține perechea session_name()=session_id() .
Valorile transmise din ex.php vor fi recunoscute în pagina2.php, pe baza identificatorului
de sesiune comun.
8.4Distrugerea unei sesiuni
Pentru eliberarea tuturor variabilelor atașate unei sesiuni se folosește funcția
session_unset(). Ca variantă pentru această funcție putem folosi atribuirea:
$_SESSION = array();
Pentru a șterge un element din variabila $_SESSION se folosește funcția unset(var) ca în
cazul ștergerii oricărei variabile.
unset($_SESSION['culoare']);
Apelul anterior determină ștergerea elementului de cheie culoare din array-ul $_SESSION.
Pentru ștergerea tuturor datelor din sesiunea curentă se apelează funcția session_destroy() .
Această funcție nu șterge și identificatorul de sesiune memorat. Pentru a șterge și cookie-ul
vom apela:
setcookie(session_name(), '', time()-42000, '/');
Așadar, pentru a distruge o sesiune, inclusiv variabilele atașate, vom folosi următoarea
secvență:
session_start();
$_SESSION = array();
setcookie(session_name(), '', time()-42000, '/');
session_destroy();
8.5Rezumat
În acest capitol am discutat despre cadrul general de folosire a sesiunilor, am pornit și am
reluat o sesiune precum și am înregistrat o sesiune nouă. Am studiat modalitatea de
transmitere a identificatorului de sesiune: prin variabile cookie sau prin URL. Am creat
variabile sesiune și le-am utilizat în diferite pagini. În final, am distrus sesiunile și am eliberat
variabilele atașate sesiunilor.
Capitolul 9:Lucrul cu fișiere
În acest capitol vom aborda următoarele subiecte:
Crearea fluxurilor pentru lucrul cu fișiere externe
Operații elementare cu fișiere: citirea, scriere și adăugarea
Gestionarea lucrului cu fișiere: copierea, redenumirea, ștergerea
Operații cu pointerul de flux atașat fișierului
Aplicație: stocarea datelor din formular
Încărcarea fișierelor pe server.
PHP oferă acces la citirea, scrierea sau adăugarea de conținut în fișiere externe.
9.1Deschiderea fișierelor și crearea fluxurilor de lucru cu fișiere
Deschiderea unui fișier sau a unui URL se face prin funcția fopen(), ce are următoarea
sintaxă simplificată:
fopen(nume_fișier, mod)
Această funcție returnează un flux prin deschiderea unei resurse dată de nume_fișier.
Sintaxa completă pentru nume_fișier este de forma: protocol://…, unde protocol
poate fi: file (implicit), http (numai pentru citire) sau ftp (atât pentru citire cât și pentru
scriere, dacă server-ul suportă conexiuni ftp). Este posibil ca protocol să lipsească și atunci
PHP decide că nume_fișier este adresa unui fișier local. În acest caz adresa poate fi una
absolută sau una relativă (construită față de directorul curent). Pentru ca fișierul să se poată
deschide trebuie ca PHP să aibă drepturi asupra acelui fișier. Modul în care un fișier este
deschis este dat de string-ul mod (Tabelul 9.1) al funcției.
Mod Descriere
rDeschide un fișier existent pentru citire. Pointerul este plasat la începutul
fișierului.
r+Deschide un fișier pentru citire sau scriere. Pointerul este plasat la începutul
fișierului
wDeschide un fișier pentru scriere. Dacă fișierul nu există, atunci este creat. Altfel,
pointerul este plasat la începutul fișierului și conținutul existent este șters.
w+Deschide un fișier pentru scriere sau citire. Daca fișierul nu există, atunci este
creat. Altfel, pointerul este plasat la începutul fișierului și conținutul existent este
șters.
aDeschide un fișier pentru scriere. Dacă fișierul nu există, atunci este creat. Altfel,
pointerul este plasat la sfârșitul fișierului.
a+Deschide un fișier pentru scriere sau citire. Dacă fișierul nu există, atunci este
creat. Altfel, pointerul este plasat la sfârșitul fișierului.
Tabelul 9.1: Descrierea modurilor de deschidere a unor fișiere
Observația 9.1: Ca și în alte limbaje de programare (ex: C) și în PHP, pe lângă precizarea
modului de deschidere a fișierului, este indicat a se preciza tipul fișierului deschis. PHP
interpretează orice fișier extern ca fiind de unul dintre tipurile: binar sau text. Nu există o
regulă privind tipul predefinit, acesta depinzând de versiunea de PHP utilizată. Diferența între
tipuri constă doar în interpretarea sfârșitului de linie. Dacă fișierul binar interpretează sfârșitul
de linie ca pe un singur caracter, fișierul text îl interpretează ca pe două caractere ( <CR> și
<LF>). Această interpretare are consecințe importante în deschiderea fișierelor. Pentru a
preciza tipul de fișier vom adăuga la sfârșitul string-ului mod unul dintre caracterele b sau t.
Funcția fopen() returnează fluxul în caz de succes și FALSE altfel. Dacă deschiderea cu
succes a fișierului nu a avut loc din cauza unei căi invalide, permisiuni de securitate
nerespectate sau alte motive, se va genera un mesaj de eroare. Pentru a suprima mesajul de
eroare predefinit putem folosi operatorul “ @” și una dintre următoarele funcții predefinite PHP
care să trateze aceste erori:
exit(mesaj) care încheie execuția scriptului curent și afișează mesajul de eroare
mesaj
die(mesaj) care este un alias al funcției exit().
Pentru închiderea fluxului către un fișier se folosește funcția fclose() ce are sintaxa:
fclose(flux);
Funcția necesită ca parametru fluxul care a fost creat la deschidere. Returnează TRUE în caz de
succes și FALSE altfel.
Este recomandat ca închiderea fluxului să se facă în mod explicit, dar este obligatoriu acest
lucru atunci când fluxul a fost deschis pentru scriere ( Exemplul 9.1), pentru a ne asigura de
închiderea memoriei tampon și transferul tuturor datelor în fișierul extern.
Exemplul 9.1: Crearea unui fișier extern
<?php
$numefisier = "../fișier.txt";
$flux=@fopen($numefisier,"wt") or exit("Nu se poate deschide
fișierul");
fclose($flux);
?>
În Exemplul 9.1 primul pas este să creăm o variabilă, $numefisier, care să rețină calea
fișierului care va fi deschis pentru scriere. Calea este relativă. Interpretarea prefixului ../ este
aceea că fișierul nou creat se află în directorul rădăcină directorului fișierului curent. După
logica creării aplicațiilor, de care am discutat în Capitolul 2, avem mai întâi directorul ce
conține workspace-ul, apoi directorul proiectului, director ce conține și fișierul curent al
aplicației. Așadar, am creat fișier.txt în directorul workspace-ului. Simpla deschidere
pentru scriere a fișierului, deschiderea fluxului și apoi închiderea sa determină crearea unui
fișier vid, cu numele indicat.
9.2Operații elementare cu fișiere
36Citirea din fișier
După operația de deschidere cu succes a unui flux urmează operațiile în cadrul acestuia. Una
dintre ele este citirea. PHP oferă mai multe funcții de citire. În acest paragraf vom aminti
câteva dintre acestea.
fread(flux, lungime) care determină citirea binară dintr-un flux existent.
Parametrii funcției sunt: numele fluxului, flux, și numărul de octeți doriți a fi citiți
din flux, lungime. Citirea se termină când:
s-a atins numărul de octeți indicat;
s-a întâlnit EOF (end of file – sfârșitul fișierului);
s-au citit 8192 de octeți;
pachetul devine indisponibil din cauza problemelor de rețea.
Funcția returnează un string sau FALSE în caz de eroare.
Exemplul 9.2: Citirea din fișier cu fread()
<?php
$numefisier = "fișier.txt";
$flux = @fopen($numefisier, "r") or exit("fisierul nu poate fi
deschis");
$continut = @fread($flux,filesize($numefisier)) or
exit("fisierul nu poate fi citit");
echo $continut."<br>";
fclose($flux);
?>
Pentru determinarea dimensiunii fișierului citit am folosit funcția filesize()
ce are ca parametru numele extern al acestuia. Se observă că și pentru această
funcție am folosit operatorul „ @”.
file_get_contents(nume_fișier) care determină citirea într-un string a
întregului conținut al unui fișier. Atenție, parametrul este numele extern al
fișierului!
stream_get_contents(flux) asemănător cu precedenta, dar parametrul este
fluxul creat la deschidere:
Exemplul 9.3: Citirea din fișier cu stream_get_contents()
$numefisier = "http://cs.unitbv.ro/";
$flux = @fopen($numefisier, "rb") or exit("fisierul nu poate fi
deschis");
$continut = @stream_get_contents($flux) or exit("fisierul nu
poate fi citit");
Se observă că și pentru această funcție am folosit operatorul „ @”.
fgetcsv(flux, lungime, delimitator) funcție folosită pentru citirea
conținutului unei linii din flux, pornind de la pointerul curent al fluxului și
transformarea (parsarea) datelor citite, în funcție de delimitator, într-o variabilă
de tip array. Paremetrul delimitator este format dintr-un singur caracter, în mod
predefinit “,” (virgula). Parametrul lungime este opțional începând cu PHP5 și
poate fi setat la 0.
Exemplul 9.4: Citirea din fișier cu fgetcsv()
Edităm fișierul fișier.txt din Exemplul 9.2 astfel încât să conțină următoarea
linie: 50,17,34,90, păstrăm neschimbată deschiderea fluxului și apoi adăugăm
liniile de cod:
$continut = @fgetcsv($flux) or exit("fisierul nu poate fi citit");
for ($i=0; $i < sizeof($continut); $i++){
echo $continut[$i];
echo "<br/>";
}
Se observă că pentru această funcție am folosit operatorul „ @” și parametrii
impliciți.
37Scrierea în fișier
Pentru scrierea într-un flux deschis pentru creare sau adăugare PHP pune la dipoziție mai
multe funcții. Vom da o descriere a celor mai importante dintre ele:
fwrite(flux, string, lungime) funcție care determină scrierea conținutului
parametrului string în flux-ul creat pentru aceasta. lungime este un parametru
opțional care indică când se va termina scrierea, după ce a fost atins numărul de
caractere specificat sau s-a atins sfârșitul stringului ( Exemplul 9.5). Funcția
returnează numărul de octeți scriși, în caz de succes, sau FALSE, altfel.
Exemplul 9.5: Scrierea în fișier cu fwrite()
<?php
$numefisier = "fișier.txt";
$flux = fopen($numefisier, "w") or exit("fisierul
nu poate fi deschis");
$continut = "text scris în fisier";
fwrite($flux,$continut);
fclose($flux);
?>
Dacă există deja fișier.txt, conținutul său va fi șters și se va crea un fișier nou;
file_put_contents(nume_fiser, date) funcție folosită pentru scrierea într-un
fișier. Primul parametru este numele extern al fișierului iar al doilea este numele
unei variabile din care se va face scrierea. Acest parametru poate fi string, array
sau un flux deja creat. Returnează lungimea șirului scris, în caz de succes, sau
FALSE, altfel;
stream_copy_to_stream(flux_sursa, flux_destinatie) funcție
asemănătoare ca funcționalitate cu cea anterioară, doar că parametrii sunt fluxuri
create pentru citire, flux_sursa, respectiv scriere, flux_destinatie. Returnează
numărul de octeți transferați;
fputcsv(flux, date, delimitator) funcție ce scrie într-un flux deja creat o
linie formată din elementele parametrului date de tip array și delimitate de
delimitator. Implicit delimitatorul este virgulă. Returnează lungimea șirului
scris, în caz de succes, sau FALSE, altfel.
9.3Gestionarea lucrului cu fișiere
38Copierea fișierelor
Pentru a copia conținutul unui fișier extern într-un alt fișier extern PHP pune la dispoziție
funcția copy(). Sintaxa acesteia este :
copy(nume_fiser_sursa, nume_fiser_destinatie)
Cei doi parametri reprezintă numele externe ale fișierelor. Funcția returnează TRUE, în caz de
succes, sau FALSE, altfel. Ca în cazul oricăror scrieri, dacă destinație există, conținutul său va
fi șters și înlocuit cu cel al fișierului sursă ( Exemplul 9.6).
Exemplul 9.6: Copierea fișierelor cu copy()
<?php
$numefisiersursa = "fișier.txt";
$numefisierdestinatie = "fisiernou.txt";
$status = @copy($numefisiersursa, $numefisierdestinatie) or
die("copierea nu se poate face");
echo "copiere facuta cu succes";
?>
39Ștergerea fișierelor
PHP oferă funcția unlink() pentru ștergerea fișierelor externe. Funcția trebuie folosită cu
grijă pentru că, o dată ce un fișier a fost șters el nu mai poate fi recuperat. Sintaxa funcției este
următoarea:
unlink(nume_fiser)
Funcția returnează TRUE, în caz de succes, sau FALSE, altfel (Exemplul 9.7).
Exemplul 9.7: Ștergerea unui fișier cu unlink()
<?php
$numefisier = "fisier.txt";
$status = @unlink($numefisier) or exit("fisierul nu poate fi sters");
echo "stergere facuta cu succes";
?>
40Redenumirea fișierelor
Funcția rename() este folosită pentru redenumirea fișierelor. Sintaxa funcției este :
rename(nume_fișier_original, nume_fișier_nou)
Funcția redenumește fișierul referit de primul parametru, nume_fișier_original , cu numele
dat de cel de-al doilea parametru, nume_fișier_nou . Ambele sunt nume externe de fișiere.
Funcția returnează TRUE, în caz de succes, sau FALSE, altfel (Exemplul 9.8).
Exemplul 9.8: Redenumirea unui fișier cu rename()
<?php
$numefiser = "fisier.txt";
$numenou = "fisiernou.txt";
$status = rename($numefisier, $numenou) or exit("fisierul nu poate fi
redenumit");
echo "redenumire cu succes";
?>
9.4Lucrul cu directoare
Crearea unui director se face cu funcția:
mkdir(nume_director)
unde, nume_director poate include și calea către director. Funcția returnează TRUE, în caz de
succes, sau FALSE, altfel.
Ștergerea unui director se face cu funcția:
rmdir(nume_director)
unde, nume_director poate include și calea către director. Funcția returnează TRUE, în caz de
succes, sau FALSE, altfel.
9.5Operații pe fișiere
41Verificarea existenței unui fișier
Putem testa existența unui fișier sau a unui director folosind funcția file_exists(). Sintaxa
acesteia este:
file_exists(nume)
unde, nume poate include și calea către fișier sau director. Funcția returnează TRUE, în cazul în
care fișierul sau directorul există, sau FALSE, altfel.
if( file_exists("test.txt") )
print "fișierul exista!";
42Fișier sau Director?
Putem afla dacă entitatea pe care o testăm este fișier folosind funcția is_file(nume).
if( is_file( "test.txt" ) )
print "test.txt este fișier!";
De asemenea, putem verifica dacă entitatea este director cu ajutorul funcției is_dir(nume).
if ( is_dir( "/tmp" ) )
print "/tmp este director";
43Funcții ce returnează atributele unui fișier
PHP posedă mai multe functii pentru testarea diferitelor atribute ale unui fișier. Vom prezenta
în continuare câteva dintre cele mai des folosite:
filesize(nume_fișier) determină dimensiunea în octeți a unui fișier;
fileatime(nume_fișier) determină timpul la care a fost accesat ultima oară fișierul;
filemtime(nume_fișier) determină timpul la care a fost modificat ultima oară
fișierul;
is_readable(nume_fișier) determină dacă fișierul poate fi citit;
is_writeable(nume_fișier) determină dacă fișierul poate fi scris;
is_executable(nume_fișier) determină dacă fișierul este executabil.
9.5.1Funcții de lucru cu pointer-ul unui fișier
Până în acest moment, în fluxul deschis, nu am făcut nicio modificare a indicatorului de fișier
(pointerul de fișier). PHP deține mai multe funcții ce operează asupra acestuia. Vom da în
continuare câteva dintre cele mai folosite:
rewind(flux) care determină poziționarea pointerului la începutul fluxului de fișier;
ftell(flux) care determină poziționarea curentă a pointerului fișierului;
fseek(flux, deplasare, pozitie_initiala) care determină poziționarea
pointerului de fișier cu un număr de octeți dat de deplasare (poate fi și negativ) față
de valoarea indicată de pozitie_initiala. Valorile posibile ale celui de-al treilea
parametru sunt: SEEK_SET (implicit) începutul fișierului, SEEK_CUR poziția curentă
respectiv SEEK_END sfârșitul fișierului;
feof(flux) determină dacă pointerul indică sfârșitul de fișier
9.6Colectarea datelor dintr-un formular
Continuăm exemplele în care un formular era prelucrat într-o aplicație PHP, prin realizarea
persistenței datelor. Cazul cel mai frecvent este salvarea într-o bază de date, dar deocamdată
vom realiza persistența într-un fișier extern ( Exemplul 9.9).
Exemplul 9.9: Date dintr-un formular salvate într-un fișier
Vom considera un formular (fișierul ex.php) cu două câmpuri de completat: numele și
prenumele.
Fișierul ex.php
<html>
<head>
<title>Exemplul 9.9</title>
</head>
<body>
<p>continutul unei forme salvat intr-un fișier</p>
<form method="post" action="pagina2.php">
Introduceti numele: <input type= "text" name="FName"/><br/><br/>
Introduceti prenumele <input type= "text" name="LName"/> <br/>
<br/>
<input type="hidden" name="DateTime" value="<?php echo
date('g:i a') ?>"/>
<input type="submit" name="SubmitB" value="Expediaza"/>
</form>
</body>
</html>
Fișierul pagina2.php
<?php
if ($_POST['SubmitB'] == "Expediaza"){
$numefisier = "fișier.txt";
$flux = fopen($numefisier, "a+");
$continut= $_POST['FName'] . "," . $_POST['LName'] . "," .
$_POST['DateTime'] ."\n";
fwrite($flux,$continut);
fclose($flux);
echo "datele din forma au fost cu succes salvate <br>";
echo "<a href='ex.php'> o noua inregistrare </a><br>";
echo "<a href='exit.php'>iesire</a>";
}
?>
Fișierul exit.php
<?php
exit();
?>
Câmpul hidden din ex.php conține timpul la care formularul a fost creat, obținut prin apelul
funcției date().
Fluxul din pagina2.php a fost creat pentru adăugare, iar legăturile din josul paginii permit o
nouă introducere sau părăsirea aplicației.
9.7Încărcarea fișierelor
În cadrul aplicațiilor web dinamice este uneori nevoie să permitem utilizatorilor să încarce
fișiere de pe calculatoarele personale pe serverul Web. Vom analiza problema încărcării de
fișiere pe un server web prin prisma interfeței pe care trebuie să o aibă clientul pentru
încărcare și a operațiilor pe care acesta le poate face după ce a încărcat fișierul pe server.
Cea mai simplă interfață de realizat în browser-ul clientului este formularul predefinit HTML
(Exemplul 9.10).
Exemplul 9.10: Formular HTML pentru încărcarea fișierelor
<form enctype="multipart/form-data" action="upload.php" method="post">
Selecteaza fisierul: <input type= "file" name="uploadFile"><br>
<input name="SubmitB" type="submit" value="Incarca">
</form>
Metoda folosită pentru expedierea formularului, în acest caz, este obligatoriu POST și atributul
enctype, care specifică metoda de criptare, trebuie să fie obligatoriu setat la valoarea
multipart/form-data . Atributul enctype este folosit în cazul unui formular pentru a
specifica modalitatea de codificare a datelor ce vor fi transmise server-ului. În mod predefinit
valoarea acestuia este application/x-www-form-urlencoded , care, însă, nu este potrivită
pentru transmiterea cantităților mari de date binare sau date text non-ASCII.
Unul dintre tag-urile input, din Exemplul 9.10, are atributul type setat la valoarea file.
Acesta va introduce în pagina web un câmp de text needitabil și un buton etichetat Browse….
Butonul permite deschiderea unei ferestre de selectare ( File Upload) a fișierului ce urmează
a fi încărcat pe server. După acționarea butonului Open din această fereastră, numele fișierului
și calea completă vor fi introduse în zona de text needitabil. Acționarea butonului Incarca,
din pagină va încheia acțiunea elementară de copiere a fișierului pe server.
În mod predefinit fișierul este încărcat în locul stabilit de directiva upload_tmp_dir din
php.ini, în principiu într-un director temporar.
După ce fișierul a fost încărcat, în locația stabilită de pe server, apelăm la o aplicație PHP care
să-l gestioneze. În PHP există variabila superglobală de tip array, $_FILES, care conține toate
informațiile disponibile despre fișierul încărcat din formularul HTML.
În urma încărcării fișierului din Exemplul 9.10, informațiile se găsesc în array-ul atașat
elementului $_FILES['uploadFile'] , cheie a elementului ce a fost stabilită de atributul
name al tag-ului input ce are type="file". Elementele acestui array au următoarea
semnificație:
$_FILES['uploadFile']['tmp_name'] a cărui valoare reprezintă directorul de pe
server-ul web unde fișierele sunt stocate temporar. În mod predefinit acesta este
directorul tmp din configurația XAMPP;
$_FILES['UploadFile']['name'] a cărui valoare reprezintă numele original al
fișierului, așa cum era pe calculatorul clientului;
$_FILES['UploadFile']['size'] a cărui valoare reprezintă dimensiunea fișierului
în octeți;
$_FILES['UploadFile']['type'] a cărui valoare reprezintă tipul MIME al
fișierului. Chiar dacă browser-ul oferă această informație ea nu este în mod obligatoriu
certă.
$_FILES['UploadFile']['error'] a cărui valoare reprezintă eroarea produsă în
timpul încărcării fișierului. Valorile posibile sunt:
oUPLOAD_ERR_OK sau 0 reprezintă încărcare cu success;
oUPLOAD_ERR_INI_SIZE sau 1, fișierul depășește dimensiunea maximă pentru
încărcare, dimensiune stabilită de directiva upload_max_filesize din
php.ini, care are valoarea predefinită 64 MB;
oUPLOAD_ERR_FORM_SIZE sau 2, fișierul depășește dimensiunea maximă pentru
încărcare stabilită prin valoarea câmpului hidden din formular, denumit
MAX_FILE_SIZE, astfel:
<input type="hidden" name="MAX_FILE_SIZE" value="30000" />
Nu este obligatoriu să stabilim explicit această dimensiune.
oUPLOAD_ERR_PARTIAL sau 3, încărcarea parțială a fișierului;
oUPLOAD_ERR_NO_FILE sau 4, nici un fișier încărcat.
Fișierele încărcate pe server în locația temporară vor fi șterse automat după expirarea cererii,
dacă nu au fost redenumite sau mutate.
Funcția oferită de PHP pentru mutarea unui fișier încărcat pe server este:
move_uploaded_file(nume_fișier_sursa, nume_fișier_destinatie)
unde cele două nume reprezintă numele extern al fișierelor. Dacă fișierul destinație există
deja, acesta va fi șters. În caz de insucces returnează FALSE.
Exemplul 9.11: Mutarea unui fișier încărcat pe server prin move_uploaded_file()
Fisierul upload.php
<?php
if ($_POST[SubmitB] == "Incarca"){
move_uploaded_file($_FILES['uploadFile'] ['tmp_name'],
$_FILES['uploadFile']['name']);
echo "Fisierul a fost incarcat.";
}
?>
Exemplul 9.11 este continuarea Exemplului 9.10 conținând prelucrări ale fișierului după
încărcare. În mod concret am mutat fișierul din locația temporară în directorul proiectului,
fișierul încărcat fiind redenumit cu numele original de pe calculatorul clientului.
O altă funcție frecvent utilizată în gestionarea fișierelor încărcate pe server este:
is_uploaded_file(nume_fișier)
care determină dacă un fișier a fost cu succes încărcat pe server dintr-un formular. Returnează
TRUE în caz de succes și FALSE, altfel. nume_fișier este numele temporar al fișierului de pe
server, obținut prin $_FILES['uploadFile']['tmp_name'] .
Observația 9.2: PHP permite și încărcarea mai multor fișiere de pe calculatorul client pe server,
din același formular. Metoda optimă este de a crea a un array de câmpuri de selectare
(Exemplul 9.12).
Exemplul 9.12: Încărcarea simultană a mai multor fișiere
<html>
<head>
<title>Exemplul 9.12</title>
</head>
<body>
<form action="upload.php" method="post" enctype="multipart/form-
data">
<p>alegeti fisierele de incarcat:<br>
<input type="file" name="fișiere[]" /><br>
<input type="file" name="fișiere[]" /><br>
<input type="file" name="fișiere[]" /><br>
<input type="submit" value="Incarca" />
</p>
</form>
</body>
</html>
Fișierul upload.php
<?php
foreach ($_FILES["fișiere"]["error"] as $key => $error) {
if ($error == UPLOAD_ERR_OK) {
$tmp_name = $_FILES["fișiere"]["tmp_name"][$key];
$name = $_FILES["fișiere"]["name"][$key];
move_uploaded_file($tmp_name, "data/$name");
}
}
?>
În formular nu apar mari deosebiri față de Exemplul 9.11, doar numele câmpurilor este identic
și postfixat de „[]” (perechi de paranteze drepte). În upload.php se observă că indicele ce
specifică fiecare fișier în parte este ultimul în șirul celor trei indici asociați variabilei
superglobale $_FILE.
Observația 9.3: Următoarele directive din php.ini pot influența încărcarea fișierelor pe server
utilizând formularul de încărcare: file_uploads, upload_max_filesize , upload_tmp_dir,
post_max_size și max_input_time.
9.8Rezumat
În acest capitol am studiat modul în care PHP poate interacționa cu fișiere externe aplicației.
În funcție de modul în care a fost deschis fluxul atașat unui fișier extern putem crea, adăuga
sau citi dintr-un fișier. De asemenea, PHP pune la dispoziție o serie de funcții predefinite
pentru copierea, ștergerea sau testarea unui fișier. Putem lucra cu pointerul atașat fișierului,
modificându-i poziția în funcție de anumite cerințe. Ca aplicație, am studiat modul în care
putem stoca datele dintr-un formular într-un fișier extern. Fișierele externe pot fi încărcate pe
server-ul PHP folosind tag-uri speciale HTML. După ce fișierele au fost încărcate putem să le
testăm atributele sau putem să le salvăm în locații diferite.
Capitolul 10:Clase și obiecte în PHP5
În acest capitol vom aborda următoarele subiecte:
Concepte de bază privind sintaxa unei clase în PHP, constructor, destructor,
modificatori de vizibilitate, membri statici, atribute cu valori constante
Moștenirea, sintaxa privind moștenirea în PHP. Modificatorul protected,
modificatorul final
Clase abstracte
Interfețe
Metode cu parametri de tip impus
Funcții “magice”
Obiecte și referințe
Clonarea obiectelor
Compararea obiectelor
Acest capitol își propune detalierea implementării în PHP a programării orientate pe obiect
(POO) și a proprietăților sale. Plecăm de la ipoteza că cei care citesc acest capitol au noțiunile
teoretice relativ la POO bine însușite.
10.1Concepte de bază
O clasă, în general, descrie o colecție încapsulată de membri împărțiți în: variabile numite și
atribute, care dau starea unui obiect obținut prin instanțierea clasei, și funcții numite și
metode, care manipulează starea obiectului.
Din punct de vedere sintactic o clasă se definește în PHP astfel:
<?php
class NumeClasa {
// proprietetile si metodele clasei
}
?>
unde:
class este cuvânt rezervat PHP, ce precede în mod obligatoriu definirea unei clase;
NumeClasa este un identificator. Conform convenției de nume PHP, identificatorul
pentru numele clasei va începe cu o literă mare, iar dacă este format din mai multe
cuvinte, fiecare cuvânt va începe cu literă mare.
Perechea de acolade este obligatorie.
În PHP, o clasă poate avea oricâte atribute, de aproape orice tip. Ca funcții, clasa are metodele
clasice pentru construirea sau distrugerea unui obiect, adică constructor respectiv destructor,
metode de control sau modificare a stării, adică getter-i respectiv setter-i, precum și alte
metode definite de utilizator.
PHP permite valori predefinite pentru atributele clase. Aceste valori pot fi doar constante, nu
valori returnate de o funcție, valorile unei variabile etc.
Odată clasa definită vom putea crea obiecte. Obiectele sunt instanțe ale clasei. Într-o instanță
atributele clasei au valori concrete. Crearea unui obiect se face prin cuvântul rezervat new care
determină apelul constructorului clasei. Obiectul creat va putea fi atribuit apoi unei variabile.
După ce un obiect a fost construit și atribuit unei variabile, accesul la membrii săi se face prin
operatorul de selecție -> (succesiunea de semne minus, mai mare) sub forma $obiect ->
membru. Accesul direct la membrul unei clasei se face doar dacă modificatorul de vizibilitate
permite aceasta (vezi paragraful referitor la modificatori de vizibilitate).
Pentru a referi obiectul curent (spre ex. din interiorul clasei) putem folosi pseudovariabila
$this. Prin $this avem acces la oricare dintre membrii clasei prin constructia $this ->
membru.
44Constructorul
În PHP fiecare clasă trebuie sa aibă definit un constructor. PHP furnizează constructorul
implicit, dar de îndată ce s-a definit un constructor de către programator, cel implicit nu mai
poate fi apelat. Pentru că PHP nu permite supraîncărcarea funcțiilor, o clasă are un singur
constructor. Definirea constructorului de către programator se face prin următoarea sintaxă:
function __construct(lista_atribute){
//cod de definire a constructorului
}
unde:
function este cuvânt rezervat PHP necesar deoarece constructorul este o funcție;
__construct, numele predefinit al constructorului (Atenție! Cuvântul construct este
precedat de două underscore-uri);
între paranteze rotunde avem lista valorilor pentru atributele ce se inițializează sau se
definesc, despărțite prin virgulă, listă ce poate fi vidă.
Această sintaxă a constructorului este valabilă numai în PHP 5.
45Destructorul
În majoritatea limbajelor de programare rolul fundamental al destructorului este eliberarea
spațiului de memorie ocupat de un obiect. În PHP rolul destructorului se rezumă mai ales la
închideri de conexiuni cu diverse servere, închideri de fluxuri, etc. Destructorul este apelat
implicit atunci când toate referințele către un anumit obiect dispar, dar poate fi apelat și
explicit.
Sintaxa unui destructor în PHP este următoarea:
function __destruct(){
//cod de definire a destructorului
}
Destructorul nu admite parametri.
46Modificatori de vizibilitate
În PHP există trei modificatori de vizibilitate pentru membrii unei clase: public, private și
protected.
Dacă modificatorul de vizibilitate este public, membrul este accesibil din orice obiect
instanță a clasei sau a oricărei clase derivate (vezi paragraful referitor la moștenire).
Dacă modificatorul de vizibilitate este private, atunci membrul este accesibil doar în clasa
curentă. Obiectele, instanțe ale clasei, sau clasele derivate vor accesa membrul private doar
prin intermediul altor membri (vezi paragraful referitor la moștenire).
Despre modificatorul protected vom discuta în paragraful referitor la moștenire.
Observația 10.1: Pentru atributele unei clase trebuie specificat în mod obligatoriu un
modificator de vizibilitate. În cazul metodelor se consideră implicit modificatorul public.
Exemplul 10.1: Crearea unei clase, instanțierea clasei și accesul la membrii clasei
Fișierul: clasa.php
<?php
class Clasa{
public $var=6;
function __construct($v){
$this->var=$v;
}
}
?>
Fișierul: test.php
<?php
include "clasa.php";
$inst=new Clasa( 9);
echo $inst->var;
?>
Regula de stil, atunci când se construiește o clasă, este ca ea sa fie salvată într-un fișier
propriu, de obicei având numele clasei. Așadar, în Exemplul 10.1, am definit clasa Clasa într-
un fișier cu numele clasa.php. În definiția clasei avem ca atribut pe $var inițializat cu
valoarea 6. Dacă nu am fi definit constructorul, în mod predefinit, la crearea unui obiect, s-ar
fi folosit un constructor, fără parametri, care ar fi păstrat valoarea predefinită a atributului. În
constructorul definit de noi modificăm valoarea predefinită la o nouă valoare, dată de
parametrul constructorului. În acest moment nu am mai putea folosi constructorul fără
parametri decât dacă am crea un constructor cu parametri cu valori predefinite.
function __construct($v=11){
…
}
În fișierul test.php am inclus mai întâi fișierul ce conține clasa, am creat obiectul $inst și
am tipărit valoarea parametrului. Acest lucru a fost posibil pentru că am avut drepturi date de
modificatorul de vizibilitate public.
În Exemplul 10.1 a trebuit să includem explicit în fișierul test.php fișierul clasa.php pentru
că acesta conține clasa invocată, Clasa, la instanțierea obiectului $inst. Acest mod de lucru
poate fi uneori deranjant, spre exemplu atunci când avem multe clase de inclus sau numele
claselor invocate este dinamic.
Începând cu PHP 5 avem la dispoziție funcția autoload() ce trebuie supradefinită și care este
apelată automat atunci când invocăm o clasă care nu a fost inclusă încă.
Putem modifica fișierul test.php din Exemplul 10.1 astfel încât, în loc să apelăm funcția
include()definim funcția autoload() care rezolvă problema includerii pentru toate clasele
necesare.
Fișierul: test.php
<?php
function __autoload($class_name) {
require_once $class_name.'.php';
}
$f=7;
$inst=new Clasa($f);
echo $inst->var;
?>
Trebuie remarcat faptul că folosirea acestei funcții determină anumite particularități:
fișierul care conține clasa se află în același director cu cel care o invocă. Altfel, ar
trebuie stabilită calea către acel fișier;
numele clasei este identic cu numele fișierului (nu neapărat case-sensitive);
extensia este adaugată prin concatenare.
47Membri statici
Declararea membrilor unei clase drept static oferă acces direct la ei ținând cont doar de
modificatorul de vizibilitate. Acces direct înseamnă fără a crea o instanță a clasei, ci direct
prin numele clasei ( Exemplul 10.2).
Declararea statică se face prin folosirea cuvântului rezervat static.
Atributele statice au o valoare unică pentru toate instanțele clasei. Celelalte atribute sunt
distincte fiecărei clase, iar valorile lor sunt inițializate de către constructor.
În definirea metodelor statice trebuie să folosim doar atribute sau expresii care nu au de-a face
cu starea obiectului. Spre exemplu, folosirea pseudovariabilei $this este interzisă într-o
funcție statică. Constructorul și destructorul nu pot fi statici.
Observația 10.2: Pentru metode nu este obligatorie calificarea prin static. Putem apela metoda
ca pe una statică, dacă în definiția ei nu folosim starea obiectului.
Din punct de vedere sintactic, accesul la un membru static se face prin operatorul domeniu,
“::” (pereche de două puncte), și nu prin operatorul de selectie, “ ->”. De asemenea,
operatorul se aplică numelui clasei și nu vreunui obiect, instanță a clasei ( Exemplul 10.2).
PHP pune la dispoziție două nume generice de clase și anume clasa curentă, self, și clasa
părinte, parent. Clasa curentă este folosită pentru a invoca membrii statici în contextul clasei.
Despre clasa părinte vom discuta în paragraful referitor la moștenire.
Exemplul 10.2: Membri statici
Fișierul: clasa.php
<?php
class Clasa{
public static $var= 6;
private $a=3;
function mesaj(){
echo "salut ".self::$var."!<br>";
}
function x(){
echo "$this->a";
}
}
?>
Fișierul: test.php
<?php
function __autoload($class_name) {
require_once $class_name.'.php';
}
$ob=new Clasa();
echo Clasa::$var."<br>";
echo Clasa::mesaj();
$ob->x();
?>
În clasa Clasa am declarat variabila statică, publică $var și cea nestatică (specifică fiecărui
obiect) $a. Funcția mesaj(), deși nedeclarată în mod explicit, este considerată statică (vezi
apelul din test.php). Așa cum este declarată ea ar putea fi invocată și prin operatorul clasic
->. Folosirea numelui generic self, în clasa.php, este necesar pentru a specifica despre ce
variabilă $var este vorba, cea a clasei, nu cea locală a funcției.
10.2Atribute cu valori constante
PHP permite declararea atributelor cu valori constante. Din punct de vedere sintactic, un
atribut constant este prefixat de cuvântul rezervat const, iar identificatorul nu mai este
prefixat de semnul “ $”. Valoarea atributului trebuie să fie dată de o constantă, nu de o
expresie sau de nu un apel al unei funcții. Fără alte precizari o constantă este un membru
public și static (Exemplul 10.3). Valorile acestui membru nu pot fi modificate.
Exemplul 10.3: Atributele constante ale unei clase
Fișierul: clasa.php
<?php
class Clasa{
const con=6;
static function mesaj(){
echo "salut ".self::con."!<br>";
}
}
?>
Fișierul: test.php
<?php
function __autoload($class_name) {
require_once $class_name.'.php';
}
echo Clasa::con."<br>";
echo Clasa::mesaj();
?>
10.3Crearea obiectelor din clasa predefinită stdClass
În PHP putem crea un obiect pornind de la un tip oarecare. Astfel, apelând la conversia
explicită (object) creăm un obiect, instanță a clasei predefinite PHP stdClass, care are ca
valori ale atributelor valorile variabilei sau constantei de tipul considerat.
Dacă membrul drept este altul decât array, atributul clasei se va numi scalar, altfel atributele
se vor numi după numele cheii elementelor. De aceea, nu se recomandă folosirea indecșilor
predefiniți ai array-ului pentru că membrii nu vor mai putea fi apoi accesați în cadrul
obiectului.
Exemplul 10.4: Instanță a clasei stdClass
<?php
$a=(object)array("i"=> 1,2);
echo $a->i;
echo $a->{0};
?>
Cel de-al doilea atribut nu va putea fi accesat din cauza lipsei cheii.
10.4Parcurgerea atributelor unei clase cu foreach
Putem folosi instrucțiunea foreach și pentru a afișa atributele unei clase. Vom obține pentru
atributele vizibile numele și valoarea atributului. Sintaxa generală este:
foreach(obiect as nume => valoare){
//codul instructiunii
}
unde, obiect este o instanță a unei clase. Dacă folosim foreach în definiția clasei curente
atunci obiect este $this.
10.5Moștenirea
Unul dintre principiile esențiale ale programării orientate pe obiect este refolosirea codului,
iar o modalitate de implementare a acestui principiu este prin moștenire. Și în PHP putem
extinde o clasă inițială (numită și clasă de bază sau părinte) prin crearea unei noi clase
(numită și clasă derivată) care să moștenească toate proprietățile și metodele clasei parinte.
În PHP nu este implementat conceptul moștenirii multiple (ca în C++, spre exemplu). Așadar,
o clasă poate moșteni doar o clasă de bază, dar o clasă de bază poate fi moștenită de oricâte
clase derivate. Aceasta se numeste moștenire simplă. Prin procesul de moștenire putem obține
ierarhii de clase.
În clasa derivată putem adăuga noi atribute, noi metode, putem redefini metodele din clasa de
bază sau le putem utiliza nemodificat. Pentru a referi membrii din clasa de bază putem folosi
clasa generică parent și operatorul domeniu, “ ::”.
Din punct de vedere sintactic moștenirea este implementată prin cuvântul rezervat extends
(class ClasaDerivata extends ClasaBaza ).
48Constructorul clasei derivate
Dacă clasa de bază definește propriul constructor, atunci acesta nu este apelat în mod implicit
în clasa derivată. Clasa derivată trebuie să-l apeleze explicit prin parent::__construct() .
Constructorul clasei de bază este responsabil de inițializarea atributelor din clasa de bază, iar
cel din clasa derivată de atributele respective.
49Destructorul clasei derivate
Ca și în cazul constructorului și pentru destructor trebuie făcut un apel explicit dacă în clasa
de bază s-a modificat destructorul predefinit ( parent::__destruct() ).
Exemplul 10.5: Clase derivate
Fișierul: clasabaza.php
<?php
class ClasaBaza{
private $var;
function __construct($a){
$this->var=$a;
}
function afisare(){
echo $this->var."<br>";
}
}
?>
Fișierul: clasaderivata.php
<?php
class ClasaDerivata extends ClasaBaza{
private $v;
function __construct($a, $b){
parent::__construct($a);
$this->v=$b;
}
function afisare(){
parent::afisare();
echo $this->v."<br>";
}
}
?>
Fișierul: test.php
<?php
function __autoload($class_name) {
require_once $class_name.'.php';
}
$obBaza=new ClasaBaza( 55);
$obDerivat=new ClasaDerivata( 33,6);
$obBaza->afisare();
$obDerivat->afisare();
?>
Am organizat aplicația în trei fișiere: clasabaza.php și clasaderivata.php ce conțin
definițiile celor două clase, iar test.php fișierul ce crează obiecte și le apelează. În clasa
derivată am mai adăugat un atribut, $v, pe care îl inițializăm în constructor. Constructorul
clasei derivate are doi parametri. Primul parametru va fi folosit pentru apelul constructorului
din clasa de bază, iar cel de-al doilea în definiția constructorului curent. Metoda afisare()
din clasa de bază a fost redefinită în clasa derivată. Redefinirea nu a fost totală, adică am
adăugat și o parte din definiția din clasa de bază, prin apelul parent::afisare(). După cum
se observă în clasa de test, afișarea este dependentă de obiectul care o conține. Pentru obiectul
instanță a clasei de bază se apelează metoda din clasa de bază, iar pentru cel din clasa derivată
metoda respectivă, redefinită.
50Modificatorul de vizibilitate protected
În Exemplul 10.5, fișierul clasaderivata.php, nu avem acces direct la atributul $var, pentru
că acesta este private în clasa de bază. PHP, ca și alte limbaje, permite o relaxare a
caracterului privat al atributelor, în interiorul unei ierarhii de clase. Astfel, putem avea acces
direct la atributul $var din interiorul tuturor claselor derivate din ClasaBaza dacă schimbăm
modificatorul de vizibilitate din private în protected. Din exteriorul ierarrhiei avem acces
private la membrii declarați protected.
10.6Clase și metode finale
PHP poate inhiba caracterul de clasă de bază. Astfel, o clasă declarată final nu mai poate fi
clasă de bază în procesul moștenirii. Încercarea de extindere a unei clase finale este
generatoare de erori fatale.
În același mod și metodele pot fi finale. Aceasta înseamnă că, în ierarhia de clase, metoda
declarată final nu mai poate fi redefinită în clasele derivate. Dacă în Exemplul 10.5, am folosi
în clasa de bază:
final function afisare(){
echo $this->var."<br>";
}
iar restul aplicației ar ramâne nemodificat, atunci am genera o eroare fatală de redefinire a
unei metode finale.
10.7Clase abstracte
Există situații în care nu putem defini întreaga funcționalitate a unei clase (nu avem încă
suficiente informații). Totuși, anumite metode trebuie declarate pentru păstrarea unei
consistențe a clasei. Metodele nu vor fi, însă, definite decât în clasele derivate, acolo unde
vom avea informații suficiente.
O metodă care într-o clasă este doar declarată, nu și definită, este o metodă abstractă și acest
lucru trebuie pus în evidență prin cuvântul rezervat abstract ce prefixează semnătura
funcției. Constructorii și destructorii pot fi abstracți.
O clasă care are cel puțin o metodă abstractă devine la rândul său abstractă și acest lucru
trebuie pus în evidență prin cuvântul rezervat abstract. O clasă abstractă nu poate fi
instanțiată. Prin derivare, clasei abstracte i se pot furniza definiții ale funcțiilor abstracte. Dacă
nu se definesc toate funcțiile abstracte, clasa derivată va deveni abstractă și va trebui calificată
abstract.
În momentul definirii metodei abstracte în clasa derivată, aceasta trebuie să aibă identic
aceeași semnătură ca la declarare. PHP permite un anumit rabat la accesibilitate. Astfel,
modificatorul de vizibilitate poate fi mai permisiv în clasa derivată decât în clasa abstractă
(spre ex. poate fi public în loc de protected, dar nu poate fi private în loc de protected).
Exemplul 10.6: Clasa abstractă
Fișierul: clasabaza.php
<?php
abstract class ClasaBaza{
protected $var;
function __construct($a){
$this->var=$a;
}
abstract function afisare();
}
?>
Fișierul: clasaderivata.php
<?php
class ClasaDerivata extends ClasaBaza{
private $v;
function __construct($a, $b){
parent::__construct($a);
$this->v=$b;
}
function afisare(){
echo $this->var." ".$this->v."<br>";
}
}
?>
Fișierul: test.php
<?php
function __autoload($class_name) {
require_once $class_name.'.php';
}
$obDerivat=new ClasaDerivata( 33,6);
$obDerivat->afisare();
?>
În clasabaza.php metoda afisare() este abstractă (cuvântul rezervat abstract și lipsa
oricărui detaliu de definire). Aceeași semnătură este folosită la definire în
clasaderivata.php . În clasaderivata.php avem acces la atributul $val prin
pseudovariabila $this pentru că a fost declarat protected în clasabaza.php. Obiectul din
test.php este instanță a clasei derivate, ce implementează metoda afisare().
10.8Interfețe
Interfețele sunt cele mai abstracte clase cu putință. O interfață nu conține niciun detaliu de
implementare, ele sunt practic o colecție de metode abstracte și publice sau atribute constante
și publice.
Practic, interfața impune ce metode trebuie să implementeze o clasă. Clasa care nu
implementează toate metodele devine abstractă și trebuie marcată prin cuvântul rezervat
abstract.
O interfață se definește asemănător cu o clasă, singura modificare este că în loc de class se
folosește interface.
interface Interfata{
// metode statice și atribute constante
}
O clasă poate implementa oricâte interfețe, separate prin virgulă. Implementarea se face
asemănător extinderii, doar că în loc de extends se folosește implements.
Exemplul 10.7: Definirea și implementarea unei interfețe
Fișierul: interfata.php
<?php
interface Interfata{
const atr=8;
function afisare();
}
?>
Fișierul: clasaderivata.php
<?php
class ClasaDerivata implements Interfata{
private $v;
function __construct($a){
$this->v=$a;
}
function afisare(){
echo Interfata::atr." ".$this->v."<br>";
}
}
?>
Fișierul: test.php
<?php
function __autoload($class_name) {
require_once $class_name.'.php';
}
$obDerivat=new ClasaDerivata( 33);
$obDerivat->afisare();
?>
Observația 10.3: Interfețele pot fi extinse de către alte interfețe, în mod asemănător claselor,
doar că aici este posibilă extinderea multiplă ( interface Interfata1 extends
Interfata2, Interfata3 ). Atât în cadrul extinderii de interfețe, cât și în cadrul
implementării mai multor interfețe, trebuie avut grijă la numele metodelor. O interfață nu
poate extinde alte interfețe dacă au metode cu nume identic. O clasă nu poate implementa
interfețe în care se regăsesc metode cu același nume.
10.9Operatorul instanceof
Este un operator care testează dacă un obiect este instanță a unei clase. Sintaxa generală este:
obiect instanceof nume_clasa
unde:
obiect a fost instanțiat prin operatorul new;
nume_clasa este numele unei clase, clase abstracte sau interfețe.
Rezultatul expresiei este TRUE sau FALSE.
Exemplul 10.8: Rezultate ale testării instanței cu instanceof
Așa după cum se cunoaște, o clasă de bază este compatibilă cu orice clasă derivată în ierarhia
sa de clase. Același lucru este valabil și pentru interfețe. Intr-o ierarhie de clase, clasele surori
nu sunt compatibile. Asadar, în Exemplul 10.7:
$obDerivat instanceof ClasaDerivata //TRUE
$obDerivat instanceof Interfata //TRUE
În Exemplul 10.5:
$obDerivat instanceof ClasaBaza //TRUE
$obBaza instanceof ClasaDerivata //FALSE
10.10Funcții cu argumente de tip impus
Până în acest moment argumentelor funcțiilor nu li se impunea, în semnătură, un tip anume.
Începând cu PHP 5 putem declara argumente cărora să le impunem un anumit tip, dintre cele
acceptate, adică class sau array. În cazul obiectelor se va specifica numele clasei (inclusiv
un nume generic), iar în cazul tipurilor array se va folosi cuvântul rezervat array, fără alte
specificații. Putem, în plus, să precizăm dacă argumentul poate primi și valoarea NULL.
Exemplul 10.9: Funcții cu argumente cu tip
Fișierul: comparare.php
<?php
interface Comparare{
function compara(self $s);
}
?>
Fișierul: clasa.php
<?php
class Clasa implements Comparare{
public $v;
public function compara(self $a){
if($this->v<$a->v)
return -1;
else if($this->v==$a->v)
return 0;
else return 1;
}
function __construct($a){
$this->v=$a;
}
}
?>
Fișierul: test.php
<?php
function __autoload($class_name) {
require_once $class_name.'.php';
}
function maxim(Comparare $a, Comparare $b){
if($a->compara($b)< 0)
return $b;
else return $a;
}
$x= new Clasa(7);
$y= new Clasa(4);
$max=maxim($x,$y);
echo "maximul este: ".$max->v;
?>
Interfața Comparare precizează semnătura unei metode, compara(), ce are un argument de tip
interfața curentă și care, prin definire, va furniza o metodă de comparare a două obiecte ce
implementează interfața.
Funcția compara(), așa cum este definită în Clasa, reprezintă practic funcția semn. De
remarcat două aspecte. Primul este folosirea numelui generic self, ceea ce conduce la
nespecificarea explicită a conversiei între Comparare și Clasa. Al doilea este semnătura
funcției ce se defineste și care este identică cu cea din interfață.
În fișierul test.php, am definit funcția de aflare a maximului, funcție ce are două argumente
de tip Comparare. Doar clasele ce implementează interfața Comparare pot fi argumente ale
acestei funcții. Prin aceasta ne asigurăm că obiectele cărora le dorim aflarea maximului se pot
compara. În plus, dacă vrem să aflăm că cele două argumente, $a și $b, sunt instanțe ale
aceleiași clase putem folosi operatorul instanceof.
Despre compararea obiectelor vom mai discuta în secțiunile următoare.
10.11Funcții “magice”
PHP, începând cu versiunea 5, posedă o serie de funcții care se autoapelează în anumite
condiții, cunoscute și sub numele de funcții “magice”. Numele lor este prefixat de __ (două
underscore-uri). Până în acest moment am studiat trei dintre ele __construct(),
__destruct() și __autoload(). Vom mai prezenta, în continuare, câteva dintre cele mai
frecvent utilizate.
51Getter-i și setter-i
Așa cum am afirmat și în secțiunile precedente starea unui obiect este recomandat a fi ascunsă
de accesul neautorizat (atributele sunt declarate private). Pentru a putea manipula starea
unui obiect, programatorii definesc funcții pentru modificarea stării (setter-i) respectiv pentru
accesarea acesteia (getter-i) și apoi le apelează în afara definiției clasei, prin intermediul unei
instanțe.
PHP rezolvă problema mult mai elegant pe baza unor funcții care se autoapelează:
pentru setare avem următoarea sintaxă generală:
function __set(nume, valoare){
//codul pentru setarea valorii unui atribut private
}
unde, nume este numele atributului a cărui valoare dorim să o setăm și care este
inaccesibil din clasa ce definește funcția __set(), respectiv valoare este valoarea
nouă a atributului;
pentru acces avem următoarea sintaxă generală:
function __get(nume){
//codul pentru accesul la valorea unui atribut private
//trebuie sa contina return
}
unde, nume este numele atributului a cărui valoare dorim să o accesăm și care este
inaccesibil din clasa ce definește funcția __get(). Rezultatul returnat este valoarea
atributului.
Exemplul 10.10: Getter-i și setter-i
Fișierul: clasa.php
<?php
class Clasa{
private $v;
private $sir=array();
function __construct($a){
$this->v=$a;
}
function __set($nume,$valoare){
if(is_array($this->nume))
foreach($valoare as $cheie=>$val)
$this->nume[$cheie]=$val;
else
$this->nume=$valoare;
}
function __get($nume){
return $this->nume;
}
}
?>
Fișierul: test.php
<?php
function __autoload($class_name) {
require_once $class_name.'.php';
}
$ob=new Clasa(33);
$ob->sir=array(7=>7,"indice"=>8);
var_dump($ob->sir);
?>
În clasa Clasa avem două atribute private. $v a fost inițializat prin constructor, iar $sir este
un array gol, creat în mod predefinit. În mod clasic nu avem acces la aceste atribute prin
construcții de felul: $ob->v, unde $ob este o instanță a clasei Clasa. De obicei accesul se face
printr-o construcție: $ob->getV(), unde getV() este o funcție publică ce returnează valoarea
lui $v. În Clasa am definit funcțiile __set() și __get().
Funcția __set()din Exemplul 10.10 construiește o modalitate de atribuire de valori unor
atribute ale clasei Clasa. Modul de lucru este următorul: mai întâi testează dacă numele
atributului este asociat unui tip array (prin funcția predefinită PHP is_array()) și în caz
afirmativ parcurge cel de-al doilea parametru al funcției printr-o instrucțiune foreach
modificând fiecare element din $sir cu valorile date de $val. Altfel, este vorba de un tip
primitiv si atribuirea are loc direct.
Așa după cum se observă în fișierul test.php, după ce am definit cele două funcții accesul
este direct la atributele private. Funcția predefinită PHP var_dump() afișează proprietățile
variabilei parametru.
52__toString()
Frecvent avem nevoie să afișăm anumite caracteristici ale clasei (starea ei sau o parte a
acesteia). În POO, se definește o funcție toString() care modelează conversia clasei la un
string. Această conversie este folosită la afișări de tipul echo, print, etc.
Și pentru această operație PHP pune la dispoziție o funcție “magică” cu următoarea sintaxă:
function __toString(){
//cod de conversie la string
}
În Exemplul 10.9 putem completa definiția clasei Clasa cu:
function __toString(){
return "valoarea: $this->v";
}
iar în fișierul test.php putem testa autoapelul acesteia prin:
echo $ob;
53__isset()
Este invocată de funcțiile predefinite PHP isset() sau empty() pentru atribute inaccesibile.
Sintaxa generală este:
function __isset(nume){
//cod de testare
}
54__unset()
Este invocată de funcția predefinită PHP unset() pentru atribute inaccesibile. Sintaxa
generală este:
function __unset(nume){
//cod de testare
}
Vom completa definiția clasei Clasa din Exemplul 10.10 cu aceste funcții.
function __isset($nume) {
return isset($this->nume);
}
function __unset($nume) {
unset($this->nume);
}
Iar în fișierul test.php testăm autoapelul lor:
var_dump(isset($ob->v));
unset($ob->v);
var_dump(isset($ob->v));
55__call()
PHP extinde noțiunea de getter pentru funcții. Astfel, pune la dispoziție funcția _call() care
va apela o funcție inaccesibilă din contextul curent. Sintaxa generală este:
function __call(nume, argumente){
//codul pentru apelul unei funcții inaccesibile
}
unde, nume este numele metodei pe care dorim să o apelăm și care este inaccesibilă din clasa
ce definește funcția __call(), respectiv argumente este un array în care sunt păstrate
argumentele funcției apelate.
În Exemplul 10.10 adăugăm o funcție private care returnează valoarea argumentului:
private function funcție($a){
return $a;
}
Pentru a putea apela direct această funcție definim, în aceeași clasă, metoda __call()
function __call($nume, $argumente) {
return $this->$nume(implode(', ', $argumente));
}
În definiția anterioară am apelat funcția predefinită implode() ce returnează un string format
din elementele unui array, transmis ca al doilea argument. Primul argument al funcției
implode() este separatorul din string a elementelor array-ului.
În fișierul test.php putem folosi următorul apel:
echo "<br> rezultatul funcției private este: ".$ob->funcție( 7);
10.12Obiecte și referințe
În PHP obiectele sunt transmise ca referințe. Pentru a clarifica situațiile apărute vom comenta
Exemplul 10.11.
Exemplul 10.11: Transmiterea obiectelor ca parametri ai unei funcții
<?php
class B{
public $y;
function __construct($a){
$this->y=$a;
}
}
class A {
public $x;
public $z;
function __construct($a){
$this->x=$a;
$this->z=new B($a);
}
}
$e = new A(3);
function f($obj) {
$obj->x = 2;
$obj->z = new B( 8);
}
f($e);
echo "apel f: ".$e->x." ".$e->z->y."<br>";
function f1($obj) {
$obj=new A(4);
}
f1($e);
echo "apel f1: ".$e->x." ".$e->z->y."<br>";
function f2(&$obj) {
$obj=new A(4);
}
f2($e);
echo "apel f2: ".$e->x." ".$e->z->y."<br>";
?>
Am definit, inițial, o clasă, B, care conține un atribut public (pentru ușurarea accesului), $y,
și un constructor clasic, cu un parametru. Clasa A are 2 atribute, $x și $z, declarate public,
care prin constructor au fost inițializate cu valoarea parametrului respectiv instanțiate cu clasa
B. Am creat apoi o instanță, $e, a clasei A.
Pentru început am definit funcția f(), ce primește ca parametru, la apel, instanța $e. În
această funcție am modificat valoarea primului atribut al lui $e și am construit un nou obiect
pentru cel de-al doilea. Deși nu am transmis explicit parametrul funcției f() ca referință,
totuși modificările se regăsesc în afara definiției (afișarea cu echo). Este un prim exemplu de
transmitere a obiectului ca parametru și recunoașterea sa implicit ca referință.
În funcția f1(), cu același parametru, am modificat valoarea întregii instanțe prin crearea unui
nou obiect. De data aceasta valoarea modificată nu este recunoscută în exteriorul funcției.
Practic, s-a creat un nou identificator de obiect ce nu mai este recunoscut în exterior. Referința
implicită nu se referă la noua instanță.
Pentru a recunoaște noua instanță creată în interiorul funcției am definit funcția f2(), în care
parametrul era explicit tratat ca referință, prin opertorul “ &”.
10.13Clonarea obiectelor
Prin clonare întelegem copierea unui obiect într-un alt obiect în care atributele au aceleași
valori. Clonarea este diferită de atribuire ( $ob1=$ob2), unde ambele variabile văd același
obiect. În PHP clonarea se face utilizând directiva clone:
$ob_clonat= clone $ob_original;
Problema apare atunci când clonăm atribute obiecte. Practic, în urma clonării vom avea două
obiecte distincte, care au atribute distincte, cu excepția atributelor obiect, care vor fi de fapt
nume distincte ale aceluiași identificator de obiect. Pentru aceasta, PHP pune la dispozitie
funcția autoapelantă __clone(), care gestionează procesul predefinit de clonare și are
următoarea sintaxă:
function __clone(){
//cod ce particularizeaza procesul de clonare implicit al unui obiect
}
O clasă nu e obligatoriu să implementeze funcția __clone() dacă nu dorește un
comportament special la clonare. Funcția __clone() este apelată implicit de directiva clone.
În Exemplul 10.12 vom da câteva particularități ale procesului de clonare.
Exemplul 10.12:
<?php
class Clasa{
public $atr;
public function __construct($x) {
$this->atr = $x;
}
}
class Clona{
public $ob1;
public $at=array( 1,2);
function __clone(){
$this->ob1 = clone $this->ob1;
}
}
$obj = new Clona();
$obj->ob1 = new Clasa( 5);
$obj2 = clone $obj;
echo $obj->ob1->atr."<br>";
var_dump($obj->at);
echo "<br>".$obj2->ob1->atr."<br>";
var_dump($obj2->at);
$obj->ob1->atr++;
$obj->at[0]++;
echo "<br>".$obj->ob1->atr."<br>";
var_dump($obj->at);
echo "<br>".$obj2->ob1->atr."<br>";
var_dump($obj2->at);
?>
Clasa este o clasă cu un atribut public. Clona este o clasă cu două atribute public, în care al
doilea a fost inițializat printr-un șir constant, cu două valori. Am construit apoi obiectul $obj
ca instanță a clasei Clona și în cadrul acestui obiect atributul $obj->ob1 ca instanță a clasei
Clasa. Am clonat $obj în $obj2. Așa cum se observă prin afișare, valorile celor două obiecte
sunt identice. Modificăm apoi valoarea atributului din $obj->ob1, și primul element din șirul
$obj->at. Se observă prin afișare că modificarile din $obj nu afectează valorile din obiectul
clonat $obj2. Aceasta se explică prin autoapelul, la clonare, al metodei __clone()din clasa
Clona. Dacă metoda nu ar fi existat valorile lui $obj->at și $obj2->at ar fi fost distincte,
dar valorile lui $obj->ob1 și $obj2->ob1 ar fi fost comune pentru că ar referi același
identificator de obiect. Metoda __clone() specifică faptul că, în procesul de clonare al clasei
Clona, atributul obiect ob va fi la rândul său clonat, în loc să se creeze doar un alias al său.
10.14Compararea obiectelor
În PHP pentru compararea egalității obiectelor folosim doi operatori:
operatorul de comparatie == (dublu egal). Variabilele obiect sunt egale dacă au
aceleași atribute, aceleași valori ale atributelor și sunt instanțe ale aceleiași clase.
operatorul de identitate === (triplu egal). Variabilele obiect sunt egale dacă și numai
dacă ele referă aceeași instanță a aceleiași clase (sunt practic alias-uri ale aceluiași
obiect).
Exemplul 10.13: Compararea obiectelor
<?php
class A{
}
$a = new A();
$b = new A();
$c = $b;
echo ($a==$b)."<br>"; //TRUE
echo ($a===$b)."<br>";//FALSE
echo ($b===$c)."<br>";//TRUE
?>
10.15Rezumat
În acest capitol am studiat modul în care PHP implementează principalele caracteristici ale
programării orientate pe obiect. Astfel, am discutat despre sintaxa generală a unei clase,
despre funcțiile pe care o clasă ar trebui să le aibe: constructori, destructori, toString(),
comparare, getter-i sau setter-i. PHP prin faptul că nu asociază în momentul declarării unei
variabile un tip, generează unele particularități, în special în ceea ce privește constructorii și
destructorii, particularități pe care le-am discutat pe parcursul acestui capitol. Moștenirea și
problemele moștenirii au fost discutate în următoarele secțiuni. Modificatorii de vizibilitate,
modificatorul final sau clauza static au completat partea cu noțiuni de bază a capitolului.
În continuare, funcțiile magice și comportamentul obiectelor, atunci când sunt parametri de
funcție, au adus în discuție elemente avansate de programare orientată pe obiect în PHP.
Partea finală a capitolului s-a referit la clonarea obiectelor și compararea acestora.
Capitolul 11:Excepții
În acest capitol vom aborda următoarele subiecte:
Definirea excepțiilor și rolul lor într-un program
Procesarea excepțiilor
Clasa Exception
Excepții derivate
Tratarea excepțiilor în mod specific PHP
Excepțiile sunt obiecte ce rețin informație și care sunt transmise în afara secvențelor return.
Excepțiile sunt propagate înapoi prin secvența de funcții apelate până când o anumită metodă
prinde excepția. De fiecare dată când întâlnim o excepție într-o metodă a programului avem
posibilitatea de a recupera pierderile cauzate de aceasta, iar execuția se va încheia fără a afișa
mesajul standard de eroare sau căderea sistemului. Prin tratarea excepțiilor programul devine
mult mai prietenos cu utilizatorul.
11.1Procesarea excepțiilor
Un program PHP poate detecta erori, apoi poate indica sistemului de execuție erorile întâlnite
și poate genera un cod de eroare sau poate lăsa la latitudinea utilizatorului tratarea lor în mod
propriu.
Secvența de cod care ar putea genera o excepție este inclusă într-un bloc try. Fiecare bloc
try trebuie să fie urmat imediat de un bloc catch corespunzător. Așadar, un bloc try poate fi
urmat de unul sau mai multe blocuri catch fiecare tratând clase diferite de excepție.
În mod obișnuit, dacă nu se întâlnește nicio excepție, programul va continua cu instrucțiunea
imediat următoare ultimului bloc catch din secvența try…catch. Dacă s-a întâlnit o
excepție, blocul try nu va mai fi executat din locul în care s-a generat excepția, iar execuția
este preluată de primul bloc catch, care are ca parametru o instanță ce se potrivește cu tipul
excepției aruncate. Dacă nu există definit niciun bloc catch care să trateze excepția atunci, în
mod predefinit, PHP va lansa o eroare fatală "Uncaught Exception … ". Din punct de
vedere sintactic avem următoarea configurație:
try{
//cod care prin execuție poate arunca excepții
}
catch(excepție1){
//cod care tratează excepția dacă tipul excepției aruncate
se //potrivește cu tipul parametrului blocului
}
…
catch(excepțieN){
//cod care tratează excepția dacă tipul excepției aruncate
se //potrivește cu tipul parametrului blocului
}
unde, excepție1, …, excepțieN reprezintă instanțe ale clasei predefinite Exception sau ale
claselor derivate din aceasta (vezi paragraful dedicat excepțiilor derivate).
Observația 11.1: Un bloc try poate conține un alt bloc try, dar fiecare trebuie să atașeze
propriile blocuri catch.
O situație excepție poate să apară în urma execuției programului sau poate fi aruncată explicit
de către programator în momentul în care anumite condiții sunt îndeplinite pentru a o genera.
În cel de-al doilea caz, PHP folosește instrucțiunea throw. După întâlnirea instrucțiunii throw
celelalte instrucțiuni din secvența respectivă nu se mai execută, de aceea se recomandă
folosirea ei într-o structură alternativă.
throw new Exceptie;
unde, Exceptie este constructorul clasei predefinite Exception sau al unei clase derivate din
aceasta.
Observația 11.2: La rândul său și un bloc catch poate arunca o excepție în mod predefinit sau
prin intermediul instrucțiunii throw.
Exemplul 11.1: Procesarea excepțiilor
<?php
function invers($x) {
if (!$x) {
throw new Exception('impartire la zero');
}
else return 1/$x;
}
try {
echo invers(5) . "<br>";
echo invers(0) . "<br>";
} catch (Exception $e) {
echo "<font color='red'>situatie excepție: ", $e->getMessage(), "!
</font><br>";
}
echo 'instructiune după excepție';
?>
Apelul $e->getMessage() determină afișarea mesajului aruncat de excepție. Exemplul 11.1
reflectă modul de a trata de către programator o situație care în mod obișnuit ar genera o
eroare ce ar fi tratată predefinit de PHP.
11.2Clasa Exception
Este clasa de bază din ierarhia claselor ce gestionează excepțiile, atât cele predefinite cât și
cele definite de utilizator. Atributele și modificatorii lor de vizibilitate precum și metodele de
acces la aceste atribute sunt prezentate în Tabelul 11.1.
Numele
atributuluiModificatorul
de vizibilitate
al atributuluiMetoda de acces Observații
$message protected getMessage()returnează un string cu
mesajul de excepție
$code protected getCode()returneaza un întreg cu
codul de excepție
$file protected getFile()returnează numele
fișierului de unde excepția
a fost aruncată
$line protected getLine()returnează numărul liniei
unde excepția a fost
aruncată
$trace privategetTrace()
getTraceAsString()returnează drumul
excepției de când a fost
aruncată și până a fost
prinsă
Tabelul 11.1: Membrii clasei Exception
Observația 11.3:
Toate metodele din Tabelul 11.1 sunt final;
Constructorul clasei are ca argument un string ce va inițializa atributul $message.
Constructorul este public;
Clasele Exception și cele derivate din ea nu se pot clona;
Conține metoda __toString(), care este public și care se poate redefini în clasele
derivate.
11.3Excepții derivate
Clasa Exception este clasa de bază în ierarhia excepțiilor ce pot fi aruncate și prinse în PHP.
56Excepții predefinite PHP
PHP furnizează și o colecție de clase predefinite, derivate din Exception pe care le prezentăm
în Tabelul 11.2.
Numele clasei Numele clasei parinte Observatii
BadFunctionCallException LogicExceptionexcepție aruncată la un apel
al unei funcții nedefinite
BadMethodCallException BadFunctionCallExceptionexcepție aruncată la un apel
al unei metode nedefinite
DomainException LogicExceptionexcepție aruncată la un
domeniu nevalid
InvalidArgumentException LogicExceptionexcepție aruncată la un apel
de funcție din cauza
nepotrivirii unui argument cu
cel așteptat
LengthException LogicExceptionexcepție aruncată de o
lungime nevalidă
LogicException Exceptionexcepție aruncată de o
expresie logică nevalidă
OutOfBoundsException RuntimeExceptionexcepție aruncată atunci când
o valoare este o cheie
nevalidă
OutOfRangeException LogicExceptionexcepție aruncată atunci când
o valoare nu este într-un
domeniu
OverflowException RuntimeExceptionexcepție aruncată atunci când
se doreste introducerea unei
valori într-un container plin
RangeException RuntimeExceptionexcepție aruncată atunci când
o valoare nu corespunde unui
domeniu
RuntimeException Exceptionexcepție aruncată în timpul
rulării
UnderflowException RuntimeExceptionexcepție aruncată atunci când
se dorește extragerea unei
valori dintr-un container gol
UnexpectedValueException RuntimeExceptionexcepție aruncată atunci când
o valoare nu corespunde unei
mulțimi date
Tabelul 11.2 : Clase predefinite, derivate din Exception
Toate aceste clase posedă doar metodele pe care le-am amintit la clasa Exception. De
asemenea, toate observațiile de acolo rămân valabile.
57Excepții definite de utilizator
Utilizatorii pot defini propriile clase de excepții prin extinderea clasei Exception.
Exemplul 11.3: Excepții definite de utilizator
<?php
class ImpartireLaZero extends Exception{
public function __construct($message) {
parent::__construct($message);
}
public function __toString() {
return $this->message;
}
}
function invers($x) {
if (!$x) {
throw new ImpartireLaZero('impartire la zero');
}
else return 1/$x;
}
try {
echo invers(0) . "<br>";
} catch (ImpartireLaZero $e) {
echo "<font color='red'>situatie excepție def de utilizator: ", $e, "!
</font><br>";
}
?>
Am construit clasa ImpartireLaZero în care am redefinit constructorul și metoda
__toString(). În blocul try în loc să aruncăm o excepție oarecare aruncăm excepția ce
tratează împărțirea la zero, excepție definită de utilizator. În plus, utilizatorul poate adăuga
metode noi clasei excepție definită.
11.4Tratarea excepțiilor în mod specific PHP
Tot ce am prezentat în acest capitol, până în acest moment, se regăsește, cu unele diferențe
sintactice, și în alte limbaje de programare (C++, Java). PHP aduce însă și o tratare specifică a
excepțiilor pe baza unor construcții pe care le vom discuta în continuare.
58Funcția set_exception_handler()
Am afirmat în secțiunile anterioare că pentru a prinde o situație excepție trebuie ca blocul de
cod ce aruncă excepția să fie introdus în try, iar apoi un alt bloc, catch, să trateze excepția.
Această procedură poate avea ca alternativă folosirea funcției predefinite PHP
set_exception_handler() , cu următoarea sintaxă:
set_exception_handler(nume)
unde, nume este o variabilă ce conține numele funcției ce tratează excepția, eventual clasa în
care se găseste această funcție (caz în care nume este un array. Vezi Exemplul 11.4).
Exemplul 11.4: Folosirea funcției set_exception_handler()
<?php
class ImpartireLaZero extends Exception{
public function __construct($message) {
parent::__construct($message);
}
public function __toString() {
return $this->message;
}
function tratare_excepție(self $excepție) {
echo "excepție: " . $excepție. "<br>";
}
}
set_exception_handler(array('ImpartireLaZero','tratare_excepție'));
function invers($x) {
if (!$x) {
throw new ImpartireLaZero('impartire la zero');
}
else return 1/$x;
}
echo invers(0) . "<br>";
?>
Față de clasa ImpartireLaZero, definită în Exemplul 11.3, am adăugat o funcție utilizator,
tratare_excepție() , care are un parametru de tipul clasei curente ( self). În definiția
funcției am afișat mesajul excepției grație definirii metodei __toString(). Apelul funcției
set_exception_handler() se face prin parametrul de tip array, în care primul element este
numele clasei ce conține metoda iar al doilea este numele metodei. Pe ultima linie încercăm să
apelăm funcția invers(), care aruncă o excepție. Deși excepția nu este aruncată într-un bloc
try și nu este prinsă de catch, totuși comportamentul este similar din cauza apelului din
set_exception_handler().
Observația 11.4: Funcția set_exception_handler() se poate folosi și în cazul în care un bloc
try nu este urmat de un bloc catch care să trateze excepția aruncată. În mod predefinit PHP
aruncă o eroare.
59Erori tratate ca excepții
PHP posedă un sistem propriu de tratare a erorilor. În locul acestuia, în anumite cazuri, putem
defini propria modalitate de tratare a erorilor. Astfel, mesajul de eroare generat împreună cu
eventuala sistare a execuției pot fi înlocuite cu o excepție. Clasa predefinită pentru aceasta
este ErrorException. Pentru tratarea erorilor ca excepții PHP folosește funcția
set_error_handler() , cu următoarea sintaxă:
set_error_handler(nume)
unde, nume are aceeași semnificație ca în cazul lui set_exception_handler() (Exemplul
11.5).
Exemplul 11.5: Erori tratate ca excepții
<?php
class ImpartireLaZero extends Exception{
public function __construct($message) {
parent::__construct($message);
}
public function __toString() {
return $this->message;
}
}
function tratare_erori($errno, $errstr, $errfile, $errline){
throw new ErrorException($errstr, 0, $errno, $errfile,
$errline);
}
set_error_handler('tratare_erori');
function invers($x) {
if (!$x) {
throw new ImpartireLaZero('impartire la zero');
}
else return 1/$x;
}
try{
echo invers('a') . "<br>";
} catch (ImpartireLaZero $e) {
echo "<font color='red'>situatie excepție def de utilizator: ", $e,
"!</font><br>";
}
catch (ErrorException $e1) {
echo "<font color='red'>situatie excepție: ", $e1-
>getMessage(), "!</font><br>";
}
?>
Folosim clasa ImpartireLaZero definită în Exemplul 11.3. Funcția tratare_erori()
construiește clasa ErrorException. Apelul funcției set_error_handler() se face prin
numele funcției ce gestionează excepția. În blocul try încercăm un apel al funcției invers()
cu un parametru nepotrivit. Această excepție nu poate fi prinsă cu ImpartireLaZero, ci doar
cu ErrorException.
11.5Rezumat
În acest capitol am discutat problemele esențiale ale conceptului de excepție, tratarea
exceptiilor și implementări specifice PHP ale exceptiilor. Astfel, am discutat despre membrii
clasei Exception care controlează activitatea de bază în manipularea exceptiilor. Am discutat
apoi despre blocurile implicate în aruncarea, respectiv prinderea excepțiilor. Am derivat, mai
departe, clasa de bază și am studiat principalele clase predefinite, precum și am creat clase
utilizator pentru tratarea excepțiilor. În final, am tratat erorile cu ajutorul excepțiilor.
Capitolul 12:Persistența datelor cu PHP
În acest capitol vom aborda următoarele subiecte:
Introducere în conceptul de persistență a datelor și modul de realizare a persistenței cu
MySQL
Conectarea la server-ul MySQL
Erori în lucrul cu server-ul MySQL
Operații fundamentale asupra unei baze de date
Accesarea rezultatelor unei interogări
Informații despre baza de date
Prin persistența datelor întelegem păstrarea datelor un timp mai îndelungat, mai precis și după
terminarea rulării unui script. Există mai multe posibilități de realizare a persistentei. Unele
le-am studiat în capitolele precedente: cookie-urile păstrau date în cantități mici, un interval
determinat de timp, sau fișierele externe unde datele erau recunoscute în mod text sau binar.
Pentru un volum mai mare de date și pentru a crea un mod organizat de gestiune a lor,
frecvent se folosesc bazele de date. Există multiple sisteme de gestiune a bazelor de date.
Vom studia în acest capitol bazele de date relaționale și un sistem de gestiune foarte mult
utilizat împreună cu PHP, și anume MySQL.
MySQL (My Structured Query Language) rulează ca un server de baze de date multiuser. Este
scris în C și C++ de către Michael Widenius și David Axmark, iar prima versiune a apărut în
1995. MySQL este open-source, free și cross-platform, adică rulează fără modificări pe
diferite platforme cum ar fi: Windows, Linux, Mac OS X, Solaris sau SunOS.
Așa după cum am precizat încă din Capitolul 1, prin instalarea pachetului XAMPP avem
instalat și serverul MySQL, cu toate conexiunile de comunicare făcute la serverul Apache.
Versiunea la care vom face referire în acest capitol este MySQL 5.0.59a.
XAMPP oferă și un browser de baze de date la adresa: http://localhost/phpmyadmin/ .
Vom considera că cititorul acestui capitol are cunoștințele necesare despre baze de date
relaționale și despre MySQL, ca sistem de gestiune a bazelor de datelor. În secțiunile
următoare vom detalia doar implementarea în PHP a comenzilor MySQL și vom comenta
acolo unde sunt necesare clarificările teoretice.
Pentru o aplicație care interacționează cu un server de baze de date trebuie să parcurgem mai
întâi unele etape pregătitoare, și anume: conectarea la server și selectarea bazei de date, iar
apoi etape specifice aplicației: crearea, interogarea sau administrarea bazei de date, etapa de
sfârșit fiind închiderea conexiunii.
12.1Conectarea la server-ul MySQL
Pentru a ne conecta la server-ul de baze de date, PHP ne oferă funcția mysql_connect().
Sintaxa simplificată a acestei funcții este:
mysql_connect(server, utilizator, parola)
unde:
server este numele sever-ului sau IP-ul acestuia urmat de numărul portului. În mod
obișnuit portul este 3306. Dacă MySQL se află pe același calculator cu server-ul
Apache atunci server va avea valoarea: localhost:3306 sau 127.0.0.1:3306.
Aceasta este și valoarea predefinită. Putem modifica valoarea predefinită în php.ini
prin directiva mysql.default_host.
utilizator este numele utilizatorului cu care ne putem conecta la server-ul MySQL.
Utilizatorul poate avea diverse drepturi asupra bazelor de date de pe server așa cum au
fost create de administratorul server-ului. În momentul instalării pachetului XAMPP
se crează în mod implicit un utilizator cu drepturi depline, inclusiv de creare de conturi
de utilizatori, având valoarea root. Este recomandat ca această valoare să fie
12.6 Informații despre baza de date 109
schimbată după instalare. Valoarea predefinită poate fi modificată în php.ini prin
directiva mysql.default_user .
Parola este parola de logare a utilizatorului, creată de administratorul bazei de date. La
instalarea XAMPP valoarea parolei este stringul vid. Valoarea predefinită poate fi
modificată în php.ini prin directiva mysql.default_password .
Returnează o conexiune la baza de date sau FALSE în caz de eșec.
Observația 12.1 : Putem suprima mesajul de eroare, în caz de conexiune greșită, prin folosirea
operatorului “ @”.
În mod implicit conexiunea anterior creată se închide la terminarea scriptului ce a deschis-o.
Explicit putem închide conexiunea apelând funcția mysql_close() , ce are următoarea sintaxă
generală:
mysql_close(conexiune)
unde, conexiune este numele unei conexiuni create cu mysql_connect() . Dacă conexiune
lipsește, se va închide ultima conexiune deschisă, iar dacă nu este nicio conexiune deschisă se
va genera un mesaj de eroare.
12.2 Selectarea unei baze de date
După ce conexiunea a fost creată cu succes putem deschide o bază de date. Selectarea bazei
de date se face folosind funcția mysql_select_db() , cu următoarea sintaxă generală:
mysql_select_db(nume_baza, conexiune)
unde:
nume_baza este numele bazei de date ce urmează a fi selectată;
conexiune este numele unei conexiuni deschise cu mysql_connect() . Dacă
parametrul conexiune lipsește se va încerca selectarea bazei de date din ultima
conexiune deschisă.
Funcția va returna TRUE în cazul în care selecția a putut fi făcută și FALSE, altfel.
12.3 Detectarea erorilor
Erorile transmise de MySQL pot fi prinse de PHP prin intermediul a două funcții:
mysql_errno() și mysql_error() . Sintaxa generală este:
mysql_errno(conexiune)
returnează numărul erorii ultimei operații MySQL. Numărul erorii este în corespondență cu
un string returnat de funcția:
mysql_error(conexiune)
Dacă parametrul conexiune lipsește se va face referire la ultima conexiune deschisă.
Exemplul 12.1: Deschiderea unei conexiuni și selectarea unei baze de date
<html>
<head>
<title>
Exemplul 12.1
</title>
</head>
<body>
<?php
$user = "root";
$pass = "";
$bd = "test";
$link = @ mysql_connect( "localhost", $user, $pass ) or
die( "Nu m-am putut conecta la MySQL! ".mysql_errno());;
print "Conectare la server cu succes!";
@ mysql_select_db( $bd ) or
die ( "Nu m-am putut conecta la baza de date $db:
".mysql_error());
print "Baza de date $bd selectata cu succes!";
mysql_close( $link );
?>
</body>
</html>
12.4Operații fundamentale asupra unei baze de date
După ce conexiunea a fost realizată cu succes, iar baza de date selectată, putem să facem
operații asupra bazei de date.
60Expedierea unei cereri catre MySQL
Poate cea mai utilizată funcție în lucru cu baze de date aflate pe un server este
mysql_query() ce expediază server-ului o cerere și are următoarea sintaxă:
mysql_query(cerere, conexiune)
unde, cerere este un string ce conține o frază SQL. Parametrul conexiune poate lipsi și
atunci este invocată ultima conexiune. Corectitudinea sintactică a cererii nu este verificată
înainte de expediere. MySQL va returna o eroare în cazul în care cererea are erori de sintaxă.
Funcția returnează un rezultat ce urmează apoi a fi interpretat dacă cererea este de tipul
SELECT, SHOW, DESCRIBE, etc. sau returnează TRUE dacă cererea este de tipul INSERT, UPDATE,
DELETE, DROP, etc. în caz de succes, respectiv FALSE în caz de eșec.
Dacă dorim să creăm o bază de date goală, librarie, putem folosi următorul cod:
$sql = "CREATE DATABASE librarie";
if (mysql_query($sql, $link))
echo "Baza de date librarie a fost creată cu succes\n";
else
echo "Eroare la crearea bazei de date: ".mysql_error()."\n";
12.6 Informații despre baza de date 111
unde, $sql conține string-ul interogării SQL, iar $link este conexiunea creată în
Exemplul 12.1 .
În baza de date anterior creată vom crea acum tabele. Exemplificăm crearea de tabele prin
tabela domenii ce are următoarea structură:
id_domeniu : cheie primara, INTEGER, NOT NULL, AUTO_INCREMENT;
nume_domeniu : VARCHAR( 20 );
descriere : TEXT;
codul PHP pentru a crea această structură este:
$sql = "create table `librarie`.`domenii` ( `domenii` int NOT NULL
AUTO_INCREMENT , `nume_domeniu` varchar (20) , `descriere` text , PRIMARY
KEY (`domenii`)) ";
if (mysql_query($sql, $link))
echo "Baza de date my_db a fost creată cu succes\n";
else
echo "Eroare la crearea bazei de date: ".mysql_error()."\n";
Acesta este modul programat de a crea o tabelă. Putem crea tabele utilizând și browser-ul
bazei de date.
În continuare adăugăm date în tabela domenii. Vom folosi un formular cu două câmpuri
corespunzătoare numelui, respectiv descrierii domeniului. Cămpul id_domeniu se
autoincrementează la fiecare adăugare de noi înregistrări.
Exemplul 12.2: Adăugarea de date dintr-un formular într-o tabelă
<html>
<head>
<title>
Exemplul 12.2
</title>
</head>
<body>
<?php
if ( isset( $_POST['nume_domeniu']) && isset( $_POST['descriere'] )){
$nume_domeniu=$_POST['nume_domeniu'];
$descriere=$_POST['descriere'];
$dberror = "";
$ret = adauga_în_bd( $nume_domeniu, $descriere, $dberror );
if ( ! $ret )
print "Error: $dberror<BR>";
else
print "Va multumim";
}
else {
write_form();
}
function adauga_în_bd( $nume_domeniu, $descriere, &$dberror ){
$user = "root";
$pass = "";
$db = "librarie";
$link = mysql_pconnect( "localhost", $user, $pass );
if ( ! $link ){
$dberror = "Nu m-am putut conecta la server-ul MySQL!";
return false;
}
if ( ! mysql_select_db( $db, $link ) ){
$dberror = mysql_error();
return false;
}
$query = "INSERT INTO domenii ( nume_domeniu, descriere)
values( '$nume_domeniu', '$descriere')";
if ( ! mysql_query( $query, $link ) ){
$dberror = mysql_error();
return false;
}
return true;
}
function write_form(){
global $PHP_SELF;
print "<form action=\"$PHP_SELF\" method=\"POST\">\n";
print "<input type=\"text\" name=\"nume_domeniu\"> ";
print "Domeniul dorit<p>\n";
print "<input TYPE=\"text\" name=\"descriere\"> ";
print "Descrierea domeniului<p>\n";
print "<input type=\"submit\" value=\"submit!\">\n</form>\n";
}
?>
</body>
</html>
61Numărul de rânduri afectate de o cerere
Putem afla numărul de rânduri afectate în urma operației INSERT din Exemplul 12.2 folosind
funcția mysql_affected_rows() ce are următoarea sintaxă generală:
mysql_affected_rows(conexiune)
unde, conexiune este opțională, dacă lipsește se va considera ultima conexiune creată.
Rezultatul întors este numărul rândurilor afectate de ultimul apel al funcției mysql_query()
cu parametru INSERT, UPDATE sau DELETE în caz de succes și -1 în caz de eșec. Dacă
parametrul este REPLACE, atunci, în caz de success, se va întoarce suma dintre numărul
înregistrărilor eliminate și numărul înregistrărilor adăugate.
62Obținerea valorii unui câmp care se autoincrementează
În Exemplul 12.2 am adăugat înregistrări noi în tabela domenii fără să specificăm explicit
valori pentru atributul id_domeniu. Aceasta deoarece valoarea sa se autoincrementează.
Putem afla valoarea acestui atribut, pentru ultima înregistare introdusă cu INSERT, folosind
funcția mysql_insert_id() , ce are următoarea sintaxă generală:
mysql_insert_id(conexiune)
unde, conexiune poate să lipsească și atunci se folosește ultima conexiune creată. Funcția
întoarce valoarea câmpului autoincrementat al ultimei înregistrări introduse cu INSERT în caz
de succes, 0 dacă ultima înregistrare nu conține un câmp autoincrementat, sau FALSE dacă nu
avem nicio conexiune stabilită, în caz de eșec.
12.6 Informații despre baza de date 113
Observația 12.2: Tipul returnat este integer în PHP. Dacă în MySQL tipul câmpului
autoincrementat este BIGINT, atunci rezultatul returnat nu este corect. Se poate folosi în
schimb o cerere SQL în care să apelăm funcția LAST_INSERT_ID() .
Pentru a ilustra cu exemple funcțiile din secțiunile următoare vom completa baza de date
librărie cu următoarele tabele:
carti, care conține cărțile accesibile cumpărătorilor din librărie. Am presupus că o
carte aparține unui singur domeniu. Această tabelă are următoarea structură:
oid_carte : cheie primară, INTEGER, NOT NULL, AUTO_INCREMENT;
otitlu: VARCHAR( 20 );
opret: FLOAT;
oid_domeniu: cheie străină, INTEGER;
autori, autorii cărților și are următoarea structură:
oid_autor : cheie primară, INTEGER, NOT NULL, AUTO_INCREMENT;
onume: VARCHAR(20);
oprenume: VARCHAR(20);
carti_autori , tabel de legatură dintre tabelul carti și tabelul autori; o înregistrare
din acest tabel leagă o carte de un autor. O carte poate avea mai mulți autori, deci pot
apărea mai multe înregistrări cu același id_carte . Un autor poate scrie mai multe
cărți, deci pot apărea mai multe înregistrări ce au același id_autor . Această tabelă are
următoarea structură:
oid_carte : cheie străină, INTEGER;
oid_autor : cheie străină, INTEGER;
63 Interogări ale bazei de date
Până în acest moment funcția mysql_query() conținea ca prim parametru o clauză SQL care
nu returna, ca rezultat, un tabel. Dacă clauza SQL este însă un SELECT atunci rezultatul
apelului este un tabel, cunoscut și sub numele de ResultSet .
Exemplul 12.3: Dacă dorim să aflăm toate informațiile despre domeniile în care pot fi incluse
cărțile din librărie putem folosi următoarea sintaxă:
$rezultat = mysql_query( "SELECT * FROM domains" );
Rezultatul returnat de funcție este reținut în variabila $rezultat și este practic un tabel, în
caz de succes, tabel ce va fi apoi parcurs cu funcții PHP.
12.5 Accesarea unui ResultSet
64 Numărul de rânduri al rezultatului unei interogări
Putem afla numărul de rânduri din variabila $rezultat din Exemplul 12.3 utilizând funcția
mysql_num_rows() . Funcția are următoarea sintaxă generală:
mysql_num_rows(rezultat)
unde, rezultat este o variabilă ce are valoarea rezultatului întors de mysql_query() cu
parametru SELECT sau SHOW.
Funcția returnează numărul de rânduri în caz de succes și FALSE altfel.
65Parcurgerea unui ResultSet
PHP pune la dispoziție mai multe posibilități de parcurgere a unui rezulat întors de o
interogare SQL. Vom prezenta în continuare câteva dintre cele mai frecvent întrebuințate.
Funcția mysql_fetch_row() returnează o variabilă de tip array pentru rândul curent din
tabela rezultat. După încheierea execuției funcției, indicatorul de tabel înaintează la următorul
rând, dacă există, sau la sfârșitul tabelei altfel. Sintaxa generală este:
mysql_fetch_row(rezultat)
unde, rezultat este o variabilă ce are valoarea rezultatului întors de mysql_query() cu
parametru SELECT sau SHOW.
Exemplul 12.4: Să se afișeze titlul și prețul unitar al cărților care îl au ca autor pe “Mihai
Eminescu”.
<html>
<head>
<title>
Exemplul 12.4
</title>
</head>
<body>
<?php
$user = "root";
$pass = "";
$db = "librarie";
$conexiune = mysql_connect( "localhost", $user, $pass );
if ( ! $conexiune ) die( "Nu putem conecta server-ul MySQL" );
mysql_select_db( $db, $conexiune ) or die ( "Nu putem deschide
$db: ".mysql_error() );
$rezultat = mysql_query( "SELECT titlu, pret FROM carti,
autori, carti_autori WHERE carti.id_carte=carti_autori.id_carte and
carti_autori.id_autor=autori.id_autor and nume='Eminescu' and
prenume='Mihai'" );
$nr_linii = mysql_num_rows( $rezultat );
print "Tabela rezultat are $nr_linii linii<P>";
print "<table border=1>\n";
while ( $linie = mysql_fetch_row( $rezultat ) ){
print "<tr>\n";
foreach ( $linie as $camp )
print "\t<td>$camp</td>\n";
print "</tr>\n";
}
print "</table>\n";
mysql_close( $conexiune );
?>
</body>
</html>
12.6 Informații despre baza de date 115
În Exemplul 12.4, pe lângă deschiderile obișnuite, de conexiune și bază de date, am realizat o
interogare prin care am joncționat trei dintre tabelele bazei de date: carti, autori și
carti_autori . În plus, condiția de selecție mai adaugă o condiție de egalitate compusă
asupra numelui și prenumelui. Variabilei $linie i-am dat valoarea returnată de funcția
mysql_fetch_row() . Am parcurs apoi această variabilă ca pe un array prin instrucțiunea
foreach și am afișat valoarea fiecărui element al său. Elementele array-ului sunt indexate
predefinit.
Alternativ, putem folosi funcția mysql_fetch_array() ce returnează tot un array dar, ale
cărui elemente pot fi accesate și prin cheia asociată numelui coloanei. Sintaxa simplificată
este:
mysql_fetch_array(rezultat)
unde, rezultat este o variabilă ce are valoarea rezultatului întors de mysql_query() cu
parametru SELECT sau SHOW.
Exemplul 12.4 poate fi modificat pentru a folosi această funcție:
print "<TABLE BORDER=1>\n";
while ( $linie = mysql_fetch_array( $rezultat ) ){
print "<TR>\n";
print "<TD>$linie[titlu]</TD><TD>$linie[pret]</TD>\n";
print "</TR>\n";
}
print "</TABLE>\n";
O altă variantă de parcurgere este dată de folosirea funcției mysql_fetch_object() . Această
funcție returnează, în caz de success, un obiect pentru fiecare rând al rezultatului. Atributele
obiectului sunt câmpurile tabelei. Sintaxa generală a acestei funcții este:
mysql_fetch_object(rezultat, nume_clasa, parametri_constructor)
unde, rezultat este o variabilă ce are valoarea rezultatului întors de mysql_query() cu
parametru SELECT sau SHOW, nume_clasa este numele clasei din care se va construi instanța
ce gestionează atributele liniei curente, iar parametri_constructor reprezintă un array în
care sunt parametrii necesari apelării constructorului clasei nume_clasa. Ultimii doi
parametri pot lipsi și atunci obiectul construit este instanță a clasei predefinite stdClass .
Exemplul 12.4 poate fi modificat pentru a folosi această funcție:
print "<table border=1>\n";
while ( $linie = mysql_fetch_object( $rezultat ) ){
print "<tr>\n";
print "<td>$linie->titlu</td><td>$linie->pret</td>\n";
print "</tr>\n";
}
print "</table>\n";
66Poziționarea indicatorului de tabel
Așa după cum am văzut din exemplele anterioare, indicatorul tabelei este poziționat pe prima
linie după deschiderea conexiunii și avansează câte o linie după apelul oricăreia dintre
funcțiile: mysql_fetch_rows() , mysql_fetch_array() sau mysql_fetch_object() . Putem
modifica acest comportament secvențial apelănd funcția mysql_data_seek() . Sintaxa
generală a acestei funcții este:
mysql_data_seek(rezultat, numar)
unde:
rezultat este o variabilă ce are valoarea rezultatului întors de mysql_query() cu
parametru SELECT sau SHOW;
numar indică numărul liniei la care se dorește poziționarea indicatorului de tabel.
Liniile unui tabel rezultat sunt numerotate între 0 și mysql_num_rows()-1 .
Funcția returnează TRUE în caz de succes și FALSE altfel.
67Numărul de coloane al rezultatului unei interogări
Putem afla numărul de coloane ale fiecărei înregistrări din variabila $rezultat din Exemplul
12.3 funcția mysql_num_fields() . Funcția are următoarea sintaxă generală:
mysql_num_fields(rezultat)
unde, rezultat este o variabilă ce are valoarea rezultatului întors de mysql_query() cu
parametru SELECT sau SHOW.
Funcția returnează numărul de coloane în caz de succes și FALSE altfel.
68Numele câmpurilor unei interogări
Funcția mysql_field_name() returnează numele unei coloane din tabela rezultat în caz de
succes și FALSE altfel. Sintaxa generală a acestei funcții este:
mysql_field_name(rezultat, numar)
unde:
rezultat este o variabilă ce are valoarea rezultatului întors de mysql_query() cu
parametru SELECT sau SHOW
numar indică numărul coloanei din cadrul rândului curent la care se dorește aflarea
numelui.
Coloanele unei linii din tabelul rezultat sunt numerotate între 0 și mysql_num_fields()-1 .
Putem modifica Exemplul 12.4 astfel încât tabelul ce cuprinde datele din tabela rezultat să aibă
și cap de tabel în care să indicăm numele câmpurilor afișate:
print "<tr>\n";
for ( $x=0; $x<$num_fields; $x++ )
print "<th>".mysql_field_name( $rezultat, $x ) ."</th>";
print "</tr>\n";
while ( $linie = mysql_fetch_object( $rezultat ) ){
print "<tr>\n";
12.6 Informații despre baza de date 117
print "<td>$linie->titlu</td><td>$linie->pret</td>\n";
print "</tr>\n";
}
print "</table>\n";
69 Lungimea unui câmp din tabela rezultat al unei interogări
Putem afla lungimea unui câmp apelănd funcția mysql_field_len(), ce are următoarea
sintaxă generală:
mysql_field_len(rezultat, numar)
unde:
rezultat este o variabilă ce are valoarea rezultatului întors de mysql_query() cu
parametru SELECT sau SHOW;
numar indică numarul coloanei din cadrul rândului curent la care se dorește aflarea
lungimii. Coloanele unei linii din tabelul rezultat sunt numerotate între 0 și
mysql_num_fields()-1 .
70 Tipul unui câmp din tabela rezultat al unei interogări
Putem afla tipul PHP al unui câmp apelând funcția mysql_field_type(), ce are următoarea
sintaxă generală:
mysql_field_type(rezultat, numar)
unde:
rezultat este o variabilă ce are valoarea rezultatului întors de mysql_query() cu
parametru SELECT sau SHOW
numar indică numărul coloanei din cadrul rândului curent la care se dorește aflarea
tipului. Coloanele unei linii din tabelul rezultat sunt numerotate între 0 și
mysql_num_fields()-1 .
71 Atributele unui câmp din tabela rezultat al unei interogări
Putem afla atribute ca: not_null , primary_key , unique_key , multiple_key , blob,
unsigned , zerofill , binary, enum, auto_increment și timestamp ale unui câmp apelând
funcția mysql_field_flags() ce are următoarea sintaxă generală:
mysql_field_flags(rezultat, numar)
unde:
rezultat este o variabilă ce are valoarea rezultatului întors de mysql_query() cu
parametru SELECT sau SHOW;
numar indică numărul coloanei din cadrul rândului curent la care se dorește aflarea
atributelor. Coloanele unei linii din tabelul rezultat sunt numerotate între 0 și
mysql_num_fields()-1 .
Rezultatul returnat este un string, în care atributele sunt separate prin spațiu, care poate fi
despărțit utilizând funcția explode() .
12.6Informații despre baza de date
PHP conține un domeniu vast de funcții ce permit returnarea informațiilor despre structura
conexiunii curente.
72Listarea bazelor de date
Funcția mysql_list_dbs() returnează o tabelă ce conține lista bazelor de date disponibile
din conexiune, în caz de succes și FALSE altfel. Sintaxa generală este:
mysql_list_dbs(conexiune)
unde, conexiune poate să lipsească și atunci se folosește ultima conexiune creată.
Folosim funcția mysql_num_rows() pentru a afla numărul de baze de date accesibile din
conexiune. Apoi, pentru aflarea numelui acestora apelăm funcția mysql_db_name() ce are
următoarea sintaxă simplificată:
mysql_db_name(rezultat, numar)
unde:
rezultat este o variabilă ce are valoarea rezultatului întors de mysql_list_dbs()
numar indică numărul liniei la care se dorește poziționarea indicatorului de tabel.
Liniile unui tabel rezultat sunt numerotate între 0 și mysql_num_rows()-1 . Funcția
returnează un string cu numele în caz de succes și FALSE altfel.
Exemplul 12.5: Lista bazelor de date disponibile din conexiunea curentă
<html>
<head>
<title>Exemplul 12.5</title>
</head>
<body>
<?php
$user = "root";
$pass = "";
$conexiune = mysql_connect( "localhost", $user, $pass );
if ( ! $conexiune ) die( "nu ne putem conecta la server-ul
MySQL" );
$rezultat = mysql_list_dbs( $conexiune );
$num = mysql_num_rows( $rezultat );
for( $x = 0; $x < $num; $x++ )
print mysql_db_name( $rezultat, $x )."<br>";
mysql_close( $conexiune );
?>
</body>
</html>
73Listarea tabelelor dintr-o bază de date
Putem folosi funcția mysql_query() având ca parametru o interogare SHOW și apoi parcurgem
tabela rezultat prin mecanisme deja cunoscute.
Modificăm Exemplul 12.5 pentru a afișa pentru fiecare bază de date și numele tabelelor ce o
formează.
$rezultat = mysql_list_dbs( $conexiune );
$num = mysql_num_rows( $rezultat );
12.6 Informații despre baza de date 119
for( $x = 0; $x < $num; $x++ ){
$bd=mysql_db_name( $rezultat, $x );
print "<b>".$bd."</b> conține urmatoarele tabele:<br>";
$sql = "SHOW TABLES FROM $bd ";
$rezultat1 = mysql_query($sql);
print "<ul>";
while ($linie = mysql_fetch_row($rezultat1)) {
print "<li> {$linie[ 0]}";
}
print "</ul>";
}
12.7 Rezumat
În acest capitol am discutat despre gestiunea bazelor de date cu ajutorul conexiunii dintre
server-ul PHP și server-ul MySQL. În nucleul de bază al limbajului PHP funcțiile care
interacționează cu server-ul de baze de date folosesc, în mare parte, sintaxa MySQL printr-un
parametru al lor. Avem, așadar, trei categorii de funcții care interacționează cu baza de date:
funcțiile de conectare, funcțiile de expediere a unor cereri și funcții de manipulare a
rezultatului cererii. Despre toate aceste categorii am discutat în secțiunile acestui capitol.
Bibliografie
[1] Luke Welling, Laura Thomson, 2005, Dezvoltarea aplicatiilor WEB cu PHP si MySQL,
Editia a II-a,, Teora
[2] David Lane; Hugh E. Williams, 2002, Web Database Applications with PHP & MySQL ,
O'Reilly.
[3] Andi Gutmans, Stig Sather Bakken, Derick Rethans, 2005, Php 5 Power Programming
Pearson Education Inc.
[4] George Schlossnagle, 2004, Advanced PHP Programming , Sams.
[5] Kevin Tatroe, Rasmus Lerdorf, Peter MacIntyre, 2006 , Programming PHP, 2nd Edition,
O’Reilly.
[6] Larry Ulman, 2006, PHP si MySQL pentru site-uri WEB dinamice, Teora.
ISBN 978-973-598-604-9
Copyright Notice
© Licențiada.org respectă drepturile de proprietate intelectuală și așteaptă ca toți utilizatorii să facă același lucru. Dacă consideri că un conținut de pe site încalcă drepturile tale de autor, te rugăm să trimiți o notificare DMCA.
Acest articol: PREFAȚĂ………………………………………………………………………………………………………………….. 7… [624153] (ID: 624153)
Dacă considerați că acest conținut vă încalcă drepturile de autor, vă rugăm să depuneți o cerere pe pagina noastră Copyright Takedown.