Programarea in PHP - Marinoiu - Cu Adnotari

Programarea în PHP
1
Cristian MARINOIU
Programarea în PHP
Editura Universităţii Petrol-Gaze din Ploiești

2011
3
Programarea în PHP
Copyright© 2011
EDITURA UNIVERSITĂŢII PETROL-GAZE DIN PLOIEŞTI
Toate drepturile asupra acestei ediţii sunt rezervate editurii
Autorul poartă întreaga răspundere morală, legală şi materială faţă

de editură şi terţe persoane pentru conţinutul lucrării
Descrierea CIP a Bibliotecii Naţionale a României

MARINOIU, CRISTIAN
Programarea în PHP / Cristian Marinoiu. - Ploieşti : Editura
Universităţii Petrol-Gaze din Ploieşti, 2011
Bibliogr.
ISBN 978-973-719-417-6
004.43 PHP
Control ştiinţific:
Prof. dr. ing. Liviu Dumitraşcu
Redactor:
Prof. dr. ing. Liviu Dumitraşcu
Tehnoredactare computerizată :
Daniela Babkin Marinoiu
Director editură:
Prof. dr. ing. Şerban Vasilescu
Adresa: Editura Universităţii Petrol-Gaze din Ploieşti, Bd. Bucureşti 39,

cod 100680, Ploieşti, România
Tel. 0244-573171, Fax 0244-575847
4
Prefaţă
Această carte reprezintă o introducere în limbajul PHP, fiind adresată
tuturor celor care doresc să înveţe unul din cele mai utilizate limbaje de
programare web din acest moment. Pentru parcurgerea şi asimilarea
materialului nu sunt necesare cunoştinţe prealabile din domeniul limbajelor
de programare. Totuşi, cunoaşterea unui limbaj, şi în mod special a
limbajului C, favorizează o înţelegere mai rapidă a problematicii expuse.
Modul de abordare a prezentării se bazează în special pe experienţa
dobândită de autor în predarea limbajelor de programare la specializările
Informatică, Informatică economică şi Calculatoare şi Automatică, de la
Universitatea Petrol-Gaze din Ploieşti.
Lucrarea este alcătuită din 14 capitole şi are un pronunţat caracter

practic. Noţiunile sunt prezentate gradat, iar înţelegerea şi asimilarea lor
este susţinută de numeroase exemple ilustrative, precum şi de cele 130 de
scripturi comentate. În primele şapte capitole sunt prezentate succesiv:
elementele de bază ale limbajului, modul de lucru cu vectorii, cu şirurile de
caractere, cu datele calendaristice şi cu ora, modul de transmitere a datelor
către scripturi. Pentru a veni în sprijinul cititorului, în Capitolul 8
(Elemente de bază în crearea formularelor) sunt descrise etichetele HTML
utilizate frecvent în aplicaţiile care utilizează formulare. Parcurgerea
capitolelor 9 (Funcţii) şi 10 (Clase şi obiecte) creează premisele elaborării
unor aplicaţii web performante. În Capitolul 11 (Persistenţa datelor
utilizând câmpuri ascunse, cookie-uri,sesiuni) sunt prezentate detaliat
elementele care asigură persistenţa datelor: câmpuri ascunse, cookie-uri,
sesiuni. Contorizarea numărului de apeluri ale unui script, afişarea traseului
parcurs de un vizitator într-un site, autentificarea şi autorizarea unui
utilizator la un site sunt doar trei aplicaţii din acest capitol ale conceptului
de persistenţă a datelor. Funcţiile de bază care permit crearea şi prelucrarea
fişierelor şi a directoarelor sunt descrise şi exmplificate în Capitolul 12
(Fişiere), respectiv Capitolul 13 (Directoare). Capitolul 14, intitulat
Crearea şi prelucrarea bazelor de date MySql utilizând PHP, încheie
lucrarea printr-o descriere a modalităţilor de utilizare a funcţiilor de creare
şi exploatare a bazelor de date MySql prin intermediul scripturilor PHP.
5
Programarea în PHP
Mulţumesc pe această cale colegilor mei de la colectivul de

Informatică al Departamentului de Tehnologia informaţiei, Matematică şi
Fizică de la Unversitatea Petrol-Gaze din Ploieşti şi în mod special
colegelor mele conf. dr. Monica Vlădoiu şi lector dr. Gabriela Moise pentru
observaţiile făcute asupra manuscrisului. Un cuvânt aparte de mulţumire
domnului profesor dr.ing. Liviu Dumitraşcu pentru amabilitatea de a
recenza această lucrare şi doamnei Daniela Babkin Marinoiu care a realizat
tehnoredactarea computerizată a cărţii.
Ploieşti, Septembrie, 2011 Autorul
6
Cuprins
CAPITOLUL 1
1. Introducere ........................................................................................ 13
1.1. PHP – scurt istoric ....................................................................... 13
1.2. PHP - caracteristici de bază.......................................................... 13
1.3. PHP – Noţiuni introductive .......................................................... 14
CAPITOLUL 2
2. Variabile, constante, tipuri de date..................................................... 19
2.1. Variabile ...................................................................................... 19
2.2. Constante ..................................................................................... 21
2.3. Tipuri de date ............................................................................... 22
2.3.1. Tipuri de date scalare ............................................................. 22
2.3.2. Tipuri de date compuse .......................................................... 24
2.3.3. Tipuri de date speciale ........................................................... 29
CAPITOLUL 3
3. Operatori şi expresii ...................................................................................... 31
3.1. Clase de precedenţă...................................................................... 31
3.2. Operatori aritmetici ...................................................................... 33
3.3. Operatori de comparaţie............................................................... 34
3.4. Operatori logici ............................................................................ 35
3.5. Operatorul de concatenare............................................................ 36
3.6. Operatori la nivel de bit................................................................ 36
3.7. Operatori de atribuire și de incrementare/decrementare............... 38
3.8. Operatorul cast – conversii explicite de tip................................... 41
CAPITOLUL 4
4. Instrucţiuni de control în PHP............................................................ 43
4.1. Instrucţiuni de atribuire, apeluri de funcţii, instrucţiunea vidă ..... 43
4.2. Instrucţiuni de decizie .................................................................. 44
7
Programarea în PHP
4.2.1. Instrucţiunea if ....................................................................... 44

4.2.2. Instrucţiunea if_else ............................................................... 45
4.2.3. Instrucţiunea if_elseif............................................................. 46
4.2.4. Instrucţiunea switch ............................................................... 48
4.2.5. Operatorul condiţional ? :....................................................... 50
4.3. Instrucţiuni iterative ..................................................................... 51
4.3.1. Instrucţiunea while................................................................. 51
4.3.2. Instrucţiunea for..................................................................... 52
4.3.3. Instrucţiunea do...while .......................................................... 54
4.3.4. Cicluri imbricate .................................................................... 55
4.4. Instrucţiuni de salt........................................................................ 56
4.4.1. Instrucţiunea break................................................................. 56
4.4.2. Instrucţiunea continue ............................................................ 58
CAPITOLUL 5
5. Vectori. Operaţii de bază ................................................................... 59
5.1. Parcurgerea vectorilor .................................................................. 59
5.1.1. Parcurgerea vectorilor folosind while, for sau do...while........ 60
5.1.2. Parcurgerea vectorilor folosind while, for sau do...while
împreună cu funcţiile list() şi each()....................................... 61
5.1.3. Parcurgerea vectorilor folosind funcţia foreach() ................... 64
5.2. Sortarea vectorilor........................................................................ 66
5.2.1. Sortarea vectorilor după valori, cu distrugerea
cheilor iniţiale....................................................................... 66
5.2.2. Sortarea vectorilor după valori, cu păstrarea corelării
acestora cu cheile iniţiale ....................................................... 68
5.2.3. Sortarea naturală a vectorilor după valori,
cu păstrarea corelării acestora cu cheile iniţiale ...................... 69
5.2.4. Sortarea vectorilor după chei, cu păstrarea corelaţiilor
acestora cu valorile iniţiale..................................................... 72
5.2.5. Sortarea simultană a vectorilor şi a vectorilor
multidimensionali .................................................................. 74
5.3. Alte funcţii utile de lucru cu vectorii............................................ 79
8
Cuprins
CAPITOLUL 6
6. Funcţii utilizate în prelucrarea şirurilor de caractere,
a datelor calendaristice şi a orei ......................................................... 87
6.1. Afișarea fără format a șirurilor de caractere utilizând
instrucţiunea echo şi funcţia print................................................. 88
6.2. Funcţii de citire şi afişare care utilizează un format ..................... 94
6.2.1. Funcţia sscanf() de citire dintr-un şir, cu format..................... 94
6.2.2. Funcţiile de afişare cu format printf() şi sprintf() ...................... 95
6.2.3. Utilizarea etichetelor <pre> şi </pre> pentru
vizualizarea spaţiilor ............................................................ 100
6.2.4. Asocierea explicită a specificatorilor de conversie
cu argumentele funcţiei printf().Funcţia sprintf()
de formatare a unei liste de argumente .................................. 102
6.3. Funcţiile strtok(), explode() și implode()................................... 103
6.4. Funcţii pentru curăţarea șirurilor: trim(), ltrim(), rtrim(),
stripslashes(), strip_tags()........................................................... 108
6.5. Alte funcţii utile pentru prelucrarea șirurilor de caractere .......... 113
6.6. Funcţii pentru prelucrarea datelor calendaristice şi a orei........... 121
CAPITOLUL 7
7. Transmiterea datelor către scripturile PHP....................................... 127
7.1. Transmiterea datelor către scripturile PHP utilizând
link-urile HTML ....................................................................... 129
7.2. Transmiterea datelor către scripturile PHP cu ajutorul
formularelor HTML .................................................................. 131
7.2.1. Folosirea unui singur script atât pentru transmiterea
datelor prin formular, cât și pentru prelucrarea lor ............... 134
CAPITOLUL 8
8. Elemente de bază în crearea formularelor ........................................ 139
8.1. Eticheta input ............................................................................. 140
8.2. Eticheta textarea......................................................................... 145
8.3. Eticheta select ............................................................................ 146
9
Programarea în PHP
CAPITOLUL 9
9. Funcţii ............................................................................................. 149
9.1. Variabile locale .......................................................................... 155
9.2. Variabile globale ........................................................................ 156
9.3. Variabile statice ......................................................................... 157
9.4. Transfer prin valoare, transfer prin referinţă............................... 159
CAPITOLUL 10
10. Clase şi obiecte ............................................................................. 163
10.1. Clasa ca un container .............................................................. 163
10.2. Clasa ca un tip de date............................................................. 168
10.3. Accesul la proprietăţile şi metodele unei clase ........................ 169
10.3.1. Accesul din afara clasei..................................................... 169
10.3.2. Accesul din interiorul clasei. Pseudo variabila this ........... 171
10.3.3. Constructori ...................................................................... 173
10.3.4. Apelul unei metode din interiorul altei metode ................. 174
10.3.5. Transferul obiectelor unei clase către metodele
altei clase ......................................................................... 175
10.4. Moştenirea .............................................................................. 176
CAPITOLUL 11
11. Persistenţa datelor utilizând câmpuri ascunse, cookie-uri,
sesiuni .......................................................................................... 181
11.1. Câmpuri ascunse ..................................................................... 182
11.2. Cookie-uri: creare, referire, ștergere........................................ 185
11.3. Sesiuni .................................................................................... 191
11.3.1. Funcţii şi variabile de sesiune ........................................... 193
11.3.2. Generarea unei sesiuni ...................................................... 195
11.3.3. Ştergerea unei sesiuni ................................................................ 198
11.4. Aplicaţii. Simularea unui mecanism de autentificare
și autorizare ............................................................................ 201
11.4.1. Varianta bazată pe utilizarea coockie-urilor ...................... 202
11.4.2. Varianta bazată pe utilizarea sesiunilor ............................. 204
10
Cuprins
CAPITOLUL 12
12. Fişiere ........................................................................................... 207
12.1. Funcţia de deschidere fopen() şi funcţia de închidere
fclose() ................................................................................... 207
12.2. Scrierea datelor în fişiere ........................................................ 210
12.2.1. Funcţiile fwrite() şi fputs() pentru scrierea în fişiere ......... 210
12.2.2. Funcţia file_puts_contents() pentru scriere în fişiere ......... 213
12.2.3. Funcţia flock() pentru blocarea şi deblocarea fişierelor ..... 215
12.3. Citirea datelor din fişier .......................................................... 217
12.3.1. Funcţia fgetc()................................................................... 218
12.3.2. Funcţia fgets()................................................................... 220
12.3.3. Funcţia fgetcsv() ............................................................... 222
12.3.4. Funcţia fgetss() ................................................................. 224
12.3.5. Funcţiile readfile(), file() şi file_get_contents()................. 226
12.4. Funcţii care permit testarea stării unui fişier............................ 229
12.4.1. Funcţia file_exists() .......................................................... 229
12.4.2. Funcţiile is_file() şi is_dir() .............................................. 230
12.4.3. Funcţiile is_readable(), is_writable() şi is_executable() .... 230
12.4.4. Funcţia filesize() ............................................................... 230
12.5. Funcţia include() ..................................................................... 232
CAPITOLUL 13
13. Directoare ..................................................................................... 239
13.1. Funcţia opendir() pentru deschiderea unui director ................. 239
13.2. Funcţia readdir() pentru citirea dintr-un director ..................... 240
13.3. Funcţia closedir() pentru închiderea unui director ................... 240
13.4. Funcţia rewinddir() pentru poziţionarea la începutul
directorului............................................................................. 241
13.5. Funcţia mkdir() de creare a directoarelor................................. 243
13.6. Funcţia chdir() de schimbare a directorului curent .................. 244
13.7. Funcţia getcwd() care indică directorul curent......................... 244
13.8. Funcţia rmdir() de ştergere a unui director .............................. 244
13.9. Funcţia scandir() pentru deschiderea, citirea şi închiderea
unui director ............................................................................ 248
13.10. Aplicaţii care utilizează funcţii ce manipulează fişiere
şi directoare ............................................................................ 251
11
Programarea în PHP
CAPITOLUL 14
14. Crearea şi prelucrarea bazelor de date MySql utilizând PHP......... 257
14.1. Conectarea la serverul de date MySql ..................................... 258
14.2. Selectarea unei baze de date.................................................... 261
14.3. Interogarea unei baze de date .................................................. 262
14.3.1. Crearea unei baze de date.................................................. 262
14.3.2. Crearea unei tabele într-o bază de date.............................. 263
14.3.3. Adăugarea datelor într-o tabelă ......................................... 265
14.3.4. Afişarea datelor dintr-o tabelă........................................... 267
14.3.5. Ştergerea datelor dintr-o tabelă ......................................... 271
14.3.6. Modificarea datelor dintr-o tabelă ..................................... 278
BIBLIOGRAFIE ........................................................................ 287
12
P H P
Capitolul 1
1. Introducere
1.1. PHP – scurt istoric
Limbajul PHP (Personal Home Page) este succesorul aplicaţiei

creeate de către programatorul danez Rasmus Lerdof în 1994, cu intenţia
principală de a contoriza numărul de vizitatori ai CV-ului său online. După
dezvoltări successive care au inclus elemente de interfaţă cu bazele de date
şi instrumente care permiteau crearea unor aplicaţii simple dinamice,
evoluţia PHP este puternic influenţată de Zeev Surasky şi Andi Gutmans,
fondatorii companiei Zend Technologies, Israel. Plecând de la rezultatele
obţinute de Rasmus Lerdof, aceştia dezvoltă un limbaj de programare web
numit tot PHP, dar având de data aceasta înţelesul dat de definiţia recursivă
PHP: Hypertext Preprocesor.
1.2. PHP - caracteristici de bază
Ajuns la versiunea a 5-a, limbajul PHP oferă utilizatorilor săi o gamă

largă de avantaje: este gratuit, este uşor de învăţat şi de folosit
(a împrumutat foarte mult din limbajele C şi Perl), poate fi utilizat pe o
varietate mare de platforme (Unix, Linux, Windows, Mac OS X etc.), are
13
Programarea în PHP
interfeţe pentru o mare parte din sistemele de gestiune a bazelor de date

utilizate în Internet (Oracle, Microsoft SQL Server, MySQL, Postgresql
etc.) este utilizat împreună cu diverse servere de Web (de exemplu Apache,
IIS (Internet Information Server), iPlanet) etc.
Aplicaţiile web care utilizează PHP funcţionează după următoarea
schemă generală (Figura 1.1):
Client Server web

Cereri
Aplicaţie
PHP
HTML
Figura 1.1. Schema de funcţionare a unei aplicaţii web care utilizează PHP
Practic, clientul (utilizatorul) realizează o cerere către serverul de

web pe baza unei adrese URL (Uniform Resource Locator). Acesta
utilizează modulul PHP pentru interpretarea codului PHP în linii de cod
HTML (HyperText Markup Language) şi trimiterea acestora înapoi către
browserul clientului. Browserul interpretează codul HTML şi-l
vizualizează pe calculatorul clientului sub forma paginilor web. Din cele
spuse se înţelege faptul că limbajul PHP este un limbaj pe parte de server
(side-server), adică prelucrează programele (scripturile) pe serverul web.
Denumirea de scripturi dată programelor PHP se datorează faptului că
translatarea codului se realizează prin interpretare. Dintre limbajele
importante destinate programării web amintim JSP (JavaServerPages) şi
ASP (Active Server Pages), pe parte de server şi JavaScript, pe parte de
client.
1.3. PHP – Noţiuni introductive
Pentru a putea fi executate, scripturile PHP trebuie să fie editate în

fişiere care au extensia .php. Scripturile conţin în mod normal cod PHP
înglobat (integrat) în cod HTML, iar la limită, numai cod PHP sau numai
cod HTML. Marcarea codului PHP se face cu ajutorul etichetelor <?php
14
Capitolul 1. Introducere
şi ?>. Practic, numai textul cuprins între aceste etichete va fi interpretat de

serverul PHP şi transformat în cod HTML. Acesta, împreună cu codul
HTML din exteriorul perechilor de etichete <?php şi ?> va fi transmis
browserului, care, în urma interpretării, afişează pagina web
corespunzătoare.
Observaţie. Etichetele <?php şi ?> se mai numesc şi etichete
standard. Sunt acceptate încă trei variante de etichete de marcare a codului
PHP : etichetele scurte <? şi ?>, etichetele în stil ASP (Active Server
Pages) <% şi %> şi etichetele de tip script, <SCRIPT LANGUAGE="php">
şi </SCRIPT>.
Pentru utilizarea etichetelor scurte trebuie ca flagul
short_open_tag din fişierul de configurare php.ini să fie setat On.
Analog, pentru utilizarea etichetelor ASP trebuie setat On flagul asp_tags
din acelaşi fişier php.ini. Recomandarea este să se folosească
întotdeauna etichetele standard şi cele de tip script, care funcţionează fără
condiţionări speciale şi, în plus, indică în mod explicit faptul că urmează
cod PHP.
În ceea ce priveşte stocarea efectivă a scripturilor avem două
posibilităţi:
ü Stocarea se face pe calculatorul utilizatorului, care are instalat PHP şi
o aplicaţie server, cum ar fi, Apache, IIS (Internet Information
Server), PWS (Personal Web Server) etc., în directorul rădăcină
(document root) al documentelor web. Accesul la un document din
acest director se face tastând în bara de adrese a browserului adresa
http://localhost/numefisier.
ü Stocarea se face pe un server, situat pe un alt calculator decât
calculatorul clientului. În acest caz, transportul fişierelor de la client
la server se poate face folosind aplicaţia FTP (File Transfer
Protocol).
Scripturile web la care facem referire în această lucrare sunt stocate
pe un server instalat pe calculatorul clientului.
Să presupunem că am creat scriptul 1.1.php, prezentat mai jos, pe
care l-am salvat în directorul rădăcină al serverului de web, care are
următorul următorul conţinut:
15
Programarea în PHP
Scriptul 1.1
<html>
<head>
<title>Scriptul 1.1</title>
</head>
<body>
<b>S-a executat scriptul numarul 1</b>
</body>
</html>
Acest script poate fi accesat sub forma http://localhost/1.1.php.

Rezultatul execuţiei este:
S-a executat scriptul numarul 1
Codul de mai sus este în întregime cod HTML. Textul S-a
executat scriptul numarul 1 a fost transmis pur şi simplu către
browser fără ca modulul PHP să facă vreo procesare. Pentru a trimite
acelaşi mesaj folosind cod PHP trebuie să folosim o funcţie de afişare, de
exemplu print(). Apelul funcţiei print(), ca de altfel apelul oricărei
funcţii PHP, este o instrucţiune PHP şi trebuie să se termine cu semnul
punct şi virgulă (;). Vom modifica scriptul 1.1.php astfel:
Scriptul 1.2
<html>
<head>
</head>
<body>
<?php
print "<b>S-a executat scriptul PHP numarul 1</b>";
?>
</body>
</html>
Executând scriptul astfel modificat obţinem acelaşi rezultat. În acest

caz, interpretarea în PHP nu a trebuit să aducă nimic nou textului procesat.
Însă, folosirea codului PHP permite crearea dinamismul atât de necesar
aplicaţiilor web, în foarte multe alte situaţii. De exemplu, dacă dorim să
afişăm şi ora execuţiei scriptului putem să înlocuim instrucţiunea print()
prin secvenţa:
print "<b>S-a executat scriptul PHP numarul 1 la data
de </b>";
16
Capitolul 1. Introducere
print date("j.m.Y");
Funcţia date() din PHP ne va furniza la fiecare execuţie a
scriptului data modificată corespunzător.
Elementele PHP pot fi integrate în blocuri separate de cod PHP în
cadrul unui script, ca în exemplul următor (Scriptul 1.3.php):
Scriptul 1.3
<head>
<title>
<?php
$n=1.3;
?>
</title></head>
<body>
<?
print "<b>S-a executat scriptul numarul $n</b>";
?>
</body>
</html>
Rezultatul execuţiei scriptului 1.3.php este:

S-a executat scriptul numarul 1.3
Se observă că variabila $n care ia valoarea 1.3 în primul fragment
de cod PHP se poate folosi fără probleme şi în cel de-al doilea fragment.
Comentariile prezente într-un script PHP pot fi de două tipuri:
ü comentarii la nivel de linie;
ü comentarii la nivel multilinie;
Comentariile la nivel de linie se specifică prin semnele // sau #.

Prezenţa lor într-o linie de program are următorul efect: textul delimitat de
unul din aceste semne şi sfârşitul liniei respective este considerat
comentariu. În cazul comentariilor multilinie, orice text cuprins între
semnele /* şi */ este considerat comentariu. Un astfel de comentariu se
poate întinde pe mai multe linii, dar nu poate fi imbricat (un comentariu nu
poate include un alt comentariu). Scriptul 1.4.php ilustrează tipurile
posibile de comentarii dintr-un script PHP.
17
Programarea în PHP
Scriptul 1.4
<html>
<head>
</head>
<body>
<?php
/* Acest script ilustreaza tipurile de comentarii
care sunt acceptate in limbajul PHP */
$x=2;
$y=4;
print "<br>x=$x"; // se va afisa x=2
print "<br>y=$y"; # se va afisa y=4
?>
</body>
</html>
18
P H P
Capitolul 2
2. Variabile, constante,
tipuri de date
O variabilă este un nume (identificator) care se asociază unei zone
de memorie în care pot fi memorate diverse valori. Conţinutul zonei de
memorie poate fi schimbat cu alte valori permise, ori de câte ori este
nevoie.
Spre deosebire de variabile, constantele sunt entităţi a căror valoare
rămâne neschimbată pe toată durata execuţiei unui script.
Atât variabilele cât și constantele aparţin unui tip de date. Un tip de
date indică mulţimea valorilor posibile precum şi operaţiile care se pot face
asupra acestor valori. În limbajul PHP sunt prezente următoarele tipuri de
date:
ü Tipuri de date scalare: integer, float, boolean, string;
ü Tipuri de date compuse: array, object;
ü Tipuri de date speciale: resource, NULL.
2.1. Variabile
Numele unei variabile PHP trebuie să fie alcătuit din litere, cifre sau
liniuţe de subliniere, primul caracter al numelui fiind obligatoriu o literă
19
Programarea în PHP
sau liniuţă de subliniere. În plus, numele trebuie să fie precedat de

semnul $.
Exemple
ü nume corecte de variabile:
$a, $A, $_abd 3, $pret_unitar, $_285a, $x_1
ü nume incorecte de variabile:
$3ac, $4_c, abc$, $ab-4
Numele unei variabile este dependent de capitalizare (case-

sensitive). Asta înseamnă că în exemplul de mai sus, $a și $A reprezintă
variabile diferite.
În principiu, înainte de utilizare, în limbajul PHP, variabilele trebuie
să fie iniţializate în mod explicit. Dacă se omite acest lucru, variabilele vor
fi iniţializate implicit cu valoarea zero, corespunzătoare tipurilor de date de
care aparţin: 0 pentru tipurile numerice integer și float, șirul vid
pentru tipul de date string, False pentru tipul de date boolean, vectorul
vid pentru tipul de date array.
În PHP tipul unei variabile nu este declarat explicit; el se schimbă în
funcţie de tipul valorii memorate. O cale simplă de a memora valori într-o
variabilă este utilizarea operatorului de atribuire (=). Astfel, în urma
atribuirii
$x=34;
variabila $x va conţine valoarea 34, iar tipul variabilei $x va fi integer.
Analog, în urma atribuirii
$x='xxx';
în variabila $x se va memora valoarea 'xxx', iar tipul ei se va schimba în
tipul string.
De regulă, o variabilă poate fi accesată doar în scriptul sau în funcţia
în care a fost definită. Se spune că scriptul sau funcţia respectivă reprezintă
domeniul de existenţă al variabilei, iar variabila este locală. Așa cum se va
vedea însă în capitolul 9, domeniul implicit al unei variabile poate fi
modificat astfel încât ea să devină globală, adică să poată fi partajată de mai
multe funcţii.
Limbajul PHP oferă programatorului un set de variabile globale
predefinite, numite variabile superglobale, ca de exemplu: $_POST,
20
Capitolul 2. Variabile, constante, tipuri de date
$_GET, $_COOKIE, $_SESSION etc. Acestea sunt disponibile permanent

în scripturile noastre și sunt foarte utile în aplicaţii. Definirea unor variabile
utilizator care încep cu grupul ’$_’ este nerecomandată deoarece numele
variabilei obţinute ar putea coincide cu numele unei variabile predefinite,
fapt ce ar produce eroare. Variabila predefinită $GLOBALS conţine toate
variabilele pe care le poate accesa scriptul, atât cele definite de utilizator
cât și cele predefinite.
2.2. Constante
Definirea unei constante se face cu ajutorul funcţiei predefinite

define(), conform sintaxei:
bool define(string nume_constanta,tip valoare,bool
cs); ,
unde:
ü nume_constanta este un identificator care reprezintă numele
constantei;
ü valoare reprezintă valoarea constantei; valoare poate să aparţină
numai unui tip de date scalar (integer,float,boolean,
string);
ü cs este un parametru opţional boolean care arată dacă numele
constantei este dependent sau nu de de capitalizare (case-sensitive
sau case-insensitive).
Funcţia define() întoarce valoarea True (adevărat) în caz de
succes și False (fals) în caz de insucces. Când parametrul cs lipsește sau
când este prezent și are valoarea False, numele constantei este dependent
de capitalizare. Prin convenţie, numele constantei definite se scrie cu litere
mari.
Exemplele de mai jos:
define ('ORAS','Ploiesti');
define ('MIEZUL_NOPTII',24);
definesc constantele ORAS şi MIEZUL_NOPTII care au valorile
'Ploiesti', respectiv 24. O dată ce au fost definite, constantele au un
21
Programarea în PHP
caracter global (pot fi accesate în orice parte a scriptului), nu pot fi

redefinite și, evident, nu pot fi modificate.
Limbajul PHP oferă posibilitatea folosirii unui număr de constante
predefinite , fapt ce poate ușura munca de programare. De exemplu,
constanta _LINE_ returnează numărul liniei dintr-un fişier, iar constanta
PHP_VERSION indică versiunea PHP folosită. Funcţia
get_defined_constants() furnizează numele și valorile tuturor
constantelor (definite sau predefinite) la care are avem acces la un moment
dat.
2.3. Tipuri de date
2.3.1. Tipuri de date scalare
Tipul de date integer acoperă o submulţime a mulţimii numerelor

întregi. Numărul de octeţi necesar reprezentării unui număr întreg este
dependent de implementare, dar în mod normal se folosesc 4 octeţi. Întregii
pot fi reprezentaţi într-una din bazele: baza 8 (octal), baza 10 (zecimal),
baza 16 (hexazecimal). Numerele întregi din baza 8 trebuie să fie precedate
de 0, iar cele din baza 16 de 0x sau de 0X. Pentru precizarea semnului se
folosesc operatorii plus (+) sau minus (-).
Exemple
ü în baza 8: 0564, 06612, 0136
ü în baza 10: 739, -24, +5694
ü în baza 16: 0x2B, 0x1AD, 0XAE29
Un întreg care depășeste valoarea maximă admisă pentru întregi va fi

tratat ca o entitate de tip float.
Tipul de date float (numit și double din motive istorice) acoperă o

submulţime a mulţimii numerelor reale. Numărul maxim de octeţi utilizaţi
pentru reprezentare este dependent de implementare, însă, în mod uzual, se
folosesc 8 octeţi. Valorile de tip float se reprezintă în baza 10,
utilizându-se atât notaţia uzuală (cu punct) cât şi notaţia exponenţială.
22
Exemple
ü în notaţie cu punct: – 2.3916, + 415, 63.945, – 0.329
ü în notaţie exponenţială: 1.2E4, – 9E-9, 0.52e+07
ü Notaţiile nE±k şi ne±k au înţelesul de n x 10±k. De exemplu,
1.2E+04 înseamnă 1.2x104, 0.3e-04 înseamnă 0.3x10-4 etc.
Tipul de date boolean se referă la valorile de adevăr adevărat şi

fals. Valoarea adevărat se specifică prin cuvântul cheie True, iar valoarea
fals, prin cuvântul cheie False. Ele pot fi scrise atât cu litere mici cât şi
cu litere mari (sunt insensibile la capitalizare). De exemplu, formele
FALSE, TRUE, false, true, False, True sunt variante corecte de
reprezentare a valorilor booleene.
Tipul de date string se referă la mulţimea șirurilor de caractere.

În limbajul PHP, șirurile de caractere se pot specifica în trei feluri:
ü folosind ghilimelele simple (apostrofuri);
ü folosind ghilimelele duble;
ü folosind sintaxa heredoc.
Specificarea unui şir folosind ghilimelele se poate face ca în
exemplul 'Acest sir e format din 35 caractere' sau ca în
exemplul "Acest sir e format din 35 caractere".
În sintaxa heredoc același șir se poate reprezenta astfel:
echo <<<ID
Acest sir e format din 35 caractere
ID;
unde simbolul <<< anunţă reprezentarea heredoc a șirului, iar ID este un
nume oarecare de identificator care delimitează șirul. Pentru a defini corect
șirul trebuie ca identificatorul care marchează sfârșitul șirului să înceapă pe
prima coloană a rândului și să fie urmat cel mult de caracterul punct și
virgulă (;).
Datorită faptului că ghilimelele (apostrofurile) marchează începutul
sau sfârșitul unui șir, nu este permisă folosirea ghilimelelor (apostrofurilor)
într-un șir definit cu ajutorul ghilimelelor (apostrofurilor). Astfel,
exemplele de mai jos:
'Sirul 'abc' e un exemplu de sir marcat cu
apostrofuri',
23
Programarea în PHP
"Sirul "cda" e un exemplu de sir marcat cu ghilimele"

sunt exemple incorecte de șiruri.
Este posibilă totuși prezenţa apostrofurilor și, respectiv, a
ghilimelelor în astfel de cazuri, dacă se plasează un caracter backslash (\)
în faţa acestora. În acest fel, exemplele:
'Sirul \'abc\' e un exemplu de sir marcat cu apostrofuri'
"Sirul \"abc\" e un exemplu de sir marcat cu ghilimele"
sunt exemple corecte de șiruri.
De asemenea, se pot folosi ghilimelele (apostrofurile) în cadrul unui
șir marcat cu apostrofuri (ghilimele). În consecinţă, și exemplele de mai jos
sunt exemple corecte de șiruri:
"Sirul 'abc' e un exemplu de sir marcat cu
apostrofuri",
'Sirul "cda" e un exemplu de sir marcat cu ghilimele'.
Șirul vid se poate reprezenta într-una din formele : '' , "" sau
<<<ID
ID;
2.3.2. Tipuri de date compuse
Tipul de date array permite reprezentarea tablourilor. În PHP,

terminologia echivalentă pentru tablou este vector, matrice sau chiar array.
În această lucrare vom folosi terminologia de vector.
Accesul la datele vectorului se face cu ajutorul cheilor, care pot fi de
tip integer sau string. În cazul când valorile cheilor sunt booleene
(True sau False), acestea vor fi convertite la valorile întregi 1, respectiv
0. Valorile cheilor nu pot fi de tip array sau de tip object. Dacă valorile
unui vector sunt scalare vectorul se numește unidimensional, iar în cazul
în care sunt de tip array, vectorul se numește multidimensional.
Un vector se poate reprezenta cu ajutorul construcţiei de limbaj
array, într-una din formele:
ü array(val_1, val_2, val_3,...,val_n)
sau
ü array(cheie_1=>val_1, cheie_2=>val_2,
cheie_3=>val_3,...,cheie_n=>val_n)
24
unde:
ü val_1, val_2, val_3,...,val_n reprezintă valori care se
memorează în vector, însoţite eventual de cheile corespunzătoare,
dacă vectorul este multidimensional;
ü cheie_1, cheie_2, cheie_3,...,cheie_n sunt cheile de
identificare a acestor valori.
Un vector în care nu se memorează nici o valoare se numește vector
vid. Un vector vid se reprezintă printr-o listă vidă de componente, adică
sub forma array(). Cheile unui vector pot fi de tip integer, de tip
string sau mixte .
O cheie de de tip integer, arată poziţia valorii care ne interesează
în cadrul vectorului. În acest caz, în locul cuvîntului cheie se poate folosi
cuvîntul indice (index). De asemenea, se spune că vectorul este indexat.
Exemplu. Instrucţiunea
$x=array(1=>23, 3=>456, 5=>-67);
creează tabloul $x cu valorile 23,456,-67. Referirea la aceste valori se
face sub forma $x[1], $x[3] și respectiv $x[5].
Așa cum se vede și din sintaxă, prezenţa cheilor nu este obligatorie.
Dacă toate cheile lipsesc, celor n valori prezente li se vor asocia implicit de
la stânga la dreapta indicii 0,1,2,...,n-1. De exemplu, construcţia
$tricolor=array('rosu','galben','albastru');
se poate scrie echivalent
$tricolor=array(0=>'rosu',1=>'galben',2=>'albastru');
O formă echivalentă de generare a unui vector se poate realiza prin
setarea explicită a valorilor vectorului, folosind operatorul [], conform
sintaxei:
$nume_vector[cheie]=valoare;
unde cheie poate lipsi.
Astfel, vectorul $x se poate genera executând secvenţa de
instrucţiuni:
$x[1]=23;
$x[3]=456;
$x[5]=-67;
25
Programarea în PHP
În cazul în care cheile lipsesc, indicii vor fi generaţi automat

începând cu valoarea 0. De exemplu, în urma execuţiei codului PHP de mai
jos
$saptamana[ ] ='luni';
$saptamana[ ] ='marti';
...............
$saptamana[ ] ='duminica';
se va genera un vector cu 7 componente care va conţine zilele săptămânii.
Practic, construcţia este echivalentă cu
$saptamana=array('luni','marti','miercuri','joi','vine
ri','sambata','duminica');
Când în lista array există cel puţin o valoare cu indice de tip
integer, atunci unei valori fără indice i se va asocia automat un indice
egal cu cel mai mare indice din listă întâlnit până la momentul evaluării,
plus 1. Ordinea de definire a indicilor într-o listă array se face de la
stânga spre dreapta. Dacă un indice este definit de mai multe ori, valoarea
sa se va suprascrie de fiecare dată.
Exemplu
$culori=array('alb','albastru',3=>'verde',
1=>'negru','rosu');
Ţinând cont de cele spuse mai sus vom avea succesiv asocierile:
0=> 'alb'
1 =>'albastru'
3=>'verde'
1=>'negru' (valoarea 'negru' se va suprascrie peste 'albastru')
4 =>'rosu' (valoarea 4 se obţine din cea mai mare valoarea de indice
existentă, adică 3, la care se adaugă 1).
Pentru a mări lizibilitatea programului, este recomandabil ca numele
unei chei să fie ales astfel încât să exprime o anumită asociere naturală cu
valoarea corespunzătoare memorată în vector. În acest caz se pot folosi chei
de tip string, iar vectorul astfel obţinut se numește vector asociativ.
$capitala=array("Romania"=>"Bucuresti","Franta"=>"Pari
s","Anglia"=>"Londra");
creează vectorul asociativ $capitala. Același rezultat se obţine prin
execuţia instrucţiunilor:
26
$capitala["Romania"]="Bucuresti";
$capitala["Franta"]="Paris";
$capitala["Anglia"]="Londra";
Un alt exemplu:
$situatie=array('nume'=>'Ion','prenume'=>'Gheorghe','n
ota'=>8);
Exemplul de mai sus se poate rescrie, pentru claritate, astfel:
$situatie=array(
'nume'=>'Ion',
'prenume'=>'Gheorghe',
'nota'=>8
);
Cheile unui vector pot fi mixte, adică atât de tip integer cât și de
tip string, după cum se poate constata în exemplul de mai jos:
$x=array(3=>67,'a'=>5,'b'=>-7);
Referirea la valorile 67, 5 și -7 se face sub forma $x[3], $x['a']
și respectiv $x['b'].
Vectorii prezentaţi până în prezent au fost vectori unidimensionali.
Mai jos, prezentăm un exemplu de vector multidimensional.
Exemplu.Tabloul extras_catalog, de mai jos (Figura 2.1).
nume prenume nota

1 Ion Gheorghe 8
2 Popescu Vasile 7
3 Ionescu Gabriela 10
Figura 2.1. Tabloul extras_catalog
poate fi modelat în PHP sub forma:

$extras_catalog=array(
1=>array(
'nume'=>'Ion',
'nota'=>8
),
2=>array(
'nume'=>'Popescu',
'prenume'=>'Vasile',
27
Programarea în PHP
'nota'=>7
),
3=>array(
'nume'=>'Ionescu',
'prenume'=>'Gabriela',
'nota'=>10
),
);
Referirea la elementele unui tablou multidimensional se face

utilizând mai multe chei (câte una pentru fiecare dimensiune).
De exemplu,
$extras_catalog[2][ 'nota'] are valoarea 7,
$extras_catalog[3]['nume'] are valoarea 'Ionescu',
$extras_catalog[1]['prenume'] are valoarea 'Gheorghe'.
Tipul de date object permite utilizarea facilităţilor oferite de

programarea orientată pe obiecte. Modul de lucru cu clase și obiecte,
precum și alte concepte importante din programarea orientată pe obiecte,
implementate în PHP, vor fi prezentate mai pe larg în Capitolul 10. În cele
ce urmează vom face doar o foarte scurtă prezentare a conceptelor de clasă
și obiect.
Clasa este o colecţie de variabile și funcţii care prelucrează aceste
variabile. Variabilele dintr-o clasă se mai numesc proprietăţi, iar funcţiile
metode. Variabilele dintr-o clasă pot conţine valori scalare, vectori sau
obiecte. O clasă poate fi privită ca un șablon (template), iar un obiect ca o
variabilă care reprezintă o instanţă a unei clase. Spre deosebire de celelalte
tipuri de date, în cazul tipului de date object, variabilele (obiectele) de
acest tip trebuie să fie declarate explicit. Prezentăm mai jos, schematizat,
un exemplu de declarare a unei clase și a unui obiect.
//declaratia clasei
class complex {
var $x;
var $y;
function adunare_complex($x , $y) {
//corpul functiei
}
function inmultire_complex($x, $y) {
28
//corpul functiei
}
}
//declaratia obiectului
$z=new complex;
Cuvântului cheie class permite declaraţia clasei, declaraţia
variabilelor clasei se face cu ajutorul cuvântului cheie var, iar declaraţia
obiectului $z cu ajutorul operatorului new. Funcţiile
adunare_complex() şi înmultire_complex() sunt metode ale clasei
complex.
2.3.3. Tipuri de date speciale
Tipul de date NULL are o singură valoare, valoarea NULL. Cuvântul

cheie NULL nu este sensibil la capitalizare (de exemplu, se poate folosi și
forma null). O variabilă are valoarea NULL în următoarele situaţii:
ü variabilei i s-a atribuit valoarea NULL:
ü variabilei nu i s-a atribuit încă o valoare;
ü variabila a fost distrusă (cu ajutorul funcţiei unset()).
Tipul de date resource se referă la valori speciale, cum ar fi:

indicele unei conexiuni la o bază de date, valoarea unui pointer la fișier,
valoarea unui manipulator (handle) de directore etc. După cum se poate
constata, aceste valori fac referire la resursele externe ale PHP și pot fi
accesate prin intermediul unor funcţii ce vor fi prezentate în capitolele 12,
13 și 14. Nici un alt tip de date nu poate fi convertit la un tip de date
resource.
29
P H P
Capitolul 3
3. Operatori și expresii
Expresia este o combinaţie validă de operanzi (variabile, constante,
funcţii) şi de operatori. Operatorii indică ce operaţii trebuie făcute pentru
evaluarea expresiei. Ordinea de evaluare a expresiei este dată de priorităţile
operatorilor săi. Această ordine, reflectată în clase de precedenţă, poate fi
schimbată cu ajutorul parantezelor rotunde.
3.1. Clase de precedenţă
O clasă de precedenţă reuneşte operatorii care au aceeaşi prioritate.

Lista operatorilor grupaţi în clase de precedenţă este dată în Tabelul 3.1.
Clasele de precedenţă sunt listate în ordinea descrescătoare a priorităţilor.
Astfel, operatorul new are cea mai mare prioritate, iar operatorul virgulă (,)
cea mai mică prioritate.
Tabelul 3.1. Clase de precedenţă

Nr.
Clasa Operatori
crt.
1. definire obiect al unei clase new
2. paranteze pătrate [ ]
3. incrementare / decrementare ++ --
31
Programarea în PHP
Tabelul 3.1. (continuare)

operatori de negaţie la nivel
~ - (int)(float)(string)
4. de bit, negaţie aritmetică şi (array) (object)(bool)@
conversie
5. operatori de negaţie logică !
operatori aritmetici
6. * / %
multiplicativi
operatori aritmetici aditivi şi
7. + - .
de concatenare stringuri
operatori shift (stânga și
8. << >>
dreapta)
9. operatori de comparaţie < <= > >= <>
10. operatori de comparaţie == != === !==
11. ŞI pe bit, referinţă &
12. SAU exclusiv bit cu bit ^
13. SAU bit cu bit |
14. ŞI logic &&
15. SAU logic ||
16. operatorul condiţional ?:
= += -= /= *= .= %=
17. operatori de atribuire &= |= ^= <<= >>=
18. ŞI logic and
19. SAU logic exclusiv xor
20. SAU logic or
21. operatorul de secvenţiere ,
Observaţii
ü Atât pentru conjuncţie (ŞI) cât și pentru disjuncţie (SAU) sunt
prevăzuţi câte doi operatori, situaţi însă în clase de precedenţă
diferite;
ü Fiecare dintre operatorii prezentaţi în tabel poate fi asociativ la
stânga, asociativ la dreapta sau neasociativ. Pentru operatorii care au
aceeaşi clasă de precedenţă asociativitatea la stânga implică
evaluarea de la stânga la dreapta a expresiei, iar asociativitatea la
dreapta, evaluarea în sens invers.
Exemple. Operatorii aritmetici aditivi au asociativitate la stânga:

$e=$x+$y+$z; este echivalentă cu $e=($x+$y)+$z;
Operatorii de atribuire au asociativitate la dreapta:
32
Capitolul 3. Operatori și expresii
$x=$y=3; este echivalentă cu $x=($y=3);
3.2. Operatori aritmetici
Operatorii aritmetici sunt binecunoscuţi: - (negaţie), + (adunare), -

(scădere), * (înmulţire), / (împărţire), % (modulo). Ei operează asupra
datelor de tip integer şi float.
Operatorul modulo %, furnizează restul împărţirii unui întreg la alt
întreg, ca în secvenţa de program următoare:
$a = -7;
$b = 5;
$c = $a%$b;
În urma execuţiei acestei secvenţe, valoarea variabilei $c va fi -2
(rezultatul va avea semnul deîmpărţitului).
Reguli de conversie automată

Dacă ambii operanzi sunt de tip integer, rezultatul va fi de tip
integer, cu o excepţie: dacă operatorul folosit este operatorul de
împărţire (/), atunci rezultatul va fi de tip float.
Cu alte cuvinte, în urma execuţiei secvenţei de program:
$a = 5;
$b = 2;
$c = $a /$b;
variabilei $c i se va atribui valoarea 2.5.
Dacă un operator este de tip integer sau float, iar celălalt este de
tip float, atunci rezultatul obţinut va fi de tip float, cu o excepţie: dacă
operatorul folosit este %, atunci, înainte de a se efectua operaţia, operanzii
de tip float vor fi convertiţi la valori întregi. Conversia unei valori de tip
float la o valoare întreagă se face rotunjind spre valoarea 0 numărul real
considerat. De exemplu, conversia într-o valoare întreagă a numărului
7.67 este 7, a numărului -5.62 este -5, a numărului -3.42 este -3 etc.
În situaţia în care operanzii nu aparţin unui tip numeric, aceștia vor fi
convertiţi la un tip numeric, înainte de a se efectua operaţiile, după cum
urmează:
33
Programarea în PHP
ü Dacă șirul începe cu un subșir care reprezintă un număr întreg sau

real atunci valoarea rezultată este acel număr, iar în caz contrar
valoarea 0. Dacă operandul este de tip boolean atunci valoarea
booleană True se convertește la valoarea 1, iar valoarea booleană
False se convertește la valoarea 0;
ü Valoarea NULL se convertește la valoarea 0, iar o valoare de tip
resource se convertește la numărul resursei respective.
3.3. Operatori de comparaţie
Operatorii de comparaţie permit comparaţia dintre doi operanzi.

Rezultatul comparaţiei poate fi True sau False. Operatorii de comparaţie
din PHP sunt: < (mai mic), <= (mai mic sau egal), > (mai mare), >= (mai
mare sau egal), == (egalitate), != și <> (pentru neegalitate), operatorul
identitate (===) şi operatorul neidentitate (!==). Când se folosesc ultimii
doi operatori se compară atât valorile operanzilor cât si tipurile de date ale
acestora. Astfel, expresia de forma $a===$b va lua valoarea True dacă şi
numai dacă $a şi $b au aceeaşi valoare şi sunt de acelaşi tip.
De exemplu, după atribuirile
$a = 6; $b = 6.0;
valoarea expresieiei $a===$b va fi False deoarece variabilele $a şi $b
sunt de tipuri diferite: $a este de tip integer, iar $b este de tip float.

Sunt două categorii de operatori de comparaţie:
ü Operatori care permit, dacă este necesar, conversia automată a
operanzilor: < <=> >= == !=. În acest caz, dacă un operand este
de tip numeric, iar celălalt este de alt tip, atunci șirul va fi convertit
mai întâi la tipul numeric respectiv și apoi se va face comparaţia.
ü Operatori de comparaţie care nu permit conversia automată a
operanzilor: === !== .
În ambele situaţii, dacă operanzii sunt de tip string, comparaţia lor
se face lexicografic.
34
3.4. Operatori logici
Operatorii logici se pot aplica valorilor de tip boolean False sau

True și în general oricărei expresii care prin evaluare poate lua valoarea
False sau True. Lista operatorilor logici este următoarea:
! pentru negaţie;
&& și and pentru conjuncţie (operaţia ȘI);
|| și or pentru disjuncţie (operaţia SAU);
xor pentru disjuncţie exclusivă (operaţia SAU exclusiv).
Modul de acţiune al acestor operatori este sintetizat în tabelul 3.2

unde prin T am notat valoarea True, iar prin F valoarea False.
Tabelul 3.2. Operaţii de bază cu valori booleene

$a && $b $a || $b
$a $b $a xor $b ! $a
$a and $b $a or $b
F F F F F T
F T F T T T
T F F T T F
T T T T F F

Operatorii logici operează întotdeauna cu valorile de tip boolean
True și False. În cazul în care valorile asupra cărora operează sunt de alt
tip, acestea vor fi convertite la tipul boolean, după cum urmează:
ü Sunt convertite la valoarea False: valoarea de tip integer 0,
valoarea de tip float 0.0, șirul vid "" și șirul nul "0", valoarea
NULL și tabloul cu 0 elemente;
ü Sunt convertite la valoarea True: valorile de tip integer și de tip
float diferite de zero, orice șir diferit de șirul vid și de șirul nul,
tablourile care au cel puţin un element și valorile de tip object și
resource.
35
Programarea în PHP
3.5. Operatorul de concatenare
Operatorul de concatenare a șirurilor este punctul (.). Efectul unei

concatenări de genul "Orasul "."Ploiesti" va fi lipirea operandului
drept la operandul stâng, adică va rezulta șirul "Orasul Ploiesti".
Operanzii sunt de regulă de tip string, însă pot fi și expresii, lucru care
facilitează afișarea inteligibilă a rezultatelor. De exemplu, afișarea
variabilei $b în urma evaluării secvenţei de program
$a=10;
$b="Nota=".$a;
va produce rezultatul Nota=10.

Operatorul de concatenare operează întotdeauna cu șiruri. Dacă
operanzii care se concatenează nu sunt șiruri, ei vor fi mai întâi convertiţi
la tipul de date string. Conversia la tipul de date string se face astfel:
ü Valorile booleene True și False se convertesc la valorile string "1"
respectiv "0".
ü Numerele întregi și reale se convertesc în șirurile de caractere
corespunzătoare. De exemplu, 45 se convertește în "45", -342 în
"-342", 41.79 în "41.79", -0.4e+03 în "0.4e+03" etc.
Valoarea NULL se convertește în "" (șirul vid), o valoare de tip
array în șirul "Array", un obiect în șirul "Object", iar o valoare de tip
resource în șirul "Resource id # număr resursă".
3.6. Operatori la nivel de bit
Limbajul PHP permite manevrarea biţilor unui intreg sau a codurilor

ASCII corespunzătore caracterelor unui șir de caractere cu ajutorul
următorului set de operatori:
36
& ŞI pe bit ;
| SAU exclusiv pe bit ;
~ NU pe bit (complement faţă de 1) ;
>> deplasare dreapta (shift dreapta);
<< deplasare stânga (shift stânga).
Tabelul 3.3 arată modul de acţiune ale operatorilor, &,|,^ și ~

asupra variabilelor bit a și b, pentru toate combinaţiile posibile.
Tabelul 3.3. Operatori de bază la nivel de bit

a b a&b a|b a^b ~a
0 0 0 0 0 1
0 1 0 1 1 1
1 0 0 1 1 0
1 1 1 1 0 0
Pentru exemplificare considerăm două variabile $a și $b, astfel încât

$a=43 și $b =9. Atunci, ţinând cont de regulile din Tabelul 3.3 și de
faptul că în baza 2, $a=101011 și $b=1001 avem:
0010 1011 0010 1011

0000 1001 0000 1001
$a&$b = 0000 1001 $a|$b = 0010 1011
0010 1011
0000 1001 0010 1011
$a^$b = 0010 0010 ~$a = 1101 0100
Să considerăm acum cazul în care operanzii care intervin sunt șirurile

de caractere $sir1 și $sir2. Notând operatorul cu op, fiecare caracter din
șirul $sir1op$sir2 este obţinut prin aplicarea operatorului op asupra
caracterelor corespunzătoare din ambele șiruri (situate pe aceeași poziţie).
A aplica operatorul op asupra a două caractere înseamnă de fapt a-l aplica
asupra codurilor ASCII corespunzătoare.
Dacă sirurile $sir1 și $sir2 au lungimi diferite atunci:
37
Programarea în PHP
ü în cazul operatorului & și ^ șirul rezultat se trunchează la cel mai

scurt operand;
ü în cazul operatorului | se completează cu zero operandul cel mai
scurt, iar rezultatul va avea lungimea celui mai lung operand.
Exemplu. Dacă $a="rac" și $b="arce", atunci, ţinând cont de
codurile ASCII ale caracterelor care compun cele două șiruri ("a" are codul
97 în zecimal și 0110 0001 în binar, "c" are codul 99 în zecimal și 0110
0011 în binar, "e" are codul 101 în zecimal și 0110 0101 în binar, "r" are
codul 114 în zecimal și 01110010 în binar), obţinem:
$a&$b=``c
$a^$b=
$a|$b= ssce
3.7. Operatori de atribuire

și de incrementare/decrementare
Operatorul de atribuire este reprezentat prin semnul = și a fost deja

folosit în prezentarea exemplelor din acest capitol și din capitolele
precedente. Există două moduri de atribuire: atribuire prin valoare și
atribuire prin referinţă.
Atunci când trebuie să atribuim valoarea unei expresii unei variabile
vom utiliza atribuirea prin valoare reprezentată sub forma
$v=expr;
unde $v este numele variabilei, iar expr este numele expresiei.
Se spune că $v este membrul stâng al atribuirii, iar expr este
membrul drept al atribuirii. O dată efectuată atribuirea, variabila $v va avea
ca tip, tipul expresiei expr.
Exemple
$a=3;// $a este de tip integer
$b=7.5;//$b este de tip float
$c=True;// $c este de tip boolean
$d="abc";// $d este de tip string
38
Atribuirea prin referinţă permite ca aceeași zonă de memorie să

poarte nume diferite. Ca exemplu, să considerăm următoarea secvenţă de
program:
$a=5;
$a=&$b;
Expresia $a=&$b; este o atribuire prin referinţă. Datorită prezenţei
operatorului de referenţiere &, variabilele $a și $b vor avea același
conţinut, adică valoarea 5.
Este posibilă prezenţa mai multor operatori de atribuire în cadrul
unei expresii, ca în exemplul de mai jos:
$y=5;
$z=2;
$x=($w=$y+3)*$z;
Se obţine $w=5+3=8 și în final $x=8*2=16.
De asemenea, este permisă atribuirea multiplă; de în exemplu,
execuţia instrucţiunii
$a=$b=$c=3;
are ca efect iniţializarea cu valoarea 3 a variabilelor $a, $b și $c.
Operatorul de atribuire = poate fi combinat cu operatorii +, -, *, /, .,
%, &, |, ^, <<, >>, obţinându-se, respectiv, operatorii de atribuire compuși
+=, -=, *=, /=, .=, %=, &=, |=, ^ =, <<=, >>= . Acești operatori permit
scrierea mai compactă a codului. Astfel, construcţia
$v=$v op expr;
unde $v este variabilă, expr este o expresie, iar op este unul din
operatorii +, -, *, /, ., %, &, |, ^, <<, >>, poate fi scrisă echivalent sub forma
$v op= expr;
De exemplu, în loc de $s=$s+7; se poate scrie $s+=7;, în loc de
$d=$d-3; se poate scrie $d-=3; și așa mai departe.
Tot în ideea simplificării scrierii programelor, pot fi folosiţi și
operatorii ++ (incrementare ) și --(decrementare).
Aplicat unei variabile, operatorul de incrementare ++ mărește
valoarea acesteia cu o unitate. În mod analog, operatorul de decrementare --
micșorează cu o unitate valoarea variabilei căreia i se aplică. Mai precis,
expresia
$x=$x+1; se poate scrie echivalent $x++; sau ++$x;
39
Programarea în PHP
iar expresia $x=$x-1; se poate scrie echivalent $x--; sau --$x;

Operatorul ++ se numește operator pre-increment dacă cele două
semne plus preced operandul și post-increment, dacă cele două semne plus
succed operandul. Plecând de la operatorul --, se definesc în mod analog
operatorii pre-decrement și post-decrement. Regula care diferenţiază modul
de funcţionare al operatorilor care preced operandul faţă de operatorii care
succed operandul este următoarea: operatorul pre-increment/pre-decrement
mărește/micșorează valoarea variabilei cu o unitate și apoi returnează
valoarea acesteia, în timp ce operatorul post-increment/post-decrement
returnează mai întăi valoarea variabilei și apoi mărește/micșorează valoarea
acesteia cu o unitate.
Exemple
//Operator pre-increment //Operator post-increment

$x=5; $x=5;
$y=++$x; $y=$x++;
//Rezultat: $x=6 și $y=6; // Rezultat: $y=5 și $x=6
//Operator pre-decrement //Operator post-decrement

$x=5; $x=5;
$y=--$x $y=$x--;
//Rezultat: $x=4 și $y=4 // Rezultat : $y=5 și $x=4;
Observaţie. Deoarece operatorii ++și -- modifică prin definiţie

operandul, acesta trebuie să fie obligatoriu o variabilă.
40
3.8. Operatorul cast – conversii

explicite de tip
Operatorul de conversie (cast) permite conversia valorii unei

variabile la tipul de date dorit. Ca și în limbajul C, conversia are un caracter
local, în sensul că nu afectează tipul unei variabile, ci tipul valorii acesteia.
Operatorul de conversie are forma
(tip)expresie;
unde tip reprezintă tipul de date la care se convertește valoarea expresiei
și poate lua una din valorile:
ü int sau integer conversie la tipul de date integer;
ü float,double sau real conversie la tipul de date float;
ü bool sau boolean conversie la tipul de date boolean;
ü string conversie la tipul de date string;
ü array conversie la tipul de date array;
ü object conversie la tipul de date object.
Exemplu. În urma execuţiei secvenţei de mai jos, variabila $x va fi

iniţializată cu valoarea reală 2.5, variabila $y cu valoarea întreagă 2, iar
variabila $z cu valoarea string "2.5".
$x=5/2;
$y=(integer)$x;
$z=(string)$x;
Observaţie. Conversia explicită a unei variabile $v la tipul de date

string se mai poate face scriind pur și simplu numele variabilei între
ghilimele, adică "$v".
41
P H P
Capitolul 4
4. Instrucţiuni de control
în PHP
Instrucţiunile de control din limbajul PHP se clasifică astfel:
ü instrucţiunii de atribuire şi apeluri de funcţie;
ü instrucţiunea vidă;
ü instrucţiuni de decizie;
ü instrucţiuni iterative;
ü instrucţiuni de salt.
O instrucţiune compusă sau instrucţiune grup se obţine prin gruparea
mai multor instrucţiuni între acolada stângă { şi acolada dreaptă }.
Utilitatea ei apare atunci când logica programului impune folosirea mai
multor instrucţiuni, însă sintaxa cere prezenţa unei singure instrucţiuni.
Sintaxa multor instrucţiuni PHP este identică sau asemănătoare cu
cea a instrucţiunilor C. O instrucţiune se încheie prin punct și virgulă (;).
4.1. Instrucţiuni de atribuire, apeluri

de funcţii, instrucţiunea vidă
Instrucţiunile de atribuire sunt de forma

$v = e;
43
Programarea în PHP
unde:
ü $v este o variabilă;
ü e este o expresie validă în PHP.
Rezultatul evaluării expresiei e se atribuie variabilei $v; de asemenea, aşa
cum s-a văzut în Capitolul 2 variabila $v preia tipul expresiei e.
De exemplu, în urma execuţiei instrucţiunii:
$x=3+5.2;
variabila $x va primi valoarea 8.2, iar tipul ei va fi numeric. Dacă vom
continua cu
$x="PHP";
variabilei $x i se va atribui şirul de caractere "PHP";, iar tipul ei va fi tipul
de date string.
O instrucţiune apel de funcţie are forma:
nume_functie (lista de parametri);
Efectul ei constă în apelarea funcţiei nume_functie cu valorile
parametrilor efectivi din lista de parametri.
De exemplu, apelul
echo "Lista notelor este următoarea";
va avea ca efect afişarea în browser a mesajului dintre ghilimele.
Atunci când sintaxa impune într-un anumit loc prezenţa unei
instrucţiuni, dar aceasta lipseşte, se consideră că acolo se află o
instrucţiune vidă. Un prim exemplu de instrucţiune vidă apare în
construcţia
$x=;
Aici, între operatorul = şi semnul ; este o instrucţiune vidă.
4.2. Instrucţiuni de decizie
4.2.1. Instrucţiunea if
Instrucţiunea if are următoarea sintaxă:

if (expresie) {
instrucţiuni;
}
44
Capitolul 4. Instrucţiuni de control în PHP
Efectul ei constă în execuţia blocului de instrucţiuni numai

dacă valoarea de adevăr pentru expresie este True.
Oricare ar fi valoarea pentru expresie, execuţia programului se
continuă cu prima instrucţiune care urmează acestei structuri.
Exemplu. În scriptul 4.1.php se compară valoarea variabilei $nota

cu 5 şi se afişează mesajul Rezultat:Admis, deoarece expresia $nota
>= 5; este adevărată.
Scriptul 4.1
<html>
<head>
<title >Scriptul 4.1</title>
</head>
<body>
<?php
$nota=6;
if ($nota >= 5) {
echo "Rezultat: Admis";
}
?>
</body>
</html>
Instrucţiunea if prezentată mai sus se mai numeşte şi instrucţiune

if cu ramură vidă. Dacă în loc de
$nota = 6;
am pune
$nota = 4;
în browser nu ar apărea nici un mesaj. Instrucţiunea if_else, pe care o
prezentăm în secţiunea următoare are două ramuri, fapt ce permite tratarea
ambelor situaţii ($nota>=5 şi $nota<5).
4.2.2. Instrucţiunea if_else
Instrucţiunea if_else (prescurtarea pentru „instrucţiunea if care

utilizează clauza else”) are următoarea sintaxă:
if (expresie) {
instructiune_1;
} else {
45
Programarea în PHP
instructiune_2;
}
Efectul instrucţiunii este următorul: dacă expresie are valoarea True
se execută instructiune_1, în caz contrar (expresie are valoarea
False) se execută instructiune_2.
Exemplu. Scriptul 4.2.php compară valoarea variabilei $nota cu 5
şi afişează mesajul Rezultat: Admis dacă $nota>=5 şi
Rezultat:Respins în caz contrar ($nota<5).
Scriptul 4.2
<html>
<head>
</head>
<body>
<?php
$nota=4;
if ($nota >= 5) {
echo "Rezultat: Admis";
} else {
echo "Rezultat: Respins";
}
?>
</body>
</html>
Deoarece valoarea variabilei $nota este 4, valoarea de adevăr a

variabilei $nota>=5 este False şi deci se va executa instrucţiunea echo
"Rezultat:Respins"; . Mesajul care se va afişa este Rezultat:
Respins.
4.2.3. Instrucţiunea if_elseif
Să presupunem că dorim să nuanţăm mesajele care apar în legătură

cu valoarea variabilei $nota. Mai concret, dorim să se afişeze următoarele
mesaje, în funcţie de valorile variabilei $nota:
Nesatisfacator, dacă 1 <= $nota <= 4;
Rezultat:Satisfacator, dacă $nota = 5;
Rezultat:Bine, dacă 6 <= $nota <= 7;
46
Rezultat:Foarte bine, dacă 8 <= $nota <= 10.

Pentrurealizarea acestor cerinţe vom folosi instrucţiunea
if_elseif care are forma generală:
if(expresie_1)
instructiune_1;
elseif(expresie_2)
instructiune_2;
elseif(expresie_3)
instructiune_3;
....................
elseif(expresie_n)
instructiune_n;
else
instructiune_n+1;
Execuţia instrucţiunii if_elseif începe prin evaluarea

expresie_1. Dacă expresie_1 are valoarea True se execută
instructiune_1. Dacă însă aceasta are valoarea False se testează
expresie_2. Dacă expresie_2 are valoarea True se execută
instructiune_2, în caz contrar se execută intructiune_3 etc.
Observaţie. Clauza elseif se poate folosi şi în forma else if
(cu pauza între else şi if).
Rezolvarea problemei prezentate se poate face folosind scriptul
4.3.php.
Scriptul 4.3
<html>
<head>
</head>
<body>
<?php
$nota = 4;
if ($nota >= 8) {
echo "Rezultat:Foarte bine";
} elseif ($nota >= 6) {
echo "Rezultat:Bine ";
} elseif ($nota = 5) {
echo ("Rezultat:Satisfacator");
47
Programarea în PHP
Scriptul 4.3 (continuare)

} else {
echo "Nesatisfacator";
}
?>
</body>
</html
Rezultatul execuţiei scriptului 4.3 este: Nesatisfacator.
4.2.4. Instrucţiunea switch
Sunt frecvente cazurile în care este nevoie să se execute o porţiune

de cod în funcţie de valorile unei variabile sau expresii. În această situaţie,
în locul structurii if_elseif prezentată mai sus este recomandată
folosirea instrucţiunii switch.
Instrucţiunea switch are următoarea sintaxă:
switch(expresie) {
case valoare_1: instructiuni_1; break;
case valoare_2: instructiuni_2; break;
. . . . . . . . . . . . . . . . . . . . . .
case valoare_n: instructiuni_n; break;
default: instructiuni_n+1; break;
}
Execuţia instrucţiunii switch începe prin evaluarea expresiei
expresie. Rezultatul se compară cu valoare_1. Dacă cele două valori
(rezultatul evaluării pentru expresie şi valoare_1) sunt egale se
execută instructiuni_1 şi apoi instrucţiunea break. Execuţia
instrucţiunii break are ca efect saltul la prima instrucţiune care urmează
structurii switch.
Dacă valoarea expresiei expresie_1 nu este egal cu valoare_1
atunci se testează egalitatea dintre valoarea expresiei expresie şi
valoare_2 etc.
În cazul în care valoarea expresiei expresie nu este egală cu nici
una din valorile valoare_1, valoare_2, …, valoare_n, se execută
instrucţiunile care urmează etichetei default (dacă aceasta există) şi se
iese din structură.
48
Observaţii
ü Entităţile expresie, valoare_1, valoare_2, …, valoare_n
pot fi de tip numeric, de tip string sau boolean.
ü Instrucţiunea break este o instrucţiune de salt. Utilizarea ei în
cadrul structurii switch este opţională. Când este prezentă, ea
realizează saltul în afara acestei structuri. Lipsa instrucţiunii break
determină execuţia în secvenţă a instrucţiunilor prezente în switch
până la prima instrucţiune de salt întâlnită, iar dacă aceasta nu există,
până la sfârşitul structurii switch.
Exemplu. Scriptul 4.4.php afişează în litere nota primită la un

examen, dacă aceasta este mai mare sau egală cu 5, mesajul Respins
pentru oricare din notele 1, 2, 3 sau 4 şi mesajul Eroare pentru valori
diferite de 1, 2, 3, 4, 5, 6, 7, 8, 9 sau 10.
Scriptul 4.4
<html>
<head>
</head>
<body>
<?php
$nota=3;
switch ($nota) {
case 1:;
case 2:;
case 3:;
case 4: echo "Respins";break;
case 5: echo "Nota cinci";break;
case 6: echo "Nota sase";break;
case 7: echo "Nota sapte";break;
case 8: echo "Nota opt";break;
case 9: echo "Nota noua";break;
case 10: echo "Nota zece";break;
default:echo "Eroare!";
}
?>
</body>
</html>
Observaţie. Dacă variabila $nota ia una din valorile 1, 2 sau 3 se

execută în secvenţă instrucţiunile vide corespunzătoare (cele aflate între
49
Programarea în PHP
semnele : şi ;) şi apoi, deoarece acestea nu sunt urmate de instrucţiunea

break, se va trece la execuţia instrucţiunii echo "Respins" etc. În felul
acesta, pentru oricare din valorile 1, 2, 3 sau 4 mesajul afişat va fi
Respins.
4.2.5. Operatorul condiţional ? :
Operatorul ? : este singurul operator ternar din PHP. Forma

generală a acestui operator este următoarea:
expresie_1?expresie_2:expresie_3;
unde expresie_1,expresie_2,expresie_3 sunt expresii valide în
PHP.
Execuţia unei astfel de instrucţiuni este echivalentă cu execuţia
instrucţiunii
if (expresie_1) {
expresie_2
} else {
expresie_3;
}
În plus, construcţia
expresie_1? expresie_2; expresie_3;
formează o expresie validă în PHP a cărei valoare este egală cu valoarea
expresie_2 dacă expresie_1 este adevărată, sau cu expresie_3,
dacă expresie_1 este falsă. Pentru ilustrare folosim aceeaşi problemă
prezentată în secţiunea 4.2.2.
Exemplu. Scriptul 4.5.php compară valoarea variabilei $nota cu 5
şi afişeaza mesajul Admis dacă $nota>=5 şi mesajul Respins în caz
contrar.
Scriptul 4.5
<html>
<head>
</head>
<body>
<?php
$nota = 6;
$mesaj =($nota >= 5)? "Admis" : "Respins";
50

echo "$mesaj";
?>
</body>
</html>
4.3. Instrucţiuni iterative
Instrucţiunile iterative din PHP sunt următoarele:

ü instrucţiunea while;
ü instrucţiunea for;
ü instrucţiunea do... while.
După cum sugerează şi titlul acestei secţiuni, instrucţiunile
enumerate mai sus realizează execuţia iterativă a unei instrucţiuni (simplă
sau compusă).
Instrucţiunile iterative sunt cunoscute şi sub numele de instrucţiuni
repetitive, de ciclare sau bucle.
4.3.1. Instrucţiunea while
Sintaxa instrucţiunii while este următoarea:

while (conditie) {
instructiune
}
unde:
ü conditie este o expresie validă în PHP;
ü instructiune este o instrucţiune simplă sau compusă din PHP.
Activarea instrucţiunii while are ca efect execuţia instrucţiunii
instructiune cât timp conditie este adevărată.
Observaţii
ü Instrucţiunea while este o instrucţiune cu test iniţial deoarece testul
condiţiei se face înainte de a executa instrucţiunea instructiune.
Din acest motiv, dacă din start conditie este falsă,
instructiune nu se mai execută.
51
Programarea în PHP
ü instructiune trebuie să conţină operaţii prin care conditie să

devină falsă după un număr finit de iteraţii. În caz contrar,
instructiune este repetată la infinit; în acest caz se spune că
avem de-a face cu o buclă eternă sau un ciclu infinit.
Exemplu. Scriptul 4.6 afişează numerele 2,4,6 şi 8.
Scriptul 4.6
<html>
<head>
</head>
<body>
<?php
$i = 2;
while ($i < 9) {
echo $i;
$i+=2;
}
?>
</body>
</html>
4.3.2. Instrucţiunea for
În programare sunt frecvente situaţiile în care valoarea de adevăr a

condiţiei dintr-o iteraţie este controlată de o variabilă numită contor. O
astfel de variabilă contor se modifică cu o valoarea constantă, numită raţie
sau pas, la fiecare iteraţie, şi bineînţeles trebuie să i se atribuie o valoare
iniţială. Astfel de situaţii pot fi descrise mult mai simplu cu instrucţiunea
for decât cu instrucţiunea while.
Sintaxa instrucţiunii for este următoarea:

for (initializare; conditie; actualizare) {
instrucţiuni
}
Expresiile initializare, conditie şi actualizare se referă
în mod frecvent (dar nu obligatoriu) respectiv la iniţializarea, testarea şi
modificarea variabilei contor. Practic, forma prezentată mai sus este
echivalentă cu secvenţa:
52
initializare
while (conditie) {
instrucţiune
actualizare
}
Evident, în astfel de situaţii, folosirea instrucţiunii for aduce un plus
de simplitate programului. Astfel, porţiunea de cod PHP care ilustrează
bucla while din exemplul precedent poate fi rescrisă cu ajutorul buclei
for, după cum urmează:
Scriptul 4.7
<html>
<head>
</head>
<body>
<?php
for ($i=2; $i<10; $i+=2)
echo "$i";
?>
</body>
</html>
Observaţii
ü oricare din componetele initializare, conditie sau
actualizare poate să lipsească, însă, păstrarea semnelor punct şi
virgulă (;) este obligatorie;
ü absenţa componentei conditie este interpretată ca fiind
echivalentă cu conditie adevărată. Bucla obţinută este evident o
buclă eternă;
ü componentele initializare, conditie, actualizare nu se
referă întotdeauna la o singură variabilă contor, iar instrucţiunea
ciclată poate fi vidă.
Exemplu. Scriptul 4.8.php furnizează cea mai mică sumă s a

primelor numere impare cu condiţia ca s>10, adică 16.
53
Programarea în PHP
Scriptul 4.8
<html>
<head>
</head>
<body>
<?php
for ($i=1,$s=0; $s<=10; $i+=2) {
$s+=$i;
}
echo "Suma calculata este $s";
?>
</body>
</html>
4.3.3. Instrucţiunea do...while
Instrucţiunea do...while are următoarea sintaxă:

do {
instructiuni
}
while (conditie);
unde:
ü instructiuni reprezintă grupul de instrucţiuni care va fi iterat;
ü conditie este o expresie validă în PHP.
Activarea instrucţiunii do...while are ca efect execuţia grupului
de instructiuni, cât timp conditie este adevărată.
Instrucţiunea do...while este o instrucţiune cu test final, adică
verificarea condiţiei se face după execuţia grupului de instrucţiuni.
Observaţii
ü Când corpul ciclului instrucţiunii do...while este format dintr-o
singură instrucţiune, acoladele pot lipsi.
ü Datorită poziţiei finale a testului, grupul de instrucţiuni se execută
cel puţin o dată.
ü Ca şi în cazul instrucţiunii while, instructiuni trebuie să
conţină operaţii pentru care conditie să devină falsă după un
număr finit de paşi. În caz contrar, se produce ciclu infinit sau buclă
eternă.
54
Exemplu. Programul realizează însumarea primelor 10 numere

naturale şi afişează rezultatul: Suma primelor 10 numere naturale
este 55.
Scriptul 4.9
<html>
<head>
</head>
<body>
<?php
$s = 0;
$i = 1;
do {
$s+=$i;
$i++;
}
while($i <= 10);
echo "Suma primelor 10 numere naturale este $s";
?>
</body>
</html>
4.3.4. Cicluri imbricate

Ca şi în alte limbaje, în PHP structurile repetitive pot fi imbricate.
Nu există un număr limită de imbricări şi pot fi imbricate instrucţiuni
repetitive de tipuri diferite. Pentru exemplificare prezentăm următorul
exemplu.
Exemplu. Pentru orice două numere i, j, 1≤ i ≤5, 1≤ j ≤5 să se
afişeze suma dintre i şi j. Afişarea se va face sub forma unei matrici de
dimensiune 5x5.
Soluţia problemei este dată de scriptul 4.10.php:
Scriptul 4.10
<html>
<head>
</head>
<body>
<?php
55
Programarea în PHP

echo "Matricea sumei valorilor i si j, (1 <= i <= 5, 1 <= j
<= 5) este:";
echo "<table border=\"1\">\n";
echo "<tr>\n";
for ($i=1; $i<=5; $i++){
echo "<tr> \n";
for ($j=1; $j<=5; $j++) {
echo "<td>";
echo ($i+$j);
echo "</td> \n";
}
echo "</tr> \n";
}
echo "</table>";
?>
</body>
</html>
În urma execuţiei scriptului 4.10.php se afişează:

Matricea sumei valorilor i si j, (1 <= i <= 5, 1 <= j
<= 5) este:
23456
34567
45678
56789
6 7 8 9 10
4.4. Instrucţiuni de salt
4.4.1. Instrucţiunea break
Instrucţiunea break permite ieşirea din corpul ciclului unei

instrucţiuni iterative sau dintr-o structură switch.
Sintaxa instrucţiunii break este
break n;
unde n este un număr natural care arată numărul de structuri imbricate a
căror execuţie se încheie. Numărul n poate lipsi, iar în acest caz se va
încheia execuţia primului ciclu în care se află instrucţiunea break.
56
Exemplu. Scriptul 4.11 realizează calculul expresiei e=i/(4-j)

1≤i≤6, 1≤j≤6 şi îl afişează sub forma unei matrici. Când $j=4 execuţia se
întrerupe şi se afişează mesajul de eroare Impartire la 0.
Scriptul 4.11
<html>
<head>
</head>
<body>
<?php
for ($i=1; $i<6; $i++){
for ( $j=1; $j<6; $j++) {
if ( $j == 4){
echo "Impartire la 0<br>";
break 1;
} else {
$e=round($i/($j-4),2);
echo "e($i,$j)=$e ";
}
}
}
?>
</body>
</html>
Rezultatul execuţiei scriptului 4.11.php este următorul:
e(1,1)=-0.33 e(1,2)=-0.5 e(1,3)=-1 Impartire la 0

e(2,1)=-0.67 e(2,2)=-1 e(2,3)=-2 Impartire la 0
e(3,1)=-1 e(3,2)=-1.5 e(3,3)=-3 Impartire la 0
e(4,1)=-1.3 e(4,2)=-2 e(4,3)=-4 Impartire la 0
e(5,1)=-1.67 e(5,2)=-2.5 e(5,3)=-5 Impartire la 0
Observaţii
ü Deoarece în interiorul ciclurilor avem break 1, se încheie doar
ciclul controlat de variabila $j;
ü Dacă în loc de break 1 vom pune break 2 efectul va consta în
încheierea ambelor cicluri for, iar rezultatul afişat va fi
e(1,1)=-0.33
e(1,2)=-0.5
e(1,3)=-1 Împărţire la 0.
57
Programarea în PHP
4.4.2. Instrucţiunea continue

Instrucţiunea continue are sintaxa
continue n;
unde n reprezintă numărul ciclurilor care conţin instrucţiunea continue
asupra cărora aceasta are efect.
Efectul execuţiei instrucţiunii continue constă în întreruperea
execuţiei instrucţiunilor care o urmează în corpul unui ciclu şi trecerea la
următoarea iteraţie.
Exemplu. Scriptul 4.12.php realizează afişarea expresiei e=3/i
pentru -5≤i≤5, cazul împărţirii la zero (i=0) fiind ocolit.
Scriptul 4.12
<html>
<head>
<title>Scriptul 4.12</title></head>
<body>
<?php
for ($i=-5; $i<6; $i++) {
if ($i == 0) {
continue;
} else {
$e=round(3/$i,2);
echo "i=$i e=$e<br>";
}
}
?>
</body>
</html>

i=-5 e=-0.6
i=-4 e=-0.75
i=-3 e=-1
i=-2 e=-1.5
i=-1 e=-3
i=1 e=3
i=2 e=1.5
i=3 e=1
i=4 e=0.75
i=5 e=0.6
Observaţie. Utilizarea funcţiei round() a permis afişarea
rezultatelor cu două zecimale, prin rotunjire.
58
P H P
Capitolul 5
5. Vectori. Operaţii
de bază
Scopul acestui capitol este de a familiariza cititorul cu cele mai
utilizate funcţii de prelucrare a vectorilor în PHP, insisistându-se în mod
special asupra principalelor modalităţi de parcurgere şi sortare a acestora.
5.1. Parcurgerea vectorilor
A parcurge un vector înseamnă a vizita fiecare componentă a sa o

singură dată.
În cele ce urmează vom prezenta trei modalităţi de parcurgere a unui
vector:
ü parcurgerea vectorilor folosind while,for sau do...while;
ü parcurgerea vectorilor folosind while,for sau do...while
împreună cu funcţiile list() şi each() ;
ü parcurgerea vectorilor folosind funcţia foreach() .
59
Programarea în PHP
5.1.1. Parcurgerea vectorilor folosind

while, for sau do...while
Situaţia cea mai simplă de parcurgere este când indicii sunt de tip
integer şi consecutivi. De exemplu, pentru a lista conţinutul vectorului
$extras_catalog (creat în Capitolul 2) putem folosi scriptul 5.1.php:
Scriptul 5.1
<html>
<head>
</head>
<body>
<?php
1=>array(
'nume'=>'Ion',
'nota'=>8
),
2=>array(
'nume'=>'Popescu',
'nota'=>7
),
3=>array(
'nume'=>'Ionescu',
'nota'=>10
),
);
for ($i=1; $i<=3; $i++) {
echo 'Nume:'.$extras_catalog[$i]['nume'].'<br>';
echo 'Prenume:'.$extras_catalog[$i]['prenume'].'<br>';
echo 'Nota:'.$extras_catalog[$i]['nota'].'<br>';
}
?>
</body>
</html>

Nume:Ion
Prenume:Gheorghe
Nota:8
60
Capitolul 5. Vectori. Operaţii de bază
Nume:Popescu
Prenume:Vasile
Nota:7
Nume:Ionescu
Prenume:Gabriela
Nota:10
Observaţie. Instrucţiunea for poate fi înlocuită, făcând modificările

de rigoare, cu while sau do...while.

while, for sau do...while împreună cu
funcţiile list() şi each()
Funcţia list() permite crearea unei liste de variabile iniţializate cu

valorile unui vector. Funcţia list() are efect numai asupra vectorilor
indexaţi numeric, cu indicele de start egal cu 0.
Exemplu. În secvenţa de program de mai jos funcţia list()
creează variabilele $x, $y, $z le iniţializează cu valorile 7, 10, respectiv 9
ale vectorului $v, şi le afişează:
$v=array(7,10,9);
list($x,$y,$z)=$v;
echo "x=$x,y=$y,z=$z";
Dacă ne interesează numai anumite variabile, acestea vor apărea
explicit în funcţia list(), iar celelalte vor fi înlocuite cu virgulă.
De exemplu, dacă ne interesează numai $x şi $z, secvenţa de
program de mai sus se poate scrie
$v=array(7,10,9);
list($x,,$z)=$v;
echo "x=$x,z=$z";
iar rezultatul execuţiei sale va fi x=7,z=9.
Dacă variabilele de interes sunt primele, atunci nu mai trebuie
marcate prin virgule poziţiile variabilelor care nu ne interesează. De
exemplu, dacă suntem interesaţi numai de variabila $x, atunci secvenţa de
program devine:
$v=array(7,10,9);
61
Programarea în PHP
list($x)=$v;
echo "x=$x";
iar rezultatul execuţiei sale este: x=7.
Funcţia each() aplicată unui vector returnează valoarea curentă a
indicelui, precum şi valoarea memorată în componenta indicată de acesta.
Aceste valori sunt memorate într-un vector cu dimensiunea patru având
cheile 0,1 key, value. În locaţiile indicate de cheile 0 şi key este
memorată valoarea cheii curente, iar în cele indicate de 1 şi value este
memorată valoarea componentei corespunzătoare acestei chei. Execuţia
funcţiei each() implică şi deplasarea pe următorul element al vectorului.
Poziţionarea pe prima componentă a vectorului se face cu ajutorul funcţiei
reset().
Exemplu. În urma execuţiei secvenţei de program
$v=array(7,10,9);
reset($v);
$rez=each($v);
echo"Cheia este $rez[0],iar valoarea memorata este
$rez[1].";
se afişează mesajul
Cheia este 0,iar valoarea memorata este 7
După execuţia acestei secvenţe de program cheile şi componentele
vectorilor $v şi $rez vor fi
7 10 9
0 1 2
respectiv,
0 7 0 7
0 1 key value
Dacă în continuarea secvenţei de mai sus se execută instrucţiunile

$rez=each($v);
echo "Cheia este $rez[key], iar valoarea memorata este
$rez[value].";
atunci mesajul afişat va fi
Cheia este 1,iar valoarea memorata este 10,
62
iar vectorul $rez va arăta astfel:
1 10 1 10
0 1 key value
Acest lucru arată că la fiecare apelare a funcţiei each() cursorul se

deplasează pe următorul element al vectorului vizat. Dacă se depăşeşte
poziţia ultimului element din vector, funcţia each() va întoarce valoare
False.
Funcţia reset(), prezentată în exemplul de mai sus, are tocmai
rolul de a aduce cursorul la prima poziţie a vectorului.
Parcurgerea unui vector indexat se poate face acum combinând
efectele execuţiei unei instrucţiuni iterative cu efectele execuţiei funcţiilor
list() şi each().
Exemplu. În scriptul 5.2.php se creează un vector, se parcurge cu
ajutorul instrucţiunii while şi al funcţiilor list() şi each() şi se
afişează indicii şi valorile corespunzătoare memorate în el.
Scriptul 5.2
<html>
<head>
</head>
<body>
<?php
$tari=array(
'ro'=>'Romania',
'fr'=>'Franta',
'it'=>'Italia',
'au'=>'Austria'
);
echo "Indicii si valorile corespunzatoare memorate in
vector sunt:"."<br>";
while (list($indice, $valoare)=each($tari)) {
echo "<br> $indice=>$valoare";
}
?>
</body>
</html>
63
Programarea în PHP

Indicii si valorile corespunzatoare memorate in vector
sunt:
ro=>Romania
fr=>Franta
it=>Italia
au=>Austria

funcţia foreach()
Funcţia foreach() reprezintă o modalitate elegantă de a parcurge

un vector indiferent de natura indicilor săi. Forma generală a funcţiei este:
foreach(nume_vector as var){
instructiune;
}
unde:
ü nume_vector este vectorul care se parcurge;
ü var este variabila în care se memoreză valoarea componentei
curente;
ü instructiune reprezintă instrucţiunea care este executată repetat.
Execuţia funcţiei are ca efect parcurgerea vectorului (mai precis o
copie a vectorului) element cu element, atribuirea valorii elementului
curent variabilei var şi realizarea operaţiilor din instructiune.
O variantă îmbunătăţită a acestei funcţii este următoarea:
foreach (nume_vector as indice=>var) {
instructiune;
}
Aceasta a doua formă a funcţiei foreach() se execută ca şi prima,
singura modificare fiind aceea că în plus, la fiecare pas valoarea indicelui
curent este memorată în variabila indice.
Pentru exemplificare, înlocuim în scriptul 5.2.php instrucţiunea
while(list($indice, $valoare)=each($tari); cu instrucţiunea
foreach ($tari as $indice=>$valoare);
64
Execuţia scriptului 5.2.php astfel modificat va conduce la afişarea

aceloraşi mesaje, adică:
ro => Romania
fr => Franta
it => Italia
au => Austria
Funcţia foreach() poate fi folosită, ca oricare altă structură
repetitivă, în construcţia ciclurilor imbricate.
Exemplu. Scriptul 5.3.php afişează informaţiile din vectorul
$extras_catalog (creat în Capitolul 2) folosind două cicluri imbricate
foreach().
Scriptul 5.3
<html>
<head>
</head>
<body>
<?php
1=>array(
"nume"=>"Ion",
"prenume"=>"Gheorghe",
"nota"=>8
),
2=>array(
'nume'=>'Popescu',
'nota'=>7
),
3=>array(
'nume'=>'Ionescu',
'nota'=>10
),
);
foreach ($extras_catalog as $linie){
echo "<br>";
foreach ($linie as $val) {
echo "$val " ;
}
}
?>
</body></html>
65
Programarea în PHP

Ion Gheorghe 8
Popescu Vasile 7
Ionescu Gabriela 10
Observaţie. La fiecare intrare în execuţia unei funcţii foreach(),

cursorul vectorului asupra căreia acţionează funcţia este resetat automat.
Amintim că în cazul folosirii funcţiei each() cursorul trebuie resetat
explicit folosind funcţia reset().
5.2. Sortarea vectorilor
A sorta elementele unui vector înseamnă a ordona cheile sau valorile

sale crescător sau descrescător. Ordinea considerată poate fi numerică, dacă
elementele care se sortează sunt numere, sau alfanumerică, dacă
elementele considerate sunt șiruri. Deoarece există mai multe modalităţi de
a sorta un vector, limbajul PHP pune la dispoziţie mai multe funcţii de
sortare, din care prezentăm câteva în cele ce urmează.
5.2.1. Sortarea vectorilor după valori, cu

distrugerea cheilor iniţiale
Funcţiile care realizează sortarea unui vector după valori, care

distrug însă cheile iniţiale sunt: funcţia sort() care realizează sortarea
crescătoare și funcţia rsort() care realizează sortarea descrescătoare a
vectorului. Funcţiile sort() și rsort() au, respectiv, următoarea
sintaxă:
bool sort ( array nume_vector, int mod_sort);
bool rsort ( array nume_vector, int mod_sort);
unde:
nume_vector este numele vectorului care se sortează;
mod_sort este un parametru opţional care poate lua valori cum ar fi:
ü SORT_REGULAR – tipul de date al valorilor care se sortează
rămâne neschimbat;
66
ü SORT_NUMERIC – valorile care se sortează sunt comparate ca

valori numerice;
ü SORT_STRING –valorile care se sortează sunt comparate ca şiruri
şiruri.
Când parametrul mod_sort lipseşte tipul de date al valorii care se
sortează rămâne neschimbat. Funcţiile returnează valoarea True în caz de
succes și valoarea False în caz de insucces. Cheile existente sunt șterse și
sunt generate alte chei.
Exemplu. Scriptul 5.4.php afișează cheile și valorile vectorului
$tari înainte și după sortarea crescătoare și descrescătoare a valorilor
sale.
Scriptul 5.4
<html>
<head>
</head>
<body>
<?php
$tari=array(
'ro'=>'Romania',
'au'=>'Austria',
'fr'=>'Franta',
'it'=>'Italia',
);
print "<br>Cheile si valorile vectorului inainte de
sortare:";
foreach ($tari as $ind=>$tara){
echo "<br>$ind=>$tara" ;
}
sort($tari);
print "<br>Cheile si valorile vectorului dupa sortarea
crescatoare a valorilor:";
foreach ($tari as $ind=>$tara) {
}
rsort($tari);
descrescatoare a valorilor:";
foreach ($tari as $ind=>$tara){
}
?>
</body></html>
67
Programarea în PHP
Rezultatele execuţiei scriptului 5.4.php, listate mai jos, arată foarte

clar faptul că, după sortare, toate cheile iniţiale au fost șterse și înlocuite cu
chei noi, numerice.
Cheile si valorile vectorului inainte de sortare:
ro=>Romania
au=>Austria
fr=>Franta
it=>Italia
Cheile si valorile vectorului dupa sortarea
crescatoare a valorilor:
0=>Austria
1=>Franta
2=>Italia
3=>Romania
descrescatoare a valorilor:
0=>Romania
1=>Italia
2=>Franta
3=>Austria
5.2.2. Sortarea vectorilor după valori, cu

păstrarea corelării acestora cu cheile
iniţiale
Funcţiile care realizează sortarea unui vector după valori, păstrând

însă corelarea cu cheile iniţiale sunt: funcţia asort() care realizează
sortarea crescătoare și funcţia arsort() care realizează sortarea
descrescătoare a vectorului. Funcţiile asort() și arsort() au, respectiv,
următoarea sintaxă:
bool asort (array nume_vector,int mod_sort);
bool arsort (array nume_vector,int mod_sort);
unde:
mod_sort este un parametru opţional care poate lua valorile deja
prezentate în cazul funcţiilor sort() și rsort().
68
Funcţiile returnează valoarea True în caz de succes și valoarea

False în caz de insucces. Este păstrată corelarea dintre cheile existente și
valorile sortate.
Dacă înlocuim în scriptul 5.4.php funcţia sort() cu funcţia
asort() și funcţia rsort() cu funcţia arsort() și executăm scriptul
astfel obţinut, se afișează următoarele rezultate:
ro=>Romania
au=>Austria
fr=>Franta
it=>Italia
crescatoare a valorilor:
au=>Austria
fr=>Franta
it=>Italia
ro=>Romania
descrescatoare a valorilor:
ro=>Romania
it=>Italia
fr=>Franta
au=>Austria
După cum se poate constata, atât după sortarea crescătoare cât și
după sortarea descrecătoare se păstrează corelaţiile iniţiale dintre chei și
valori.
5.2.3. Sortarea naturală a vectorilor după

valori, cu păstrarea corelării acestora
cu cheile iniţiale
Conceptul de ordine naturală are în vedere un alt mod de ordonare al

șirurilor de caractere decât ordinea lexicografică. Pentru înţelegerea acestui
concept vom folosi drept exemplu următoarele șiruri de caractere:
x12, x2, x34, x251.
69
Programarea în PHP
Sortarea crescătoare lexicografică a acestui șir de șiruri va produce

x12, x2, x251, x34.
În cazul sortării naturale, subșirurile de caractere formate din cifre
sunt comparate ca niște numere. Astfel, în urma sortării naturale a șirului
x12, x2, x34, x251
se va obţine:
x2, x12, x34, x251.
Funcţiile care realizează sortarea naturală a unui vector după valori
sunt: funcţia natsort() și funcţia natcasesort(). Funcţia
natcasesort(), spre deosebire de funcţia natsort(), nu face diferenţă
între literele mari și mici care compun șirurile (este case insensitive).
Funcţiile natsort() și natcasesort() au, respectiv, următoarea
sintaxă:
bool natsort(array nume_vector);
bool natcasesort(array nume_vector);
unde nume_vector este numele vectorului care se sortează.
False în caz de insucces. Este păstrată corelarea dintre valorile existente și
cheile sortate.
$siruri înainte și după sortarea naturală a cheilor sale folosind funcţiile
natsort() și natcasesort().
Scriptul 5.5
<html>
<head>
</head>
<body>
<?php
$siruri = array(
12=>'x12',
'2'=>'x2',
'34'=>'X34',
'251'=>'x251',
);
sortare:";
foreach ($siruri as $cheie=>$sir) {
echo "<br>$cheie=>$sir" ;
70

}
natsort($siruri);
naturala a valorilor (cazul case sensitive):";
}
natcasesort($siruri);
naturala a valorilor (cazul case insensitive):";
}
?>
</body>
</html>
Rezultatele execuţiei scriptului 5.5.php sunt următoarele:

12=>x12
2=>x2
34=>X34
251=>x251
Cheile si valorile vectorului dupa sortarea naturala a
valorilor-case sensitive:
34=>X34
2=>x2
12=>x12
251=>x251
Cheile si valorile vectorului dupa sortarea naturala a
valorilor-case insensitive:
2=>x2
12=>x12
34=>X34
251=>x251
Se observă faptul că se păstreză corelarea dintre chei şi valori.
71
Programarea în PHP
5.2.4. Sortarea vectorilor după chei, cu

păstrarea corelaţiilor acestora cu
valorile iniţiale
Funcţiile care realizează sortarea unui vector după chei, păstrând

însă corelarea acestora cu valorile iniţiale sunt: funcţia ksort(), care
realizează sortarea crescătoare și funcţia krsort(), care realizează
sortarea descrescătoare a vectorului. Funcţiile ksort() și krsort() au,
respectiv, următoarea sintaxă:
bool ksort(array nume_vector, int mod_sort);
bool krsort(array nume_vector, int mod_sort);
unde:
mod_sort este un parametru opţional care poate lua valorile deja
prezentate în cazul funcţiilor sort() și rsort().
False în caz de insucces. Este păstrată corelarea dintre valorile existente și
cheile sortate.
$materiale înainte și după sortarea crescătoare și descrescătoare a
cheilor sale.
Scriptul 5.6
<html>
<head>
</head>
<body>
<?php
$materiale=array(
'504'=>'creioane',
'634'=>'pixuri',
'423'=>'agrafe',
'109'=>'cerneala',
);
sortare:";
foreach ($materiale as $cod=>$material) {
72

echo "<br>$cod=>$material" ;
}
ksort($materiale);
crescatoare a cheilor:";
}
krsort($materiale);
descrescatoare a cheilor:";
}
?>
</body>
</html>
În urma execuţiei scriptului 5.6.php se obţin următoarele rezultate:

504=>creioane
634=>pixuri
423=>agrafe
109=>cerneala
crescatoare a cheilor:
109=>cerneala
423=>agrafe
504=>creioane
634=>pixuri
descrescatoare a cheilor:
634=>pixuri
504=>creioane
423=>agrafe
109=>cerneala
După cum se poate constata vectorul a fost sortat după chei prima
dată crescător, a doua oară descrescător, păstrându-se de fiecare dată
corelaţia dintre chei și valorile iniţiale.
73
Programarea în PHP
5.2.5. Sortarea simultană a vectorilor şi a

vectorilor multidimensionali
A sorta mai mulţi vectori simultan este echivalent cu a sorta matricea

care are drept coloane aceşti vectori, după cum urmează: se permută liniile
unei matrici astfel încât prima coloană să fie ordonată crescător, liniile care
au valori egale pe prima coloană sunt permutate astfel încât elementele
corespunzătoare de pe a doua coloană să fie ordonate crescător, liniile care
au valori egale pe prima și a doua coloană sunt permutate astfel încât
elementele corespunzătoare de pe a treia coloană să fie ordonate crescător
și așa mai departe. Acest tip de sortare aminteşte de sortarea liniilor unei
tabele dintr-o bază de date. Mai jos prezentăm o matrice X înainte și după o
astfel de sortare.
X înainte de sortare X după sortare
5 4 7 2 1 7
2 9 9 2 9 9
5 4 3 5 4 3
2 1 7 5 4 7
6 8 7 6 8 7
Funcţia array_multisort() din PHP permite realizarea sortării
unei matrici conform descrierii făcute mai sus.
Sintaxa funcţiei array_multisort() este următoarea:
bool array_multisort(array v_1,fl1,fl2,array v_2,
fl1,fl2…,array v_n,fl1,fl2);
unde:
ü v_1, v_2,…,v_n sunt nume de vectori, argumentul v_1 fiind
obligatoriu;
ü fl1, fl2 sunt argumente opţionale cu următoarea semnificaţie:
ü fl1 este flagul de ordonare care poate lua una din valorile:
ü SORT_ASC pentru ordonare crescătoare;
ü SORT_DESC pentru ordonare descrescătoare;
ü fl2 este flagul care arată tipul sortării:
ü SORT_REGULAR – compară valorile normal;
ü SORT_NUMERIC – compară valorile numeric;
ü SORT_STRING - compară valorile ca șiruri de caractere;
74
Valorile flagurilor care urmează imediat unui vector se referă numai

la acel vector. Când flagurile lipsesc, valorile considerate implicit sunt
SORT_ASC și SORT_REGULAR. Funcţia întoarce valoarea True în caz de
succes și False în caz contrar.
Când cheile sunt șiruri de caractere, corelarea lor cu valoarile
iniţiale se păstrează și după ordonare. În cazul cheilor nenumerice are loc o
reindexare.
Exemplu. Scriptul 5.7.php, prezentat mai jos, realizează următoarele
acţiuni :
ü Sortează simultan trei vectori $x,$y,$z, ilustrând modul de lucru al
acestui tip de sortare ;
ü Sortează simultan doi vectori $xa și $yb care conţin atăt chei de tip
string cât și chei de tip numeric, ilustrând efectele sortării asupra
cheilor și a modului de corelare cu valorile vectorului;
ü Sortează matricea $extras _catalog, ilustrând modul de sortare
al unei matrici;
Scriptul 5.7
<html>
<head>
</head>
<body>
<?php
$x=array(5,2,5,2,6);
$y=array(4,9,4,1,8);
$z=array(7,9,3,7,7);
print "Afisarea vectorilor x,y si z inainte de sortare:
<br>";
echo "x=(";
foreach ($x as $val) {
echo "$val ";
}
echo ")<br>";
echo "y=(";
foreach ($y as $val) {
echo "$val ";
}
echo ")<br>";
echo "z=(";
foreach ($z as $val) {
75
Programarea în PHP

echo "$val ";
}
echo ")<br>";
array_multisort($x,$y,$z);
print "Afisarea vectorilor x,y si z dupa sortare: <br>";
echo "x=(";
foreach ($x as $val) {
echo "$val ";
}
echo ")<br>";
echo "y=(";
foreach ($y as $val) {
echo "$val ";
}
echo ")<br>";
echo "z=(";
foreach ($z as $val) {
echo "$val ";
}
echo ")<br>";
$xa=array("a"=>3,5,1,5);
$yb=array(9,7,"b"=>8,6);
print "Afisarea vectorilor xa si yb inainte de sortare:
<br>";
echo "xa=(";
foreach ($xa as $cheie=>$val) {
echo "$cheie=>$val ";
}
echo ")<br>";
echo "yb=(";
foreach ($yb as $cheie=>$val) {
}
echo ")<br>";
array_multisort($xa,$yb);
print "<br>Afisarea vectorilor xa si yb dupa sortare:
<br>";
echo "xa=(";
foreach ($xa as $cheie=>$val) {
}
echo ")<br>";
echo "yb=(";
foreach ($yb as $cheie=>$val) {
}
76

echo ")<br>";
1 => array(
"nume"=>’Ionescu’,
"prenume"=>’Gheorghe’,
"nota"=>8
),
2 => array(
"nume"=>’Popescu’,
"prenume"=>’Vasile’,
"nota"=>7
),
3 => array(
"nume"=>’Ionescu’,
"prenume"=>’Gabriela’,
"nota"=>10
),
);
foreach ($extras_catalog as $linie) {
foreach ($linie as $cheie=>$val) {
switch ($cheie) {
case "nume":$numele[]=$val; break;
case "prenume":$prenumele[]=$val;
break;
case "nota":$notele[]=$val;
}
}
}
print "<br>Afisarea matricii inainte de sortare: <br>";
for ($i=0; $i<3; $i++) {
echo "$numele[$i] $prenumele[$i] $notele[$i] <br>" ;
}
array_multisort($numele,SORT_STRING,SORT_ASC,
$prenumele,SORT_STRING,SORT_DESC,$notele);
print "<br>Afisarea matricii dupa sortare:<br>";
for ($i=0; $i<3; $i++) {
echo "$numele[$i] $prenumele[$i] $notele[$i] <br>" ;
}
?>
</body>
</html>

Afisarea vectorilor x,y si z inainte de sortare:
x=(5 2 5 2 6 )
y=(4 9 4 1 8 )
77
Programarea în PHP
z=(7 9 3 7 7 )
Afisarea vectorilor x,y si z dupa sortare:
x=(2 2 5 5 6 )
y=(1 9 4 4 8 )
z=(7 9 3 7 7 )
Afisarea vectorilor xa si yb inainte de sortare:
xa=(a=>3 0=>5 1=>1 2=>5 )
yb=(0=>9 1=>7 b=>8 2=>6 )
Afisarea vectorilor xa si yb dupa sortare:
xa=(0=>1 a=>3 1=>5 2=>5 )
yb=(b=>8 0=>9 1=>6 2=>7 )
Afisarea matricii inainte de sortare:
’Ionescu’ ’Gheorghe’ 8
’Popescu’ ’Vasile’ 7
’Ionescu’ ’Gabriela’ 10
Afisarea matricii dupa sortare:
’Ionescu’ ’Gheorghe’ 8
’Ionescu’ ’Gabriela’ 10
’Popescu’ ’Vasile’ 7
După sortarea simultană a celor trei vectori x, y,z se constată

următoarele:
ü poziţiile elementelor vectorilor y și z au rămas corelate cu poziţiile
componentelor vectorului x;
ü când elementele vectorului x au fost egale (de exemplu elementele
2,2) criteriul de ordonare a fost decis de ordinea elementelor
corespunzătoare din vectorul y (elementele 1 și 9). În cazul în care și
elementele corespunzătore din vectorul y au fost egale (de exemplu,
pentru elementele egale cu 5 din vectorul x, elementele
corespunzătore din vectorul y sunt egale cu 4) criteriul de ordonare a
fost decis de ordinea elementelor corespunzătoare din vectorul z
(elementele 3 și 7).
După sortarea simultană a vectorilor xa și yb se constată

următoarele:
78
ü valorile cheilor numerice s-au schimbat (a avut loc o reindexare). De

exemplu, cheia 1 a valorii 1 din vectorul xa a fost schimbată în 0,
cheia 2 a valorii 6 din vectorul yb a fost schimbată în 1 etc. ;
ü cheile de tip string "a" și "b" au rămas corelate cu valorile iniţiale (3
respectiv 8).
Pentru sortarea matricii $extras_catalog au fost extrase mai

întâi coloanele matricii în vectorii $numele, $prenumele și respectiv
$notele, cu ajutorul instrucţiunilor foreach și switch. Sortarea a fost
realizată cu ajutorul instrucţiunii
array_multisort($numele,SORT_STRING,SORT_ASC,$prenumel
e,SORT_STRING,SORT_DESC,$notele);
Atât vectorul (coloana) $numele, cât și vectorul (coloana)
$prenumele au fost sortate ca niște șiruri (au opţiunea SORT_STRING),
însă coloana $numele este sortată crescător (opţiunea SORT_ASC), iar
coloana $prenumele este sortată descrescător (opţiunea SORT_DESC).
Din acest motiv, persoana ’Ionescu’ ’Gheorghe’ apare după sortare
pe prima linie a matricii, iar persoana ’Ionescu’ ’Gabriela’ pe linia a
doua.
5.3. Alte funcţii utile de lucru cu

vectorii
Scopul acestei secţiuni este de a prezenta pe scurt alte câteva funcţii

utile de lucru cu vectorii. Sintaxa completă a funcţiilor care permit
efectuarea acestor operaţii poate fi consultată în manualul PHP
(http://php.net/manual/ro). În cele ce urmează vom preciza doar câteva
informaţii strict necesare pentru folosirea lor: numele funcţiei, ce face
funcţia şi exemple simple de utilizare în scriptul 5.8.php.
ü sizeof() sau count() – calculează numărul de elemente dintr-un

vector;
ü array_values() – creează din valorile unui vector un alt vector
indexat numeric;
79
Programarea în PHP
ü array_keys() – creează din cheile unui vector un alt vector

indexat numeric;
ü array_reverse() – creează vectorul inversat (memorat în ordine
inversă) al unui vector dat;
ü array_sum() – calculează suma elementelor unui vector;
ü array_product() – calculează produsul elementelor unui vector;
ü array_push() – adaugă la sfârșitul unui vector un număr de
elemente precizate;
ü array_pop() – elimină ultimul element dintr-un vector;
ü array_search() – caută o valoare într-un vector și-i întoarce
cheia dacă este găsită;
ü in_array() – caută o valoare într-un vector și întoarce valoarea
True dacă este găsită;
ü array_key_exists() – caută o cheie într-un vector și întoarce
valoarea True dacă este găsită;
ü array_merge() – creează un nou vector prin alipirea a doi sau mai
mulţi vectori;
ü array_unique() – elimină elementele redundante ale unui vector
și întoarce vectorul obţinut;
ü array_intersect() – returnează intersecţia a doi sau mai mulţi
vectori: returnează toate valorile din primul vector care se află în
ceilalţi vectori;
ü array_diff() – returnează diferenţa a doi vectori: returnează
toate valorile din primul vector care nu se află în celălalt vector;
ü explode() – generează un vector dintr-un șir; valorile memorate în
vector sunt subșiruri ale șirului considerat, delimitate de un separator
precizat în funcţie;
ü implode() – este funcţia simetrică a funcţiei explode(), adică
generează un șir dintr-un vector; funcţia trebuie să aibă precizat un
parametru care să “lege” elementele vectorului într-un șir;
Execuţia scriptului 5.8.php, prezentat în continuare, ilustrează modul

de lucru al acestor funcţii.
80
Scriptul 5.8
<html>
<head>
<title>Scriptul S5.7</title>
</head>
<body>
<?php
//se genereaza vectorul $x=(0=>5,1=>4,"a"=>5,2=>6)

$x=array(5,4,"a"=>5,6);
echo "<br>Vectorul x este:x=(";
foreach ($x as $cheie=>$val) {
}
echo ")";
//se calculeaza in $n numarul de elemente ale vectorului;

//n=4
$n=sizeof($x);
echo "<br>Lungimea initiala a vectorului x este=$n";
/* se creaza cu valorile vectorului $x

vectorul indexat numeric $xval=(0=>5,1=>4,2=>5,3=>6)*/
$xval=array_values($x);
echo "<br>Valorile vectorului x sunt:";
for ($i=0; $i<$n; $i++) {
echo "$xval[$i] ";
}
/*se creaza cu cheile vectorului $x

vectorul indexat numeric $xchei=(0=>0,1=>1,2=>"a",3=>3)*/
$xchei=array_keys($x);
echo "<br>Cheile vectorului x sunt:" ;
for ($i=0; $i<$n; $i++) {
echo "$xchei[$i] ";
}
//se creaza vectorul $x inversat

$xrev=(0=>6,"a"=>5,1=>4,2=>5)
$xrev=array_reverse($x);
echo "<br>Vectorul x inversat este:xrev=(";
foreach ($xrev as $cheie=>$val) {
}
echo ")";
//se calculeaza suma si produsul elementelor vectorului x
81
Programarea în PHP

echo "<br>Suma elementelor vectorului x
este:".array_sum($x);
echo "<br>Produsul elementelor vectorului x
este:".array_product($x);
/*se adauga elementele 10 si 12 la sfarsitul vectorului$x

care devine $x=(0=>5,1=>4,"a"=>5,2=>6,3=>10,4=>12)*/
array_push($x,10,12);
// se calculeaza lungimea vectorului dupa adaugare

$n=count($x);
echo "<br>Lungimea vectorului x dupa adaugare este=$n";
echo "<br>Vectorul x dupa adaugare este:";
for ($i=0; $i<$n; $i++) {
echo "$x[$i] ";
}
//se elimina ultimul element din vectorul x si se memoreaza

in $z
$z=array_pop($x);
echo "<br>Elementul eliminat este:$z";
echo "<br>Lungimea vectorului x dupa eliminarea ultimului
element este=".sizeof($x);
echo "<br>Vectorul x dupa eliminarea ultimului element
este:";
for ($i=0; $i<count($x); $i++) {
echo "$x[$i] ";
}
//se genereaza din nou vectorul $x=(0=>5,1=>4,"a"=>5,2=>6)

$x=array(5,4,"a"=>5,6);
/* functia array_search() cauta o valoare in vectorul $x

si-i intoarce cheia daca este gasita; in caz contrar
se intoarce valoarea false; daca sunt mai multe valori
egale
in vector se intoarce cheia primei valori gasite;
aici se intoarce cheia 0 */
$valdegasit=5;
$cheie=array_search($degasit,$x);
if ($cheie === false) {
echo "<br>Valoarea $valdegasit nu exista in vector";
} else {
echo "<br>Valoarea $degasit a fost gasita si are cheia
$cheie ";
}
82

/* functia in_array() cauta o valoare in vectorul $x
si intoarce valoarea true daca este gasita;
in caz contrar se intoarce false ;aici se intoarce valoarea
false*/
$valdegasit=56;
if (in_array($degasit,$x)) {
echo "<br>Valoarea $valdegasit a fost gasita";
} else {
echo "<br>Valoarea $valdegasit nu exista in vector";
}
/*functia array_key_exists() cauta o cheie in vectorul $x

si intoarce valoarea true daca este gasita; in caz contrar
se intoarce false;
aici se intoarce valoarea cheii a */
$cheiedegasit='a';
if (array_key_exists($cheiedegasit,$x)) {
echo "<br>Cheia $cheiedegasit a fost gasita";
} else {
echo "<br>Cheia $cheiedegasit nu exista in vector";
}
//se genereaza vectorul $y=(0=>5,1=>6,2=>20)

$y=array(5,6,20);
echo "<br>Vectorul y este:y=(";
foreach ($y as $cheie=>$val) {
echo "$cheie=>$val " ;
}
echo ")";
/*functia array_merge() pune la un loc

elementele vectorilor $x si $y in vectorul $xmergey */
$xmergey=array_merge($x,$y);
echo "<br>Vectorul:xmergey=(";
foreach ($xmergey as $cheie=>$val) {
}
echo ")";
/* functia array_unique() elimina valorile redundante

dintr-un vector si intoarce un vector cu valori
neredundante
aici se intoarce vectorul $xsauy care are drept valori
reuniunea valorilor vectorilor $x si $y */
$xsauy=array_unique($xmergey);
echo "<br>Vectorul xmergey fara redundante este:xsauy=(";
foreach ($xsauy as $cheie=>$val) {
83
Programarea în PHP

echo "$cheie=>$val " ;
}
echo ")";
/* functia array_intersect($x,$y) returneaza intersectia

vectorilor
$x si $y, adica valorile comune din $x si $y; este pastrata
corelarea
dintre chei si valori ;*/
$xinty=array_intersect($x,$y);
echo "<br>Intersectia vectorilor x si y este:xsiy=(";
foreach ($xinty as $cheie=>$val) {
}
echo ")";
/*functia array_dif($x,$y) returneaza diferenta vectorilor

$x si $y,
adica, toate valorile din $x care nu se afla in $y;
este pastrata corelarea dintre chei si valori ; */
$xdify=array_diff($x,$y);
echo "<br>Diferenta vectorilor x si y este:xdify=(";
foreach ($xdify as $cheie=>$val) {
}
echo ")";
/* functia explode(",",$str) genereaza vectorul $vect

din sirul $str, ulilizind separatorul virgula(,) */
$str="nume,prenume,ocupatia";
$vect =explode(",",$str);
echo "<br>Vectorul generat este: ";
foreach ($vect as $cheie=>$val) {
}
echo ")";
/*functia implode(",",$str) genereaza vectorul $vect

din sirul $str, utilizand ca separator spatiul*/
$vect=array("Ionescu","Popescu","Georgescu");
$str =implode(" ", $vect);
echo "<br> Sirul generat este: ".$str;
?>
</body>
</html>
84
Vectorul x este:x=(0=>5 1=>4 a=>5 2=>6 )

Lungimea initiala a vectorului x este=4
Valorile vectorului x sunt:5 4 5 6
Cheile vectorului x sunt:0 1 a 2
Vectorul x inversat este:xrev=(0=>6 a=>5 1=>4 2=>5 )
Suma elementelor vectorului x este:20
Produsul elementelor vectorului x este:600
Lungimea vectorului x dupa adaugare este=6
Vectorul x dupa adaugare este:5 4 6 10 12
Elementul eliminat este:12
Lungimea vectorului x dupa eliminarea ultimului element
este=5
Vectorul x dupa eliminarea ultimului element este:5 4 6 10
Valoarea 5 nu exista in vector
Valoarea 56 nu exista in vector
Cheia a a fost gasita
Vectorul y este:y=(0=>5 1=>6 2=>20 )
Vectorul:xmergey=(0=>5 1=>4 a=>5 2=>6 3=>5 4=>6 5=>20 )
Vectorul xmergey fara redundante este:xsauy=(0=>5 1=>4 2=>6
5=>20 )
Intersectia vectorilor x si y este:xsiy=(0=>5 a=>5 2=>6 )
Diferenta vectorilor x si y este:xdify=(1=>4 )
Vectorul generat este: 0=>nume 1=>prenume 2=>ocupatia )
Sirul generat este: Ionescu Popescu Georgescu
85
P H P
Capitolul 6
6. Funcţii utilizate în
prelucrarea şirurilor de
caractere, a datelor
calendaristice şi a orei
Alături de imagine, textul joacă un rol important în construcţia site-
urilor. Din acest motiv limbajul PHP oferă programatorilor o mulţime de
funcţii utile pentru prelucrarea șirurilor de caractere. Sunt funcţii pe care le
întâlnim în mod obișnuit și în alte limbaje, dar și funcţii create pentru a
rezolva problemele specifice care apar din interacţiunea PHP cu HTML și
MySQL. În continuare vom prezenta principalele funcţii și construcţii de
limbaj utilizate în prelucrarea șirurilor de caractere, a datelor calendaristice
şi a orei.
87
Programarea în PHP
6.1. Afișarea fără format a șirurilor

de caractere utilizând
instrucţiunea echo şi funcţia
print
Instrucţiunea echo are următoarea sintaxă:

void echo string argument_1, string argument_2,…,
string argument_n;
unde: argument_i,i=1,2,…,n, reprezintă argumentele instrucţiunii
echo;
Efectul execuţiei instrucţiunii echo este concatenarea valorilor celor

n argumente și afișarea rezultatului. Trebuie să existe cel puţin un
argument. Opţional, se pot folosi și parantezele rotunde pentru încadrarea
fiecărui argument. Așa cum reiese din sintaxa instrucţiunii echo
argumentele trebuie să fie șiruri de caractere. Șirurile se pot întinde pe mai
multe rânduri, pot conţine secvenţe escape, nume de variabile și referiri la
valorile unui vector. Dacă pentru reprezentarea șirului se utilizează
ghilimelele duble, atunci numele de variabile și referirile la valorile unui
vector vor fi înlocuite cu valorile lor.
De exemplu, execuţia secvenţei de instrucţiuni
$x=3;
echo "x=$x";
va avea ca rezultat:
x=3
În mod asemănător, execuţia secvenţei de instrucţiuni
$y[7]=8;
echo "y[7]=$y[7]";
va produce rezultatul
y[7]=8
88
Capitolul 6. Funcţii utilizate în prelucrarea şirurilor de caractere, a datelor calendaristice
şi a orei
De asemenea, caracterele backslash (\n-rând nou, \r-retur de car,

\t-tab orizontal, \" etc.) au efect numai dacă sunt folosite între ghilimele
duble. Folosirea acestora permite creșterea lizibilităţii codului HTML, fără
a afecta însă aspectul paginii obţinute. Astfel, execuţia secvenţelor de
instrucţiuni
$x=2;
$y=3;
echo "x=$x y=$y";
și
$x=2;
$y=3;
echo "x=$x \ny=$y";
va produce același rezultat, adică x=2 y=3. Efectul caracterului linie nouă
(\n) se observă însă în codul HTML generat: execuţia primei secvenţe de
instrucţiuni(fără codul \n) va produce codul HTML x=2 y=3, iar execuţia
celei de-a doua secvenţe de instrucţiuni (cu codul \n) va produce codul
HTML
x=2
y=3
Pentru afișarea pe două rânduri a rezultatului trebuie folosit codul
HTML <br> într-una din formele: echo "x=$x <br>y=$y"; sau echo
"x=$x <br>\ny=$y";
Atunci când lista de afișare cuprinde numai nume de variabile,
ghilimelele pot lipsi. Astfel, în loc de instrucţiunea echo "$a","$b"; se
poate utiliza varianta mai simplă echo $a,$b;.
Este foarte important de reţinut faptul că utilizarea apostrofurilor în
locul ghilimelelor va avea ca efect afișarea numelor variabilelor și nu a
valorilor acestora, precum și a eventualelor caractere backslash folosite.
Astfel, execuţia secvenţei de instrucţiuni
$x=3;
echo 'x=$x\n';
$y[7]=8;
echo 'y[7]=$y[7]';
89
Programarea în PHP
x=$x\ny[7]=$y[7]
De asemenea, afișarea elementelor unui vector necesită o atenţie
deosebită. De exemplu, execuţia secvenţei de instrucţiuni
$x=array(2=>7,5);
echo "x[2]=$x[2]<br>";
va produce, așa cum era de așteptat, rezultatul x[2]=7.
În același timp, în cazul în care cheile sunt de tip string, schema de
mai sus va funcţiona numai dacă structura nume_variabila[cheie] va
fi cuprinsă între acolade, adică va fi de forma
{nume_variabila[cheie]}.
Mai jos prezentăm un astfel de exemplu. Execuţia secvenţei de instrucţiuni
$y=array("ro"=>"Romania");
$z=array('fr'=>'Franta');
echo "y[ro]={$y["ro"]}<br>";
echo "z[fr]={$z['fr']}<br>";
y[ro]=Romania
z[fr]=Franta
Pentru a înţelege și mai bine legătura dintre instrucţiunile PHP și
codul HTML ne propunem să rezolvăm următoarea problemă: să se
elaboreze un script PHP care să afișeze valorile 1,2,3,4,5,6,7,8,9,
10,11,12 sub forma
1 2 3 4
5 6 7 8
9 10 11 12
O rezolvare a acestei probleme este realizată de scriptul 6.1.php :
Scriptul 6.1
<html>
<head>
</head>
<body>
<?php
for ($i=1; $i<=3; $i++){
echo "<br>";
for ($j=1;$j<=4;$j++){
$e=$j+4*($i-1);
90
şi a orei

echo "$e ";
}
}
?>
</body>
</html>
În urma execuţiei scriptului 6.1.php se afișează matricea
1 2 3 4
5 6 7 8
9 10 11 12
codul HTML generat fiind:

<html>
<head>
</head>
<body>
<br>1 2 3 4 <br>5 6 7 8 <br>9 10 11 12
</body>
</html>
Organizarea datelor de ieșire sub forma unui tabel poate fi obţinută

cu ajutorul scriptului 6.2.php:
Scriptul 6.2
<html>
<head>
</head>
<body>
<table border="1">
<?php
for ($i=1; $i<=3; $i++){
echo "<tr>";
for ($j=1; $j<=4; $j++){
echo "<td>";
$e=$j+4*($i-1);
echo $e;
echo "</td>";
}
echo "</tr>";
91
Programarea în PHP

}
?>
</table>
</body>
</html>
Rezultatul execuţiei scriptului 6.2.php este tabelul următor:
1 2 3 4
5 6 7 8
9 10 11 12
Observaţii
ü Etichetele HTML <table border="1"> și </table> pot fi și ele
afișate în browser cu ajutorul instrucţiunii echo, modificând scriptul
astfel (vezi scriptul 6.3.php):
Scriptul 6.3
<html>
<head>
</head>
<body>
<?php
echo '<table border="1">';
for ($i=1; $i<=3; $i++) {
echo "<tr>";
for ($j=1; $j<=4; $j++) {
echo "<td>";
$e=$j+4*($i-1);
echo $e;
echo "</td>\n ";
}
echo "</tr>\n";
}
echo "</table>";
?>
</body>
</html
92
şi a orei
ü În instrucţiunea echo '<table border="1">'; șirul trimis spre

afișare a fost încadrat între apostrofuri și nu între ghilimele, tocmai
pentru a se evita conflictul dintre acestea din urmă și ghilimelele
folosite de HTML. O altă modalitate de rezolvare a acestui conflict
este folosirea formei echivalente echo "<table border
=\"1\">";
ü Prezenţa sau absenţa caracterelor newline (\n) în scriptul 6.3.php are
ca efect doar creșterea lizibilităţii codului HTML generat, fără a
modifica însă rezultatul afișat. Astfel, codul HTML generat de acest
script este următorul:
<html>
<head>
</head>
<body>
<table border="1">
<tr><td>1</td>
<td>2</td>
<td>3</td>
<td>4</td>
</tr>
<tr><td>5</td>
<td>6</td>
<td>7</td>
<td>8</td>
</tr>
<tr><td>9</td>
<td>10</td>
<td>11</td>
<td>12</td>
</tr>
</table>
</body>
</html
ü Dacă în scriptul 6.3.php înlocuim echo "</td>\n"; cu echo

"</td>"; și echo "</tr>\n"; cu echo "</tr>"; și executăm
scriptul obţinut, rezultatul afișat va fi același, însă, după cum se
poate observa mai jos, codul HTML generat va fi mai puţin lizibil:
93
Programarea în PHP
<html>
<head>
<title>scriptul 6.3</title>
</head>
<body>
<table border="1">
<tr><td>1</td><td>2</td><td>3</td><td>4</td></tr><tr><td>5<
/td><td>6</td><td>7</td><td>8</td></tr><tr><td>9</td><td>10
</td><td>11</td><td>12</td></tr>
</table>
</body>
</html>
Funcţia print() are sintaxa:

int print ( string argument);
Efectul execuţiei funcţiei este afișarea șirului de caractere desemnat de
parametru argument. Spre deosebire de instrucţiunea echo, funcţia
print() întoarce o valoare, și anume întoarce întotdeauna valoarea 1.
Nefiind în mod real o funcţie, ci mai degrabă o construcţie de limbaj cu un
comportament asemănător unei funcţii, print() poate fi folosită și fără
paranteze. De exemplu, în următoarea secvenţă de program,
echo "x=$x";
print ("x=$x");
print "x=$x";
cele trei comenzi de afișare sunt echivalente, afișând fiecare ca rezultat
șirul x=3.
6.2. Funcţii de citire şi afişare care

utilizează un format
6.2.1. Funcţia sscanf() de citire dintr-un

şir, cu format
Funcţia sscanf() realizează citirea informaţiei dintr-un șir de

caractere conform unui anumit format. Sintaxa funcţiei este următoarea:
tip sscanf(string sir,string format,lista_de_argumente);
94
şi a orei
unde:
ü sir reprezinta șirul de unde se citește informaţia;
ü format este formatul cu care se citește șirul;
ü lista_de_argumente se referă la o listă de argumente opţionale;
ü tip este tipul de date array dacă lista_de_argumente este vidă și
este tipul de date integer dacă lista_de_argumente este
prezentă.
Sunt posibile două cazuri. Dacă sunt prezente doar primele două
argumente, funcţia întoarce un vector care are dimensiunea egală cu
numărul specificatorilor din şirul format. Dacă în plus apar şi argumente
opţionale atunci este returnat numărul acestora. Cele două cazuri sunt
exemplificate în scriptul de mai jos:
<?php
situatie1="Ionescu Mircea 7";
list($nume, $prenume, $nota)=sscanf($situatie1, "%s %s
%d");
echo "<br>Nume=$nume, Prenume=$prenume, Nota=$nota";
$situatie2="Popescu Ion 10";
scanf($situatie2, "%s %s %d",$nume, $prenume, $nota);
echo "<br>Nume=$nume, Prenume=$prenume, Nota=$nota";
?>
În urma execuţiei acestui script se afișează următoarele rezultate:

Nume=Ionescu, Prenume=Mircea, Nota=7
Nume=Popescu, Prenume=Ion, Nota=10
6.2.2. Funcţiile de afişare cu format

printf() și sprintf()
Funcţiile printf() şi sprintf() permit formatarea şirurilor de

caractere afişate.
Sintaxa funcţiei printf() este următoarea:
int printf (string format, lista_de_argumente);
unde:
ü format este un șir de control al formatului de afișare care poate
conţine mesaje utilizator, specificatori de conversie, secvenţe escape,
entităţi HTML etc.;
95
Programarea în PHP
ü lista_de_argumente se referă la variabile și expresii valide în

PHP.
Funcţia printf() permite afișarea valorii argumentelor din

lista_de_argumente conform specificatorilor de conversie prezenţi în
șirul de control al formatului. Pentru realizarea conversiei, specificatorul de
conversie trebuie să conţină, cel puţin, unul din specificatorii de tip
prezentaţi în tabelul 6.1.
Tabelul 6.1. Lista specificatorilor de tip și semnificaţia lor

Specificatori
Utilizare
de tip
d conversie în număr întreg zecimal cu semn
u conversie în număr întreg zecimal fără semn
c conversie în caracterul ASCII corespunzător
f conversie în număr real în virgulă mobilă
e conversie în notaţie știinţifică
b conversie în baza 2 (binar)
o conversie în baza 8 (octal)
x conversie în baza 16 (hexazecimal) cu litere mici
X conversie în baza 16 (hexazecimal) cu litere mari
s conversie într-un string
În scriptul 6.4.php exemplificăm utilizarea specificatorilor de

conversie prezentaţi în Tabelul 6.1.
Scriptul 6.4
<html>
<head>
</head>
<body>
<?php
$x=174;
printf(" Conversia numarului %d in zecimal este %d <br>",
$x,$x);
printf(" Conversia numarului %d intr-un intreg fara semn
este %u<br>", -$x,$x);
96
şi a orei

printf(" Conversia numarului %d in binar este %b<br>",
$x,$x);
printf(" Conversia numarului %d in octal este %o <br>",
$x,$x);
printf(" Conversia numarului %d in hexazecimal(litere mici)
este %x <br>", $x,$x);
printf(" Conversia numarului %d in hexazecimal(litere mari)
este %X <br>", $x,$x);
printf(" Conversia numarului %d intr-un numar real in
notatie cu punct %e <br>", $x,$x);
printf(" Conversia numarului %d intr-un numar real in
notatie stiintifica este %f <br>", $x,$x);
printf(" Conversia numarului %d intr-un caracter este %c
<br>", $x,$x);
printf(" Conversia numarului %d intr-un string este %s
<br>", $x,$x);
?>
</body>
</html>

Conversia numarului 174 in zecimal este 174
Conversia numarului -174 intr-un intreg fara semn este
174
Conversia numarului 174 in binar este 10101110
Conversia numarului 174 in octal este 256
Conversia numarului 174 in hexazecimal(litere mici)
este ae
Conversia numarului 174 in hexazecimal(litere mari)
este AE
Conversia numarului 174 intr-un numar real in notatie
cu punct 1.740000e+2
Conversia numarului 174 intr-un numar real in notatie
stiintifica este 174.000000
Conversia numarului 174 intr-un caracter este ®
Conversia numarului 174 intr-un string este 174
Opţional, între semnul % și litera care desemnează specificatorul de

tip, se pot insera, în următoarea ordine, specificatorii: specificatorul de
semn, specificatorul de lăţime, specificatorul de aliniere, specificatorul de
precizie, specificatorul de completare,.
97
Programarea în PHP
Specificatorul de semn asigură afișarea semnului unui număr,

indiferent dacă este pozitiv sau negativ. În exemplul următor se afișează
atât valoarea unui număr căt și opusul acestuia.
<?php
$x=-89;
printf("Numarul x este =%+d <br> Opusul numarului x
este=%+d",$x,-$x);
?>
Rezultatul execuţiei acestei secvenţe de program este:
Numarul x este =-89
Opusul numarului x este =+89
Specificatorul de lăţime a câmpului de afișare reprezintă numărul

maxim de caractere pe care-l estimăm pentru afișare (lăţimea câmpului de
afișare) și se plasează imediat în faţa specificatorului de conversie.
Implicit, alinierea în cadrul acestui spaţiu de afișare se face la dreapta, dar
dacă numărul prin care se precizează lăţimea este precedat de specificatorul
de aliniere minus (-), alinierea se face la stânga. Pentru vizualizarea
spaţiilor care apar în cazul alinieri la dreapta, instrucţiunile de afișare
trebuie să fie încadrate de tag-urile <pre> și </pre> ca în exemplul
următor:
<?php
$x=-89;
echo "<pre>";
printf("x=%10d<br>",$x);
printf("x=%-10d<br>",$x);
$y='abc';
printf("y=%10s<br>",$y);
printf("y=%-10s<br>",$y);
echo "</pre>";
?>
În urma execuţiei secvenţei de mai sus se obţine următorul rezultat:

x= -89
x=-89
y= abc
y=abc
98
şi a orei
Specificatorul de precizie permite rotunjirea părţii zecimale a unui

număr reprezentat în virgulă mobilă (de tip float). La modul general,
acest specificator este de forma .n, unde n este numărul zecimalelor la care
se face rotunjirea. Dacă se dorește ca întreg numărul să fie afișat pe m
poziţii, se combină specificatorul de lăţime cu specificatorul de precizie
rezultând construcţia m.n, cu următorul efect: numărul real va fi afișat pe m
poziţii, din care n vor fi ocupate cu partea zecimală, iar o poziţie va fi
ocupată de punctul zecimal. Execuţia secvenţei de program
<?php
$x=41.3;
echo "<pre>";
printf("x=%-10.2f<br>",$x);
$y=41.324;
printf("y=%10.2f<br>",$y);
$z=41.325;
printf("z=%10.2f<br>",$z);
echo "</pre>";
?>
va conduce la afișarea următorului rezultat:
x=41.30
y= 41.32
z= 41.33
Specificatorul de completare precizează caracterul cu care dorim să

umplem spaţiile rămase libere, atunci când lăţimea câmpului de afișare este
mai mare decât numărul caracterelor afișate. Caracterul de umplere poate fi
0, spaţiu sau oricare caracter. În primele două cazuri, între simbolul % și
numărul prin care precizăm lăţimea câmpului de afișare se introduce 0 sau
un spaţiu, după caz. Precizarea oricărui alt caracter de umplere se face prin
prefixarea sa cu ajutorul caracterului apostrof ('). Pentru exemplificare
considerăm următoarea secvenţă de program:
<?php
$x=-89;
printf("x=%07d<br>",$x);
printf("x=% 7d<br>",$x);
printf("x=%'#7d",$x);?>
99
Programarea în PHP
Deși codul HTML generat este

x=-000089<br>x= -89<br>x=####-89
va fi afişat următorul rezultat :
x=-000089
x= -89
x=####-89
După cum se poate observa lăţimea de afișare estimată a avut

valoarea 7, în timp ce pentru afișare avem nevoie efectiv de 3 câmpuri.
Diferenţa de patru caractere a fost umplută în primul și în ultimul caz cu
zerouri, respectiv cu caracterul diez (#). Se observă însă că în cel de-al
doilea caz, între semnul = și semnul – al numărului a apărut un singur
spaţiu și nu 4 spaţii așa cum era de așteptat și cum au apărut, de altfel, în
codul HTML. Acest lucru se datorează faptului că un număr oarecare de
spaţii consecutive din HTML este interpretat de browser ca un singur
spaţiu.
6.2.3. Utilizarea etichetelor <pre> şi

</pre> pentru vizualizarea spaţiilor
Afișarea în browser a unui număr de spaţii consecutive și a

caracterelor newline (\n) se poate face totuși dacă introducem
instrucţiunile de afișare între tag-urile <pre> și </pre>. Pentru ilustrare
am modificat secvenţa de program de mai sus astfel:
<?php
echo "<pre>";
$x=-89;
printf("x=%07d\n",$x);
printf("x=% 7d\n",$x);
printf("x=%'#7d",$x);
echo "</pre>";
?>
După cum se observă modificările constau în introducerea tag-urilor

<pre> și </pre> și înlocuirea tag-ului HTML <br> cu caracterul newline
100
şi a orei
(\n). În urma execuţiei acestei secvenţe de program, codul HTML obţinut

este
<pre>x=-000089
x= -89
x=####-89</pre>
iar rezultatele afișate sunt
x=-000089
x= -89
x=####-89
Se constată că folosirea tag-urilor <pre> și </pre> a permis

vizualizarea spaţiilor în cel de-al doilea caz și interpretarea corectă a
caracterului newline (\n).
Dacă nu se specifică nici un caracter de umplere în spaţiul de afișare
precizat, alinierea se face implicit la dreapta; alinierea la stânga se poate
face adăugând înaintea lăţimii câmpului de afișare specificatorul de aliniere
minus (-). Folosirea simultană a specificatorului de completare și a
specificatorului de aliniere minus (-) are ca efect ignorarea primului
specificator, în cazul folosirii caracterelor de umplere 0 și spaţiu, și
forţarea alinierii la stânga și completarea restului de câmpuri cu caracterul
de umplere, dacă acesta este diferit de 0 sau spaţiu. Astfel, execuţia
secvenţei de program,
<?php
echo "<pre>";
$x=-89;
printf("x=%0-7d\n",$x);
printf("x=% -7d\n",$x);
printf("x=%'#-7d",$x);
echo "</pre>";
?>
va produce următorul rezultat:
x=-89
x=-89
x=-89####
101
Programarea în PHP
6.2.4. Asocierea explicită a

specificatorilor de conversie cu
argumentele funcţiei printf(). Funcţia
sprintf() de formatare a unei liste de
argumente
Așa cum s-a văzut, asocierea dintre specificatorii de conversie și

argumentele funcţiei printf() se face implicit de la stânga la dreapta.
Practic, un specificator de conversie care are o anumită poziţie în lista sa,
se asociază cu argumentul care are aceeași poziţie în lista de argumente.
Există însă posibilitatea de a asocia un specificator de conversie cu orice
argument aflat în lista de argumente. De exemplu, în secvenţa de program
de mai jos, prezentăm două moduri de formatare pentru afișarea numelui.
Atunci când utilizăm pentru afișare $format1, specificatorul de conversie
% 20s se asociază cu argumentul $nume, iar cel de-al doilea specificator %
15s se asociază cu argumentul $prenume. Utilizând variabila $format2
specificatorul de conversie % 20s se asociază cu argumentul $prenume,
iar cel de-al doilea specificator % 15s se asociază cu argumentul $nume.
Acest mod de asociere se realizează prin indicarea explicită a asocierilor.
Astfel, șirul de caractere 2\$ prezent în primul specificator de conversie
din variabila $format2 arată că acest specificator se asociază cu
argumentul $prenume, aflat pe poziţia a doua în lista de argumente. În
mod analog, al doilea specificator de conversie se va asocia cu argumentul
$prenume deoarece conţine șirul de caractere 1\$. În general, prezenţa în
cadrul unui specificator de conversie a unui șir de forma i\$ indică
asocierea cu argumentul aflat pe poziţia i.
Ţinând cont de observaţiile făcute mai sus, execuţia secvenţei de
program
<?php
$nume="Popescu";
$prenume="Ion";
$format1="% 20s % 15s<br>";
$format2="%2\$20s %1\$15s<br>";
printf($format1,$nume,$prenume);
printf($format2,$nume,$prenume);
?>
102
şi a orei
produce următorul rezultat:

Popescu Ion
Ion Popescu
Funcţia sprintf() permite formatarea unei liste de argumente şi

are sintaxa următoare:
string sprintf(string format,lista_de_argumente);
unde format și lista_de_argumente au înţelesul prezentat în cazul
funcţiei printf(). Funcţia întoarce un șir de argumente formatat conform
șirului format. Secvenţa de program prezentată mai jos afișează o dată
calendaristică în format american.
<?php
$zi=24;
$luna=11;
$anul=1988;
$format=sprintf("%2\$2d/%1\$2d/%3\$3d",$zi,$luna,
$anul);
echo "Data in format american $format";//se afiseaza
//data sub forma 11/24/1988
?>
6.3. Funcţiile strtok(), explode()

și implode()
Funcţia strtok() extrage dintr-un șir, subșirurile sale delimitate

prin unul sau mai mulţi separatori. Sintaxa funcţiei strtok() este
următoarea:
string strtok (string sir, string separator);
unde:
ü sir este șirul din care se extrag subșirurile ;
ü separator este un şir care conţine posibilii delimitatori de
subşiruri.
103
Programarea în PHP
Funcţia lucrează în doi pași: la primul apel se returnează primul

subșir, iar începând cu al doilea apel se returnează subșirurile următoare
sau False dacă s-a atins sfârșitul șirului. Prezenţa șirului sir este
necesară numai la primul apel, începând cu al doilea apel este necesară
numai prezenţa separatorului separator. Modul de lucru al acestor
funcţii este ilustrat de scriptul următor:
<?php
$x="D:\wamp\lucru\Tipul de date string\Functii
String.php";
while($w!==false)
$w=strtok($x,"\.:");
{
echo "w=$w<br>";
$w=strtok("\.:");
}
?>
Execuţia va produce următorul rezultat :
w=D
w=wamp
w=lucru
w=Tipul de date string
w=Functii String
w=php
Observaţii. Începând cu versiunea PHP 4.1.0, atunci când se

întâlnește șirul vid (de exemplu, între separatorii : și \ din șirul $x există
un șir vid) acesta nu mai este extras, ci pur și simplu este sărit. Din acest
motiv am putea folosi instrucţiunea while($w) în locul instrucţiunii
while($w!==false), variabila $w luînd valoarea False numai atunci
când se atinge sfârșitul șirului. Totuși, varianta folosită în script este de
preferat, fiind mai riguroasă. Dacă se dorește să se extragă și subșirurile
separate prin spaţii, se adaugă și spaţiul în lista de separatori, adică se
înlocuiește $w=strtok($x,"\.:"); cu $w=strtok($x,"\. :"); și
$w=strtok("\.:"); cu $w=strtok("\. :");. Rezultatul obţinut
după efectuarea modificărilor și execuţia scriptului modificat este:
w=D
w=wamp
w=lucru
w=Tipul
104
şi a orei
w=de
w=date
w=string
w=Functii
w=String
w=php
Funcţia explode() face posibilă memorarea subșirurilor unui șir

într-un vector. Subșirurile trebuie să fie delimitate printr-un separator.
Sintaxa funcţiei este următoarea:
array explode (string separator, string sir, int n);
unde:
ü separator este un șir care delimitează subșirurile care vor fi
memorate în vector;
ü sir este șirul ale cărui subșiruri vor fi memorate în vector;
ü n este un argument opţional întreg care are următoarea semnificaţie:
ü dacă este pozitiv, în vector se vor memora n subșiruri: primele
n-1 componente vor conţine primele n-1 subșiruri, iar ultima
componentă va conţine restul șirului;
ü dacă este negativ, în vector se vor memora toate subșirurile, mai
puţin ultimile –n subșiruri.
Funcţia returnează vectorul cu subșirurile extrase, în caz de succes și

valoarea False în cazul în care separatorul precizat nu există în șir.
Prezenţa unui separator vid ("") va avea ca efect memorarea întregului șir
într-un vector cu o singură componentă.
Execuţia scriptului 6.5.php ilustrează posibilităţile funcţiei
explode().
Scriptul 6.5
<html>
<head>
</head>
<body>
<?php
// se extrag toate subsirurile delimitate de spatii

$situatie="Ionescu Mircea 7";
105
Programarea în PHP

$x=explode(" ",$situatie);
echo "<br>Separator care este prezent in sir(spatiul
alb).Subsiruri extrase:";
for ($i=0; $i<count($x); $i++) {
print "<br>x[$i]=$x[$i]";
}
// se extrag primele doua subsiruri delimitate de spatii

$x=explode(" ",$situatie,2);
echo"<br>Limita egala cu 2.Subsiruri extrase:";
for ($i=0; $i<count($x); $i++)
// se extrag toate subsirurile mai putin ultimile doua

$x=explode(" ",$situatie,-2);
echo"<br>Limita egala cu -2.Subsiruri extrase:";
for ($i=0; $i<count($x); $i++) {
}
// se extrage tot subsirul intr-o singura componenta

$x=explode("8",$situatie);
echo"<br>Separator care nu este in sir.Subsiruri extrase:";
for ($i=0; $i<count($x); $i++) {
}
// functia explode returneaza valoarea false

$x=explode("7",$situatie);
echo "<br>Separatorul este vid.Subsiruri extrase:";
if ($x) {
echo "<br>Nu se extrage nici un subsir; functia
intoarce valoarea false";
} else {
for ($i=0; $i<count($x); $i++) {
}
}
?>
</body>
</html>

Separator care este prezent in sir(spatiul alb).Subsiruri
extrase:
106
şi a orei
x[0]=Ionescu
x[1]=Mircea
x[2]=7
Limita egala cu 2.Subsiruri extrase:
x[0]=Ionescu
x[1]=Mircea 7
Limita egala cu -2.Subsiruri extrase:
x[0]=Ionescu
Separator care nu este in sir.Subsiruri extrase:
x[0]=Ionescu Mircea 7
Separatorul este vid.Subsiruri extrase:
Nu se extrage nici un subsir; functia intoarce valoarea
false
Funcţia implode() realizează operaţia simetrică funcţiei

explode(): construiește un șir „legând”, în ordinea în care sunt
memorate, elementele unui vector. Sintaxa funcţiei este următoarea:
string implode (string element_de_legatura, array
vector);
unde:
ü element_de_legatura este un șir de caractere care „leagă”
elementele vectorului;
ü vector este vectorul din ale cărui componente se construiește șirul.
Funcţia returnează șirul construit. În locul funcţiei implode() se

poate folosi funcţia join() care este un alias al ei.
Scriptul următor, precum și rezultatele execuţiei sale ilustrează
modul de lucru al funcţiei implode().
Scriptul 6.6
<html>
<head>
</head>
<body>
<?php
$situatie="Ionescu Mircea 7";
// se extrag in vectorul $x toate subsirurile delimitate de
spatii din sirul situatie
$x=explode(" ",$situatie);
echo "<br>S-a generat vectorul x:<br>";
for ($i=0; $i<count($x); $i++) {
print "x[$i]=$x[$i]<br>";
107
Programarea în PHP

}
// din elementele vectorului $x se genereaza sirul $y ,
elementul de legatura fiind virgula
$y=implode(",",$x);
echo "S-a generat sirul y:<br>$y";
?>
</body>
</html>

S-a generat sirul x:
x[0]=Ionescu
x[1]=Mircea
x[2]=7
S-a generat sirul y:
Ionescu,Mircea,7
6.4. Funcţii pentru curăţarea șirurilor:

trim(), ltrim(), rtrim(),
stripslashes(), strip_tags()
Funcţiile prezentate în acest paragraf permit eliminarea anumitor

caractere sau grupuri de caractere dintr-un șir.
Funcţiile trim(), ltrim() și rtrim() permit eliminarea
caracterelor blank (" "), newline ("\n"), carriage return
("\r"), tab orizontal ("\t"), tab vertical ("\x0B"),
caracterul nul (" \0") dintr-un șir, și opţional, a oricărui grup de
caractere precizat, după cum urmează:
ü trim() realizează eliminarea atât la începutul cât și la sfârșitul
șirului;
ü ltrim() realizează eliminarea doar la începutul șirului;
ü rtrim() realizează eliminarea doar la sfârșitul șirului;
Sintaxele acestor funcţii sunt, respectiv, următoarele:

ü string trim (string sir,string grup_de_caractere);
ü string ltrim (string sir,string grup_de_caractere);
108
şi a orei
ü string rtrim (string sir,string grup_de_caractere);

unde:
ü sir este sirul care va fi curăţat;
ü grup_de_caractere este un argument opţional prin care se
precizează caracterele din şir care vor fi eliminate;
Următorul script ilustrează modul de lucru al funcţiilor trim(),

ltrim() și rtrim().
Scriptul 6.7
<html>
<head>
</head>
<body>
<?php
// sirul initial
$sir="\tx=2 y=5 ";
echo "<br> Sirul initial este:<br>";
echo "<pre>$sir</pre>";
// se curata sirul de spatii atat la inceput cat si la

sfarsit
$x=trim($sir);
$y=$x."!";
echo "Sirul curatat la inceput si la sfarsit este:<br>";
echo "<pre>$y</pre>";
// se curata sirul de spatii doar la inceput

$x=ltrim($sir);
$y=$x."!";
echo "Sirul curatat la inceput este:<br>";
// se curata sirul de spatii doar la sfarsit

$x=rtrim($sir);
$y=$x."!";
echo "Sirul curatat la sfarsit este:<br>";
// se marcheaza sirul la sfarsit cu !

$sirm=$sir."!";
echo "Sirul marcat este:<br>";
echo "<pre>$sirm</pre>";
109
Programarea în PHP
// se elimina marcatorul ! din sirul sirm

$y=trim($sirm,"!");
echo "Sirul fara marcator este:<br>";
?>
</body>
</html>
Pentru a permite vizualizarea spaţiilor prezente în șirul sir a fost

folosită perechea de etichete <pre> și </pre>. În plus, a fost semnalată
extremitatea dreaptă a șirului printr-un marcator de sfârșit de șir.
Sirul initial este:
x=2 y=5
Sirul curatat la inceput si la sfarsit este:
x=2 y=5!
Sirul curatat la inceput este:
x=2 y=5!
Sirul curatat la sfarsit este:
x=2 y=5!
Sirul marcat este:
x=2 y=5!
Sirul fara marcator este:
x=2 y=5
Se observă că eliminarea marcatorului de sfârșit de șir "!" se face cu

ajutorul variantei funcţiei trim(), care utilizează un argument opţional (în
cazul de faţă șirul "!").
Funcţia stripslashes() permite eliminarea simbolurilor
backslash (\) adăugate explicit cu funcţia addslash() sau automat, dacă
directiva magic_quotes_gpc din fișierul phpini() este activată (în
mod implicit este activată). Adăugarea simbolurilor backslash se face în
scopul evitării unor caractere ( ' , " sau \).
Sintaxa funcţiei stripslashes() este următoarea:
string stripslashes(string sir);
unde sir este șirul care trebuie sa fie curăţat.
110
şi a orei
O ilustrare a modului de lucru a acestei funcţii este dată de execuţia

scriptului 6.8.php:
Scriptul 6.8
<html>
<head>
</head>
<body>
<?php
$z="Atunci, O'Neal a spus in limba romana:'Imi place
Romania'";
echo "<br>Sirul generat este: $z";
//se adauga backslashuri in fata apostrofurilor
$z=addslashes($z);
echo "<br>Sirul generat dupa aplicarea functiei
addslashes(); este: $z";
//se elimina backslashurile adaugate
$z=stripslashes($z);
echo "<br>Sirul generat dupa aplicarea functiei
stripslashes() este: $z";
?>
</body>
</html>
Rezultatele execuţiei scriptului 6.8.php sunt prezentate mai jos şi

arată șirul iniţial, apoi șirul modificat prin adăugarea backslashurilor cu
ajutorul funcţiei addslashes(), și în final șirul curăţat de slashuri cu
ajutorul funcţiei stripslashes().
Sirul generat este: Atunci, O'Neal a spus in limba
romana:'Imi place Romania'
Sirul generat dupa aplicarea functiei addslashes(); este:
Atunci, O\'Neal a spus in limba romana:\'Imi place
Romania\'
Sirul generat dupa aplicarea functiei stripslashes() este:
Atunci, O'Neal a spus in limba romana:'Imi place Romania'
Funcţia strip_tags() elimină etichetele (tags) HTML dintr-un

text. Acest lucru este necesar, de exemplu, atunci cand preluăm un text de
la tastatură prin intermediul unui formular. Prezenţa etichetelor HTML
într-un astfel de text poate produce efecte nedorite asupra formatării paginii
web rezultate. De exemplu, dacă în caseta unui formular se tastează textul
<br><i> x=$x</i>
111
Programarea în PHP
acesta va fi afișat sub forma

x=7
deoarece vor fi interpretate corespunzător etichetele <br> (salt la rând nou)
și perechea de etichete <i> și </i> (scriere italică a textului).
Funcţia strip_tags() are următoarea sintaxă:
string strip_tags ( string sir, string etichete );
unde:
ü sir este șirul din care se elimină etichetele HTML;
ü etichete reprezintă un șir care conţine o listă de etichete HTML
care vor fi exceptate de la ștergere din șirul sir. Etichetele din
această listă nu trebuie să fie despărţite de nici un caracter. O
etichetă HTML prezentă în lista de excepţii și care are pereche (de
exemplu, perechea etichetei <i> este </i> și invers) va fi exceptată
împreună cu perechea ei.
Codul și rezultatele execuţiei scriptului 6.9.php arată posibilităţile
oferite de această funcţie în eliminarea etichetelor HTML dintr-un text.
Scriptul 6.9
<html>
<head>
</head>
<body>
<?php
$x=7;
// generarea unui sir care contine etichete HTML
$z="<br><b><i>x=$x</i></b>";
echo "<br>Valoarea initiala a sirului este: $z";
// se elimina toate etichetele HTML, cu exceptia etichetei

<i>
$x=strip_tags($z,"<i>");
echo "<br>Valoarea sirului dupa ce au fost eliminate
etichetele HTML, cu exceptia etichetei care determina
scrierea italica, este:$x";
// se elimina toate etichetele HTML, cu exceptia etichetei
<i> si a etichetei <br>
$x=strip_tags($z,"<i><br>");
etichetele HTML, cu exceptia etichetei de salt si a celei
care determina scrierea italica, este:$x";
112
şi a orei

// se elimina toate etichetele HTML
$x=strip_tags($z);
etichetele HTML este:$x";
?>
</body>
</html>

Valoarea initiala a sirului este:
x=7
Valoarea sirului dupa ce au fost eliminate etichetele HTML,
cu exceptia etichetei care determina scrierea italica,
este:x=7
Valoarea sirului dupa ce au fost eliminate etichetele HTML,
cu exceptia etichetei de salt si a celei care determina
scrierea italica, este:
x=7
Valoarea sirului dupa ce au fost eliminate etichetele HTML
este: x=7
6.5. Alte funcţii utile pentru

prelucrarea șirurilor de caractere
Funcţia strlen() returnează lungimea (numărul caracterelor)

dintr-un șir. Funcţia are următoarea sintaxă:
int strlen(string sir );
unde sir este șirul a cărui lungime se determină.
Funcţia strpos() determină poziţia dintr-un șir, la care începe un
subșir precizat. În caz de succes funcţia întoarce poziţia găsită, iar în caz
contrar valoarea False.
int strpos(string sir,string subsir,int start_poz);
unde:
ü sir este șirul în care se caută subșirul;
ü subsir este subșirul care se caută în sir;
ü start_poz este un parametru opţional care arată poziţia din sir de
la care începe căutarea.
113
Programarea în PHP
În secvenţa de program de mai jos se verifică dacă subșirul "Ion"

este sau nu în listă.
<?php
$lista="Ion, George, Gheorghe";
$poz=strpos($lista,'Ion');
if ($poz == false) {
echo "Ion nu este in lista.";
} else {
echo "Ion este in lista.";
}
?>
Ion nu este in lista.
La prima vedere, acest rezultat pare greşit. Totuși, dacă analizăm cu
atenţie instrucţiunile, vom găsi o explicaţie logică pentru acest rezultat
aparent contradictoriu. În mod normal, funcţia strpos() întoarce
valoarea False când se atinge sfășitul șirului (echivalent aici cu a spune că
Ion nu este in listă). Pe de altă parte, dacă poziţia întoarsă de strpos()
este 0 (cazul nostru), această valoare va fi interpretată tot ca valoarea
booleană False, de unde și confuzia creată. Pentru a evita aceste confuzii
în locul operatorului == vom folosi operatorul ===, care testează atât
valorile operanzilor cât și tipurile lor. Astfel, 0 și False fiind de tipuri
diferite, rezultatul comparaţiei 0===false va fi False și nu True ca în
expresia 0==false.
În concluzie, pentru a obţine rezultatul corect
Ion este in lista.
testul if ($poz == false) se va modifica în if($poz===false).
În următoarea secvenţă de program se caută un subșir începând de la

o anumită poziţie a șirului. Din acest motiv, în apelul funcţiei strpos()
va apare și argumentul opţional prin care se precizează poziţia de pornire.
Astfel, execuţia secvenţei de program
<?php
$start_poz=9;
$poz=strpos($lista,'org',$start_poz);
if ($poz !== false) {
114
şi a orei
echo "Pozitia la care incepe sirul org este

$poz.";
} else {
echo "Subsirul \"org\"nu se gaseste in cea de-a
doua jumatate a sirului care incepe cu
pozitia $start_poz.";
}
?>
va avea ca rezultat mesajul:

Pozitia la care incepe subsirul org este 16.
Observaţie. Căutarea subșirului 'org' se face începând cu poziţia

9. Din acest motiv, subșirul "org" de pe poziţia 7 din subșirul "George"
nu este depistat.
O altă posibilitate (mai puţin rapidă decât funcţia strpos()) de a

stabili dacă un șir este subșir într-un șir dat este utilizarea funcţiei
strstr(). Funcţia strstr() caută un subșir într-un șir, iar în caz de
succes returnează porţiunea de șir cuprinsă între primul element al
subșirului găsit și sfârșitul șirului. În caz de insucces se returnează valoarea
False.
string strstr(string sir, string subsir );
unde:
ü sir este șirul în care se caută un anumit subșir;
ü subsir este subșirul căutat;
Ca exemplu, prezentăm mai jos o secvenţă de program obţinută prin
modificarea exemplelor folosite în cazul funcţiei strpos():
<?php
$subsir="Geo";
$sirreturn=strstr($lista,$subsir);
if ($sirreturn === false) {
echo "Geo nu este in subsir in lista";
} else {
echo "Geo este subsir in lista, iar subsirul
returnat este: $sirreturn ";
?>
115
Programarea în PHP

Geo este subsir in lista, iar subsirul returnat este:
George, Gheorghe
Observaţie. Funcţia strstr() este dependentă de capitalizare

(case-sensitive). Varianta independentă de capitalizare (case-insensitive) a
acestei funcţii este funcţia stristr().
Funcţia substr() permite extragerea unui subșir dintr-un șir dat
care începe la o anumită poziţie și are o anumită lungime. Sintaxa funcţiei
substr() este următoarea:
substr(string sir, int inc, int lungime);
unde:
ü sir este șirul din care se extrage subșirul;
ü inc reprezintă:
ü poziţia la care începe subșirul pe care-l extragem, dacă
parametrul inc este un întreg pozitiv (se numără începând cu 0,
un număr de inc caractere);
ü poziţia la care începe subșirul pe care-l extragem, dacă
parametrul inc este un întreg negativ (se numără de la sfârșitul
șirului un număr de inc caractere);
ü lungime este un parametru opţional care indică:
ü lungimea subşirului extras (cel mult lungime caractere) dacă
parametrul lungime este un întreg pozitiv;
ü faptul că se omite un număr de lungime caractere de la sfârşitul
şirului, dacă parametrul lungime este un întreg negativ.
Următoarea secvenţă de program extrage în patru moduri diferite,

anul, ziua și data dintr-un șir care reprezintă codul numeric personal al unei
persoane, utilizând funcţia substr().
<?php
$x="2591024293148";
echo substr($x,1,6)."<br>";
echo substr($x,-12,6)."<br>";
echo substr($x,-12,-6)."<br>";
echo substr($x,1,-6)."<br>";
?>
116
şi a orei

591024
591024
591024
591024
Funcţia str_replace() permite înlocuirea unui subșir de caractere
din cadrul unui șir cu un șir dat. Se înlocuiesc toate apariţiile subșirului.
tip str_replace( tip deinlocuit, tip seinlocuiestecu,
tip sir, int n);
unde:
ü tip poate fi string sau array;
ü sir este șirul în care se fac înlocuirile;
ü parametrul deinlocuit reprezintă șirul sau vectorul de șiruri care
vor fi înlocuite în toate apariţiile lor in șirul sir;
ü parametrul seinlocuiestecu reprezintă șirul sau vectorul de
șiruri cu care se face înlocuirea;
ü parametrul n este un parametru opţional și reprezintă numărul
înlocuirilor care se efectuează.
Următoarea secvenţă de program ilustrează modul în care se face

înlocuirea unui subșir de caractere dintr-un șir, cu un șir precizat. Astfel,
subșirul "Ionescu" va fi înlocuit cu "Ionascu" în ambele sale apariţii din
șirul $sir.
<?php
$sir="Ionescu, Popescu, Georgescu, Ionescu";
echo "<br>Sirul initial este:<br>$sir";
$deinlocuit="Ionescu";
$seinlocuiestecu="Ionascu";
$sir=str_replace($deinlocuit, $seinlocuiestecu, $sir);
echo "<br>Sirul modificat este:<br>$sir";
?>

Sirul initial este:
Ionescu, Popescu, Georgescu, Ionescu
Sirul modificat este:
Ionascu, Popescu, Georgescu, Ionascu
117
Programarea în PHP
În cazul în care avem mai multe șiruri de modificat, iar în fiecare

dintre ele mai multe modificări de făcut, șirurile care trebuie modificate
(parametru sir), modificările (parametrul seinlocuiestecu), precum și
subșirurile care vor fi înlocuite (parametrul deinlocuit), vor fi
organizate ca niște vectori. În mod normal, subșirul egal cu prima
componentă a vectorului deinlocuit va fi înlocuită cu prima
componentă a vectorului seinlocuiestecu, subșirul egal cu a doua
componentă a vectorului deinlocuit va fi înlocuită cu a doua
componentă a vectorului seinlocuiestecu etc.
Astfel, în urma execuţiei secvenţei de program de mai jos, șirul
"Ionescu", se înlocuiește cu șirul "Ionascu", iar șirul "Tudor" se
înlocuiește cu șirul "Teodor".
<?php
$sir=array("Persoana de contact este Ionescu Tudor",
"email: Ionescu.Tudor@yahoo.com");
echo "<br>Sirurile initiale sunt:";
for ($i=0; $i<count($sir); $i++) {
echo "<br>$sir[$i]";
}
$deinlocuit=array("Ionescu", "Tudor");
$seinlocuiestecu=array("Ionascu", "Teodor");
$sir=str_replace($deinlocuit, $seinlocuiestecu, $sir);
echo "<br>Sirurile modificate sunt:";
}
?>
Rezultatele execuţiei sunt următoarele:

Sirurile initiale sunt:
Persoana de contact este Ionescu Tudor
email: Ionescu.Tudor@yahoo.com
Sirurile modificate sunt:
Persoana de contact este Ionascu Teodor
email: Ionascu.Teodor@yahoo.com
Observaţii
ü Dacă vectorul $deinlocuit are mai multe componente decât
vectorul $seinlocuiestecu, componentele în exces se înlocuiesc
cu șirul vid ("").
118
şi a orei
De exemplu, secvenţa de program

<?php
//vectorul deinlocuit are mai multe elemente ca vectorul
seinlocuiestecu
"email: Ionescu.Tudor@yahoo.com");
}
$deinlocuit=array("Ionescu", "Tudor");
$seinlocuiestecu=array("Ionascu");
$sir=str_replace($deinlocuit, $seinlocuiestecu, $sir,
$nrinloc);
}
echo "<br> S-au facut $nrinloc inlocuiri";
?>
va produce următorul rezultat:

Persoana de contact este Ionascu
email: Ionascu.@yahoo.com
S-au facut 4 inlocuiri
ü Prin simetrie, dacă vectorul $deinlocuit are mai puţine

componente decât vectorul $seinlocuiestecu , componentele în
exces se ignoră.
Astfel, executând secvenţa de program
<?php
//vectorul deinlocuit are mai putine elemente ca vectorul
seinlocuiestecu
"email: Ionescu.Tudor@yahoo.com ");
}
$deinlocuit=array("Ionescu");
$seinlocuiestecu=array("Ionascu", "Teodor");
119
Programarea în PHP
$sir=str_replace($deinlocuit, $seinlocuiestecu, $sir,

$nrinloc);
}
echo "<br> S-au facut $nrinloc inlocuiri";
?>
se va produce următorul rezultat:

Persoana de contact este Ionascu Tudor
email: Ionascu.Tudor@yahoo.com
S-au facut 2 inlocuiri
Funcţia substr_replace() extrage (ca și funcţia substr()) un

subșir și în plus îl înlocuiește cu un șir dat. Sintaxa funcţiei
substr_replace() este următoarea:
tip substr_replace(tip sir, string seinlocuiestecu,
int inc, int lungime);
unde:
ü tip poate fi string sau array;
ü parametrii sir, inc, lungime au semnificaţia prezentată la sintaxa
funcţiei substr();
ü parametrul seinlocuiestecu reprezintă șirul cu care se
înlocuiește subșirul precizat prin indexul de început inc și prin
parametrul lungime.
Exemplul următor arată diverse moduri de a înlocui data de naștere

dintr-un șir care reprezintă un cod numeric personal:
$x="2591024293148";
echo substr_replace($x,"551120",1,6)."<br>";
echo substr_replace($x,"551120",-12,6)."<br>";
echo substr_replace($x,"551120",-12,-6)."<br>";
echo substr_replace($x,"551120",1,-6)."<br>";
Rezultatul execuţiei secvenţei de program de mai sus este următorul:
120
şi a orei
2551120293148
2551120293148
2551120293148
2551120293148
6.6. Funcţii pentru prelucrarea datelor

calendaristice şi a orei
Limbajul PHP utilizează o serie de funcţii de lucru cu datele

calendaristice şi cu ora. Acestea acoperă prin flexibilitatea lor cerinţele
legate de reprezentarea şi gestionarea timpului în scripturile PHP.
Prezentăm în continuare câteva din aceste funcţii: time(),date(),
getdate(), mktime(),checkdate().
Sintaxa funcţiei time() este următoarea:
int time(void);
unde cuvântul rezervat void semnifică aici absenţa parametrilor.
Funcţia time() întoarce un număr întreg care reprezintă numărul de
secunde scurse de la miezul nopţii din data de 1 ianuarie 1970, moment
considerat începutul epocii Unix. Această valoare se numeşte timestamp
(marcă temporală). Cu alte cuvinte, funcţia time() întoarce marca
temporală curentă. Folosirea acestei mărci înlesneşte precizarea timpului
atunci când ne referim la o dată viitoare sau trecută. De exemplu, peste
două zile, ne vom situa la time()+2*24*60*60 secunde depărtare de
momentul zero al epocii Unix..
Una din funcţiile care permit convertirea mărcii temporale într-un
format utilizat în mod obişnuit este funcţia date(). Funcţia are
următoarea sintaxă :
string date(string format,int valtimestamp);
unde:
ü format este formatul de reprezentare ;
ü valtimestamp este un parametru opţional care indică valoarea unei
mărci temporale. Dacă parametrul lipseşte valoarea acestei mărci este
timpul curent.
121
Programarea în PHP
În Tabelul 6.2 sunt prezentate majoritatea caracterelelor care pot

intra în componenţa şirului format, conform manualului PHP
(http://php.net/manual/en/function.date.php).
Tabelul 6.2. Exemple de coduri de format pentru funcţia date()

Caracter Descriere Exemplu
Ante meridian (am) sau Post meridian (pm)
a am
cu litere mici
Ante Meridian (AM) sau Post Meridian
A PM
(PM) cu litere mari
u Microsecunde 43201
Secunde ( 2 cifre cu zerouri nesemnificative
s 03 sau 53
dacă e cazul)
Minute ( 2 cifre cu zerouri nesemnificative
i 09 sau 27
dacă e cazul)
Oră (format de 12 ore cu zerouri
h 07 sau 11
nesemnificative dacă e cazul)
Oră (format de 12 ore fără zerouri
g 7 sau 11
nesemnificative)
Oră (format de 24 ore cu zerouri
H 00,01,…,23
Oră (format de 24 ore fără zerouri
G 0,1,2,…,23
Ziua din lună cu zerouri nesemnificative
d 05 sau 23
(dacă e cazul)
j Ziua din lună fără zerouri nesemnificative 5
Ziua din săptămână (primele 3 litere, în
D Mon
engleză)
l(L
Ziua din săptămână (în engleză) Monday
mic)
Ziua din săptămână în cifre (0 pentru
w 2
Duminică, 1 pentru Luni etc.
z Ziua din an (0-365) 43
Sufixul ordinal în engleză pentru ziua din
S st,nd,rd,th
lună
122
şi a orei
Tabelul 6.2. (continuare)

Luna din an cu zerouri nesemnificative
m 02 sau 11
(dacă e cazul)
n Luna din an fără zerouri nesemnificative 2
M Luna din an (primele 3 litere, în engleză) Oct
F Luna din an (în engleză) October
Y Anul reprezentat cu 4 cifre 2011
y Anul reprezentat cu 2 cifre 11
An bisect (1pentru an bisect, 0 în caz
L 0 sau 1
contrar)
Număr de secunde de la începutul epocii
U 1251133321
(timestamp)
Mon, 24 Aug
2009
r Data complet standardizată
20:09:45
+0300
Scriptul 6.10.php, prezentat mai jos ilustrează modul de folosire al

funcţiei date().
Scriptul 6.10
<html>
<head>
</head>
<body>
<?php
$timestamp=time();
echo "Suntem in data de ";
$data=date("j F Y \o\\r\a g.i:s A", $timestamp);
echo "$data";
?>
</body>
</html>
Rezultatul afişat în urma execuţiei scriptului 6.10.php va fi ceva

asemănător cu următorul mesaj:
Suntem in data de 22 August 2009 ora 4.22:00 PM
123
Programarea în PHP
Observaţie. Analizând rezultatul de mai sus recunoaştem efectul

folosirii caracterelor j F Y şi g i s A în scrierea datei 22 August
2009 şi respectiv a orei 4.22:00 PM. De asemenea, observăm că
fiecare dintre caracterele cuvântului ora face parte din codurile de
formatare: o şi a se regăsesc printre caracterele descrise în Tabelul 6.2, iar
\r este caracterul de control pentru carriage return. Procesarea lor a
fost evitată prin plasarea în faţa literei o a unui caracter de evitare
backslash (\) , iar în faţa literei r a două caractere de evitare backslash .
Funcţia getdate()este folosită, ca şi funcţia date(), pentru
convertirea unui timestamp într-un format inteligibil. Sintaxa funcţiei
getdate() este următoarea:
array getdate(int valtimestamp);
unde valtimestamp este un parametru opţional care indică valoarea unei
mărci temporale. Dacă parametrul lipseşte valoarea acestei mărci este
timpul curent. Funcţia întoarce un vector asociativ. Cheile şi semnificaţia
valorilor memorate la aceste chei sunt prezentate în Tabelul 6.3, conform
manualului PHP (http://www.php.net/manual/en/function.getdate.php).
Tabelul 6.3. Cheile vectorului asociativ returnat de funcţia getdate()

Cheie Semnificaţie Exemplu
seconds Numărul de secunde (0-59) 43
minutes Numărul de minute (0-59) 58
hours Ora din zi (0-23) 21
mday Ziua din lună (1-31) 14
wday Ziua din săptămână (0-6) 3
mon Luna din an (1-12) 11
year Anul în reprezentarea cu 4 cifre 2011
yday Ziua din an (0-365) 23
weekday Ziua săptămânii (în engleză) Monday
month Luna din an (în engleză) February
Număr de secunde de la începutul epocii
0 1251133321
(timestamp)
O exemplificare a modului în care lucrează funcţia getdate()este

prezentată în scriptul 6.11.php.
124
şi a orei
Scriptul 6.11
<html>
<head>
<body>
<?php
$timestamp=time();
$v=getdate($timestamp);
echo "Suntem in data de".$v['mday']."/"
.$v['mon']."/".$v['year'];
echo " ora ".$v['hours']."." .$v['minutes'].
":".$v['seconds'];
?>
</body>
</html>
Execuţia scriptului 6.11.php va produce un rezultat asemănător cu

mesajul:
Suntem in data de 24/8/2009 ora 19.22:57
Funcţia mktime() permite obţinerea unui timestamp precizând ca
parametrii ai funcţiei: ora, minutul, secunda, luna, ziua şi
anul. Sintaxa funcţiei este următoarea:
int mktime(int ora, int minutul, int secunda, int
luna, int ziua, int anul);
Toate argumentele sunt opţionale. Ele pot fi omise în ordinea de la
dreapta spre stânga. Argumentele omise se înlocuiesc automat cu valorile
datei şi ale orei curente.
Scriptul 6.12
<html>
<head>
</head>
<body>
<?php
$timestamp=mktime(19,22,57,8,24,2009);
$v=getdate($timestamp);
echo "Suntem in data de ".$v['mday']."/"
.$v['mon']."/".$v['year'];
125
Programarea în PHP

echo " ora ".$v['hours']."." .$v['minutes'].
":".$v['seconds'];
?>
</body>
</html>
Rezultatul execuţiei scriptului 6.12.php este, evident, următorul:

Suntem in data de 24/8/2009 ora 19.22:57
Funcţia checkdate() permite verificarea corectitudinii
informaţiilor privind ziua, luna şi anul unei date calendaristice. Data este
considerată corectă dacă sunt îndeplinite următoarele condiţii: ziua este
cuprinsă între 1 şi limita admisă pentru fiecare lună, ţinând cont inclusiv de
anii bisecţi, luna este cuprinsă între 1 şi 12, anul este cuprins între 1 şi
32767. Dacă data este corectă funcţia întoarce valoare True, iar în caz
contrar valoarea False.
bool checkdate(int luna, int ziua, int anul);
Scriptul 6.13.php verifică corectitudinea datei de 24-08-2009.
Scriptul 6.13
<html>
<head>
</head>
<body>
<?php
$check=checkdate(8,24,2009);
if ($check) {
print "Data este valida!";
} else {
print "Data nu este valida!";
}
?>
</body>
</html>
Rezultatul execuţiei scriptului 6.13.php este: Data este valida!
126
P H P
Capitolul 7
7. Transmiterea datelor
către scripturile PHP
Toate exemplele prezentate până acum au prelucrat date generate în

cadrul unui script. În astfel de situaţii, modificarea datelor de execuţie
presupune modificări în codul sursă al scriptului. Alternativa cea mai
naturală pentru evitarea unui astfel de inconvenient este transmiterea
datelor de la tastatura clientului. Transmiterea datelor de la client către
scriptul PHP de pe server, pentru prelucrare se poate face cu ajutorul unui
formular, dar şi „manual”, ataşându-le la adresa URL a fişierului PHP.
De exemplu, transmiterea manuală a valorilor 7 și 10 către un script
(să-i spunem, de exemplu, maxim.php), care stabilește maximul dintre două
numere, se poate face folosind una din variantele:
ü direct în bara de adrese a browserului, tastând
http://localhost/maxim.php?nr1=7&nr2=10
ü din interiorul unui script HTML, activând o legătură de genul
<a href="maxim.php?x=7&y=10">Click aici pentru a
transmite date</a>
Cu astfel de construcţii, putem transmite către un script PHP șiruri
întregi de date organizate sub forma:
127
Programarea în PHP
?variabila_1=valoare_1&variabila_2=valoare_2&...variab
ila_n=valoare_n.
Totuşi, acest sistem „manual” se foloseşte de regulă când vrem să
transmitem către scripturi un număr mic de valori. De asemenea, datorită
faptului că datele transmise sunt vizualizate în bara de adrese a
browserului, metoda „manuală” nu se folosește în cazul în care dorim ca
aceste date să rămână confidenţiale (de exemplu, nu se pot transmite
parole).
Prin facilităţile de comunicare oferite, formularul HTML rămâne
instrumentul principal de transmitere a datelor câtre scripturi. Capitolul 8
este dedicat în întregime descrierii principalelor etichete (tag-uri) ale unui
formular. În acest capitol însă, vom considera următoarea structură
simplificată de formular:
<form action="nume_script" method ="metoda">
<input type="tip" name="nume" value="valoare"
size="marime">
etichete formular cu atribute
</form>.
unde:
ü nume_script este numele scriptului care prelucrează datele
transmise;
ü metoda reprezintă metoda de transmitere a datelor către scriptul de
prelucrare;
ü etichetele formular pot fi : input, textarea, select etc.
Metodele folosite pentru transmiterea datelor sunt GET și POST.
Utilizând metoda GET, datele sunt ataşate la adresa URL exact ca şi
în cazul transmiterii manuale. Din acest motiv, principalele neajunsuri ale
transmiterii manuale – lipsa confidenţialităţi, volumul limitat al datelor care
pot fi transmise, faptul că nu se pot transmite decât caractere ASCII – le
întâlnim şi în cazul metodei GET.
Spre deosebire de metoda „manuală” și de metoda GET, metoda
POST asigură confidenţialitatea transmiterii datelor, deoarece acestea nu
sunt vizualizate în bara browserului. Aceste avantaje o recomandă ca fiind
metoda favorită de transmitere a datelor către scripturi.
128
Capitolul 7. Transmiterea datelor către scripturile PHP
Întrebarea la care vom răspunde acum este următoarea: „Cum se pot

accesa datele transmise în scriptul PHP ?”. În principiu, există două
posibilităţi.
Să presupunem că în cadrul etichetei input a a unui formular,
parametrul name are forma name="nume_variabila". La destinaţie, în
scriptul PHP spre care s-a transmis, variabila va fi accesibilă sub forma
$_POST['nume_variabila'], dacă s-a folosit metoda POST, sau
$_GET['nume_variabila'] dacă s-a folosit metoda „manuală” sau
metoda GET. Aceasta este prima posibilitate şi este recomandată ca fiind
sigură.
A doua posibilitate permite accesul la datele transmise sub forma
mai simplă $nume_variabila. Deşi pare mai atractivă, folosirea acestei
metode este condiţionată de setarea Globals = on în fişierul php.ini.
Pe de altă parte, renunţarea la setarea implicită Globals = off măreşte
considerabil insecuritatea aplicaţiei web, ceea ce este un motiv serios
pentru a alege varianta de accesare a datelor prin intermediul vectorilor
superglobali $_POST sau $_GET.
În cele ce urmează, ilustrăm transmiterea datelor către scripturi prin
câteva exemple.
7.1. Transmiterea datelor către

scripturile PHP utilizând
link-urile HTML
Scriptul 7.1.php, prezentat mai jos, conţine numai cod HTML. El a

fost realizat cu unicul scop de a crea un link care are atașate date pentru a fi
prelucrare în scriptul 7.2.php.
Scriptul 7.1
<html>
<head>
</head>
<body>
129
Programarea în PHP

<a href="7.2.php?x=7&y=10">Click aici pentru a transmite
date!</a>
</body>
</html>
Rezultatul execuţiei scriptului 7.1.php este link-ul:

Click aici pentru a transmite date!
Executând click pe acest link, se lansează în execuţie scriptul

7.2.php, care primește datele atașate linkului prin metoda GET. Din acest
motiv, valorile transmise sunt recuperate în scriptul 7.2.php prin variabila
superglobală $_GET;
Scriptul 7.2
<html>
<head>
</head>
<body>
<?php
$x=$_GET['x'];
$y=$_GET['y'];
echo "Rezultat comparatie: ";
if ($x < $y) {
print "Maximul dintre x=$x si y=$y este y=$y";
} else {
print "Maximul dintre x=$x si y=$y este x=$x";
}
?>
</body>
</html>
După cum era de așteptat, rezultatul execuţiei scriptului 7.1.php este:

Rezultat comparatie: Maximul dintre x=7 si y=10 este
y=10
130
7.2. Transmiterea datelor către

scripturile PHP cu ajutorul
formularelor HTML
În această secţiune ne-am propus să dăm câteva exemple de utilizare

a formularelor în transmiterea datelor către scripturi. Pentru început,
prezentăm mai jos scriptul 7.3.php. Acest script conţine cod HTML pentru
creearea unui formular necesar transmiterii datelor de la tastatură către
scriptul 7.4.php .
Scriptul 7.3
<html>
<head>
</head>
<body>
<form action="7.4.php" method ="POST">
<b>x=</b><input type="text" name="x" size="3"><br>
<b>y=</b><input type="text" name="y" size="3"><br>
<input type="submit" name="trimite" value ="Compara">
</form>
</body>
</html>
După execuţia scriptului 7.3.php, pe ecran va apare imaginea (Figura 7.1):
Figura 7.1. Rezultatul execuţiei scriptului 7.3.php
Cele două casete sunt generate de codul HTML:

<b>x=</b><input type="text" name="x" size="3"><br>
131
Programarea în PHP
Ele permit introducerea datelor pe care le comparăm în casetele

etichetate x respectiv y. Lăţimea casetelor este precizată în atributul size
şi se referă la numărul de caractere vizibile în casetă. După completarea
casetelor, acestea arată ca mai jos (Fig. 7.2):
Figura 7.2. Rezultatul execuţiei scriptului 7.3.php,

după ce au fost completate casetele
În acest moment se poate executa click pe butonul Compara, buton

generat de codul
<input type="submit" name="trimite" value ="Compara">
Efectul este trimiterea celor două valori către scriptul de prelucrare

7.4.php. Acest transfer al datelor de intrare este posibil datorită prezenţei în
cadrul etichetei form (care de altfel marchează şi începutul formularului) a
două atribute: action şi method.
Atributul action indică numele scriptului care va prelucra datele din
formular (în cazul de faţă scriptul 7.4.php), iar atributul method arată
metoda aleasă pentru a transmite aceste date (în cazul în cazul de faţă
metoda POST).
Scriptul 7.4.php prezentat în continuare, conţine o combinaţie de cod
HTML și de cod PHP:
Scriptul 7.4
<html>
<head>
</head>
132

<body>
<?php
$x=$_POST['x'];
$y=$_POST['y'];
echo "Rezultat comparatie: ";
if ($x < $y) {
print "x=$x este strict mai mic decat y=$y";
} else if ($x>$y) {
print "x=$x este strict mai mare decat y=$y";
} else {
print "x=$x este egal cu y=$y";
}
?>
<p><a href="7.3.php">Inapoi la formular</a></p>
</body>
</html>
Deoarece am ales ca metodă de transmitere a datelor metoda POST,

scriptul 7.4.php va avea acces la valorile x și y tastate în cele două casete
prin intermediul vectorului superglobal $_POST.
Mai precis, în variabila $_POST['x'] se va găsi valoarea tastată în
caseta etichetată x, iar în $_POST['y'], se va găsi valoarea tastată în
caseta etichetată y. În continuare se compară valorile transmise, iar
rezultatul este afişat în browser cu ajutorul funcţiei echo(). Rezultatul
afișat este următorul:
Rezultat comparatie: x=3 este strict mai mic decat y=5
Inapoi la formular
Pentru a reveni la formular în vederea unei noi sesiuni de lucru se
execută click pe linkul Inapoi la formular.
Acesta este generat de codul
<p><a href="7.3.php">Inapoi la formular</a></p>
Observaţie. După ce s-a executat scriptul PHP, la revenirea în

pagina în care este afişat fomularul, constatăm că valorile 3 şi 5 au dispărut
din casetele lor. Dacă dorim ca în aceste casete să menţinem nişte valori
implicite (să zicem 5 și 10), modificabile de către utilizator, adăugăm
etichetelor input de tip text, atributele value. Concret, în scriptul
7.3.php etichetele input de tip text vor fi modificate astfel:
133
Programarea în PHP
<b>x=</b><input
type="text"name="x"value="5"size="3"><br>
<b>y=</b><input
type="text"name="y"value="10"size="3"><br>
Ca urmare, după această modificare, de fiecare dată când lansăm în

execuţie scriptul 7.3.php, pe ecran va apărea imaginea de mai jos (Fig. 7.3),
cu valorile implicite 5 și 10 care pot fi modificate de către utilizator.
Figura 7.3. Rezultatul execuţiei scriptului 7.3.php modificat: formularul

obişnuit a fost transformat în formular cu „memorie”
Observaţie. Un formular cu valori implicite se mai numește

formular cu „memorie”.
7.2.1. Folosirea unui singur script atât

pentru transmiterea datelor prin
formular, cât și pentru prelucrarea lor
În exemplul prezentat anterior formularul pentru transmitere a fost

creat în fişierul 7.3.php, iar programul de prelucrare a datelor transmise a
fost creat în fişierul 7.4.php. Există posibilitatea să combinăm codul cele
două fişiere într-unul singur. În principiu, se pot urma două variante pentru
a realiza acest obiectiv.
Prima variantă are forma:
if (formularul_este_transmis){
//Trateaza formular
}
134
//Afiseaza formular
A doua variantă are forma:

if (formularul_este_transmis){
//Trateaza formular
} else {
//Afiseaza formular
}
Pentru exemplificarea primei variante, prezentăm mai jos scriptul

7.5.php. Scriptul citește de la tastatură două numere, le adună și afișează
suma lor.
Scriptul 7.5
<?php
if (isset($_POST['trimite'])) {
$x=$_POST['x'];
$y=$_POST['y'];
echo "Suma numerelor x=$x si y=$y este=". ($x+$y);
}
?>
<html>
<head>
</head>
<body>
<h3>
Calculator pentru adunarea a doua numere
</h3>
<form action="<?php echo $_SERVER[PHP_SELF]?>" method
="POST" >
<br>x:<input type="text" name="x" size="8">
<br>y:<input type="text" name="y" size="8">
<br><input type="submit" name="trimite" value ="Trimite
datele de intrare" >
</form>
</body>
</html>
După cum se poate observa, valoarea atributului action al

formularului este $_SERVER[PHP_SELF]. Variabila $_SERVER
[PHP_SELF] este o variabilă globală, echivalentă cu numele scriptului
curent, adică, în cazul nostru cu 7.5.php (se poate scrie în loc de . "<?php
echo $_SERVER[PHP_SELF]?>", pur și simplu "7.5.php"). De altfel,
135
Programarea în PHP
numele 7.5.php poate fi văzut în bara de adrese a browserului. Efectul

acestei acţiuni este reîncărcarea automată a scriptului 7.5.php.
În general, funcţia isset($var) întoarce valoarea True dacă
variabila $var a fost creată și valoarea False în caz contrar. Variabila
$_POST['trimite'] este creată din momentul în care s-au transmis
prima dată spre prelucrare datele de intrare (de când s-a executat prima dată
click pe butonul de trimitere). Din acest motiv, la prima lansare în execuţie
a scriptului 7.5.php funcţia isset($_POST['trimite']) va întoarce
valoarea False (datele nu au fost încă transmise). Ca urmare, se va afișa
formularul HTML unde se vor introduce datele pentru prelucrare.
Transmiterea datelor către script are ca efect crearea variabilei
$_POST['trimite'] și în consecinţă funcţia isset($_POST
['trimite'] ia valoarea True, fapt ce determină execuţia secvenţei de
cod
{
$x=$_POST['x'];
$y=$_POST['y'];
echo"Suma numerelor x=$x si y=$y este=".($x+$y);
}
După prelucrarea datelor și afișarea rezultatului se afișează din nou
formularul și ciclul se reia.
Dacă ne interesează ca la o lansare a scriptului, formularul să fie
afişat doar o singură dată, se poate folosi a doua variantă ilustrată în
scriptul 7.6.php.
Scriptul 7.6
<?php
$x=$_POST['x'];
$y=$_POST['y'];
echo "Suma numerelor x=$x si y=$y este=". ($x+$y);
} else {
print '<html>
<head>
<title>7.6.php</title>
</head>
<body>
<h3>
Calculeaza suma a doua numere
136

</h3>
<form action="7.6.php" method ="POST" >
<br>x:<input type="text" name="x" size="8">
<br>y:<input type="text" name="y" size="8">
<br><input type="submit" name="trimite" value
="Trimite datele de intrare" >
</form>
</body>
</html>';
}
?>
137
P H P
Capitolul 8
8. Elemente de bază în
crearea formularelor
În secţiunile anterioare am folosit pentru exemplificarea schemei
transmiterii datelor către scriptul PHP, un exemplu simplu de formular,
insistând mai degrabă asupra înţelegerii acestei scheme decât asupra
varietăţii de prezentare a datelor prin astfel de formulare.
Deoarece formularele constituie modalitatea curentă de transmitere a
datelor către scripturi, în cele ce urmează ne propunem, să prezentăm
variantele cele mai frecvent folosite.
Toate elementele unui formular sunt cuprinse între etichetele
<form> și </form>. Eticheta <form> suportă mai multe atribute, cele
mai importante fiind action şi method. Plasarea lor în cadrul etichetei
form se face conform sintaxei:
<form action="actiune" method="metoda">
unde:
ü actiune specifică scriptul de prelucrare al formularului;
ü metoda specifică metoda HTTP folosită pentru transmiterea datelor
din formular.
De exemplu, construcţia de mai jos,
<form action="compara.php" method ="POST">
139
Programarea în PHP
indică faptul că datele se transmit pentru prelucrare către scriptul

compara.php folosind metoda POST.
O să prezentăm pe scurt sintaxa a trei dintre etichetele cele mai
folosite în plasarea pe ecran a elementelor unui formular, împreună cu
exemplele corespunzătoare. Acestea etichete sunt: input, textarea,
select.
8.1. Eticheta input
Eticheta input are următoarea sintaxă:

<input type="tip" name="nume" value="valoare"
size="marime" maxlenght="lungime_maxima">
unde:
ü tip poate fi text, password, hidden, radio, checkbox,
submit, reset, button, file, image;
ü nume se referă la numele casetei de text care se creează;
ü valoare reprezintă valoarea iniţială a elementului cu numele nume;
ü marime este lăţimea casetei; doar un număr de caractere egal cu
lăţimea casetei este vizibil la un moment dat;
ü lungime_maxima reprezintă numărul maxim de caractere care pot
fi tastate în casetă.
Ilustrăm în continuare modul de funcţionare al etichetei input prin

câteva exemple.
Exemplu. Casetă text
x=<input type="text" name="x" value="5" size="4">
Efect: creează pe ecran o casetă de lungime 4 caractere cu numele

logic x şi valoarea iniţială 5. Textul x= este numele descriptiv al casetei şi
va apare pe ecran în faţa casetei, ca în imaginea următoare (Figura 8.1):
140
Capitolul 8. Elemente de bază în crearea formularelor
Figura 8.1. Casetă text
Observaţie. Numele logic se referă la valoarea datelor din casetă şi

poate fi folosit în scripturile PHP spre care s-au transmis datele, sub forma
$_POST['x'] sau $_GET['x']. Numele descriptiv al casetei oferă
informaţii despre semnificaţia datelor din casetă.
Exemplu. Casetă pentru parolă
Parola:<input type="password" name="parola" size="15">
Efect: creează pe ecran o casetă cu numele descriptiv Parola și

numele logic parola, lungimea casetei fiind de 15 caractere. Pentru a
asigura confidenţialitatea, caracterele care alcătuiesc parola nu vor apărea
în casetă când acestea se tastează. În locul fiecărui caracter apare de regulă
o steluţă (Figura 8.2)
Figura 8.2. Casetă pentru parolă
141
Programarea în PHP
Exemplu. Câmp ascuns
<input type="hidden" name="nota" value="8">
Efect: generează un câmp ascuns cu numele nota. Caracterul ascuns

al câmpului constă în faptul că valoarea sa nu apare în pagina web a
formularului.
Exemplu. Butoane radio
<input type="radio" name="disciplina"

value="Matematica">Matematica<br>
value="Informatica" checked>Informatica<br>
value="Fizica">Fizica<br>
Efect: creează trei butoane radio unele sub altele (Figura 8.3).
Butoanele sunt plasate pe rânduri diferite datorită etichetei <br>. Se
observă că toate au acelaşi nume logic (name) şi anume, disciplina. La
un moment dat poate fi selectat doar unul dintre butoane. Adăugarea
atributului checked a condus la preselecţia butonului Informatica.
Figura 8.3. Butoane radio
142
Exemplu. Casete de validare
<input type="checkbox" name="Prahova" value="Ploiesti"

checked>Ploiesti<br>
<input type="checkbox" name="Dambovita"
value="Targoviste">Targoviste<br>
<input type="checkbox" name="Gorj" value="Targu
Jiu"checked>Targu Jiu<br>
Efect: creează trei casete de validare aşezate unele sub altele (Figura
8.4). În cazul casetelor de validare, numele logic name poate avea valori
diferite și este posibilă selectarea mai multor butoane simultan. Dacă se
adaugă şi opţiunea checked, butonul respectiv poate fi preselectat.
În cazul de faţă sunt preselectate butoanele Ploiesti şi Targu
Jiu.
Figura 8.4. Casete de validare
Exemplu. Buton de trimitere a formularului
<input type="submit" value="Trimite formular">
Efect: creează un buton de trimitere a formularului (Figura 8.5). În

cazul de faţă textul care apare scris pe buton este Trimite formular.
Trimiterea formularului către scriptul PHP menţionat în atributul action
al etichetei form se face executând click pe acest buton. Forma butonului
diferă de la un browser web la altul.
143
Programarea în PHP
Figura 8.5. Buton pentru trimiterea datelor către scriptul de prelucrare
Exemplu. Buton de resetare a datelor tastate în formular
<input type="reset" value="Reset formular">
Efect: creează un buton care permite anularea datelor tastate în

formular şi revenirea la starea iniţială; după ce s-a executat click pe acest
buton, dacă formularul e cu memorie, în câmpurile de completare reapar
valorile implicite, iar în caz contrar, spaţii albe. Un exemplu de buton
Reset se poate vedea în mai jos (Figura 8.6).
Figura 8.6. Buton pentru resetarea datelor dintr-un formular
Exemplu. Casete pentru încărcarea unui fișier pe server
<input type="file" name="nume_atasat_fisier"

value="adresa_URL _fisier" enctype =
"multipart/form_data">
144
unde:
ü nume_atasat_fisier reprezintă numele cu care va fi încărcat
fişierul pe server;
ü adresa_URL _fisier reprezintă adresa URL a fişierului care se
încarcă pe server;
ü multipart/form_data este metoda de criptare a datelor din
fişier.
Efect: permite selectarea unui fişier de pe calculatorul utilizatorului
şi încărcarea (uploadarea) lui pe server, după ce a fost apăsat butonul de
trimitere.
Observaţie. Adresa URL a fişierului care va fi expediat către server

poate fi obţinută în trei moduri: prin precizarea sa în atributul value, prin
tastarea sa în caseta de editare care însoţeşte butonul Browse (Figura 8.7)
sau prin selectarea fişierului cu ajutorul butonului Browse.
Figura 8.7. Buton Browse pentru selectarea fişierului

în vederea încărcării pe server
8.2. Eticheta textarea
Casetele cu text, create cu ajutorul etichetei input şi a atributului

text limitează lungimea textului introdus. Spre deosebire de acestea,
eticheta textarea oferă utilizatorului posibilitatea de a transmite texte
oricât de lungi (de exemplu comentarii, sugestii etc.).
Sintaxa etichetei textarea este următoarea:
<textarea nume="nume" rows="linii" cols="coloane"
wrap="aranjare">
145
Programarea în PHP
unde:
ü nume este numele zonei de text;
ü linii reprezintă numărul de rânduri de text vizibile;
ü coloane reprezintă numărul de coloane care înmulţite cu lăţimea
medie a unui caracter furnizează lăţimea vizibilă a textului;
ü aranjare este un parametru care specifică formatul afişării.
Eticheta <textarea> trebuie urmată întotdeauna de eticheta de

închidere </textarea>.
Exemplu
<b> Comentarii </b> <br>
<textarea name ="Comentarii" rows="5"
cols="30"></textarea>
Efect: În urma procesării secvenţei de cod de mai sus se creează

următoarea zonă de text sau câmp de editare multilinie (Figura 8.8).
Figura 8.8. Câmp de editare creat cu ajutorul etichetei textarea
8.3. Eticheta select
Eticheta select permite crearea unui meniu derulant (listă de

selecţie) cu mai multe opţiuni care pot fi selectate de către utilizatori.
Sintaxa etichetei select este următoarea:
146
<select name="nume" size="nr_linii_lista" multiple

selected>
unde:
ü nume este numele selecţiei;
ü nr_linii_lista reprezintă numărul de linii din listă care se văd
simultan;
ü multiple este un atribut care permite selectări multiple; dacă
lipseşte se poate selecta o singură opţiune;
ü selected este un atribut care permite selectarea unei opţiuni ca
valoare iniţială; în cazul în care atributul selected nu este prezent,
este selectată implicit ca valoare iniţială prima opţiune din listă.
Eticheta <select> se încheie cu eticheta de închidere </select>.

Între etichetele <select> şi </select> trebuie introdusă lista de opţiuni
ale cărei elemente sunt de forma:
<option value="optiune_i">Text optiune_i</option>
unde:
ü optiune_i este valoarea care se va transmite scriptului PHP, dacă
se va selecta Text optiune_i;
ü Text optiune_i este numele care va apare în meniul derulant
generat.
Exemplu
Selecteaza o culoare<br>
<select name = "culoare" size = "3" multiple>
<option value = "Rosu"> Rosu </option>
<option value = "Galben"> Galben </option>
<option value = "Albastru"> Albastru </option>
<option value = "Verde"> Verde </option>
<option value = "Alb"> Alb </option>
</select>
Efect: se creează meniul derulant ( Figura 8.9) care permite să se

vadă la un moment dat trei elemente din listă (atributul size este egal cu
3) şi permite selectarea mai multor opţiuni simultan (atributul multiple).
147
Programarea în PHP
Figura 8.9. Meniu derulant obţinut cu ajutorul etichetei select
148
P H P
Capitolul 9
9. Funcţii
O funcţie este o porţiune de cod, organizată sub un nume, care poate
fi apelată şi executată ori de câte ori este nevoie. Funcţiile permit crearea
unor programe clare şi elegante.
Funcţiile pot fi predefinite şi definite de utilizator. Funcţiile
predefinite pot fi apelate şi utilizate în orice script. Utilizarea unei funcţii
presupune cunoştinţe minimale: ce face funcţia, cum se apelează, cum
avem acces la rezultatele returnate (întoarse) de ea. Felul în care funcţia
este proiectată pentru a-şi îndeplini sarcinile nu prezintă, de obicei, interes
pentru utilizator. Limbajul PHP are implementate câteva sute de funcţii
predefinite, deosebit de utile în uşurarea muncii de programare. Iată câteva
exemple: abs() pentru calculul valorii absolute a unui număr real,
count() şi sizeof() pentru aflarea numărului de elemente ale unui
vector, strcmp()pentru compararea lexicografică a două şiruri etc.
Limbajul PHP oferă posibilitatea programatorului să-şi creeze
propriile funcţii, numite funcţii utilizator.
Sintaxa unei funcţii PHP este următoarea:
function nume_functie(lista_de_argumente_formale){
//corpul functiei
}
149
Programarea în PHP
unde:
ü nume_functie este numele funcţiei pe care dorim să o definim;
ü lista_de_argumente_formale conţine variabilele care vor
prelua valori pentru a fi prelucrate sau adrese de variabile;
ü corpul functiei reprezintă codul funcţiei.
Observaţii
ü Identificatorul nume_functie se formează după regulile de
formare a numelor de variabilă. Spre deosebire de acestea, nu
necesită însă semnul dolar ca prefix şi nu depind de capitalizare. De
exemplu, afisare() şi Afisare() desemnează aceeaşi funcţie.
ü Este posibil ca lista de argumente să fie vidă. Chiar şi în aceste
condiţii parantezele trebuie să fie prezente: se va scrie Afisare() şi
nu Afisare.
Apelul unei funcţii se face sub forma:
nume_functie(lista_de_argumente_efective);
unde lista_de_argumente_efective reprezintă valori sau expresii
ale căror valori vor fi transmise funcţiei.
În urma apelului, funcţia poate să returneze sau nu o valoare.
Un exemplu simplu de funcţie care nu întoarce o valoare este
prezentat în scriptul 9.1.php:
Scriptul 9.1
<html>
<head>
</head>
<body>
<?php
function MesajEroare() {
echo "Eroare!";
}
MesajEroare();
?>
</body>
</html>
Execuţia scriptului 9.1.php are ca fefect afişarea în browser a mesajului

Eroare!. În acest caz numelui funcţiei nu i se atribuie nici o valoare.
150
Capitolul 9. Funcţii
Atribuirea unei valori numelui funcţiei se poate face cu ajutorul

instrucţiunii return. Sintaxa instrucţiunii return este următoarea:
return expresie;
În urma execuţiei instrucţiunii return, numelui funcţiei i se va atribui
valoarea rezultată prin evaluarea expresiei expresie. În scriptul 9.2.php, ,
funcţia MesajEroare() este modificată astfel încât să întoarcă o valoare.
Scriptul 9.2
<html>
<head>
</head>
<body>
<?php
function MesajEroare() {
return "Eroare!";
}
echo MesajEroare();
?>
</body>
</html>
Deosebit de utile sunt funcţiile pentru care lista de argumente nu este

vidă. În exemplul de mai jos (scriptul 9.3.php), funcţia Anotimp()
returnează una din valorile, "Iarna!", "Primavara!", Vara!",
"Toamna!", în funcţie de valorile argumentului $luna. Valoarea
argumentului $luna este obţinută cu ajutorul funcţiei predefinite date(),
care aplicată argumentului "n" întoarce valoarea curentă a lunii (una din
valorile 1,2,3,....,12).
Scriptul 9.3
<html>
<head>
</head>
<body>
<?php
function Anotimp($luna) {
switch ($luna) {
case 12: ;
case 1: ;
151
Programarea în PHP

case 2: return "Iarna!";break;
case 3: ;
case 4: ;
case 5: return "Primavara!";break;
case 6: ;
case 7: ;
case 8: return "Vara!";break;
case 9: ;
case 10: ;
case 11: return "Toamna!";break;
}
}
$luna=date("n");
echo Anotimp($luna);
?>
</body>
</html>
De asemenea, o funcţie poate să returneze valori multiple. Pentru

exemplificare, considerăm scriptul 9.4.php, în care sunt returnate
elementele unui vector.
Scriptul 9.4
<html>
<head>
</head>
<body>
<?php
function LuniAnotimp($Anotimp){
switch($Anotimp) {
case "Primavara" :
return array("Martie","Aprilie", "Mai");
break;
case "Vara" :
return array("Iunie","Iulie", "August");
break;
case "Toamna" :
return array("Septembrie","Octombrie",
"Noiembrie"); break;
case "Iarna" :
return array("Decembrie","Ianuarie",
"Februarie");
}
}
152

$Anotimp="Iarna";
list($Prima, $Adoua, $Atreia)=LuniAnotimp($Anotimp);
print "Lunile anotimpului $Anotimp sunt: $Prima, $Adoua,
$Atreia ";
?>
</body>
</html>
Până acum am tratat numai funcţii care au cel mult un parametru. În

cazul existenţei mai multor parametri, corespondenţa dintre parametrii
formali şi cei efectivi se face de la stânga la dreapta. În mod normal,
transferul valorilor efective se face prin valoare, adică valorile parametrilor
efectivi sunt copiate în parametrii formali corespunzători. În exemplul de
mai jos (vezi scriptul 9.5.php) se transferă valoarea notelor luate la o
disciplină de către un student, către funcţia SituatieStudent(). Funcţia
întoarce valoarea "Admis!" dacă media notelor este mai mare sau egală cu
valoarea memorată în variabila $Prag sau "Respins!" dacă media
notelor este strict mai mică decât valoarea memorată în variabila $Prag.
Scriptul 9.5
<html>
<head>
</head>
<body>
<?php
function SituatieStudent($Anl,$Alg,$Mec,$Prag){
$media=($Anl+$Alg+$Mec)/3;
return ($media>=$Prag)?"Admis!":"Respins!";
}
$Anl=6;$Alg=9;$Mec=5;
$Prag=7;
echo "Situatie
student:".SituatieStudent($Anl,$Alg,$Mec,$Prag);
?>
</body>
</html>
Practic, la apelul funcţiei SituatieStudent(), valorile

variabilelor $Anl, $Alg, $Mec, numite şi parametrii efectivi, se copiază
153
Programarea în PHP
în valorile parametrilor formali cu aceleași nume, adică în $Anl, $Alg

şi respectiv $Mec.
Dacă este nevoie, anumiţi parametrii formali ai funcţiei pot avea
valori implicite. Deoarece la apelul funcţiei atribuirea valorilor către
parametrii formali ai funcţiei se face de la stânga la dreapta, valorile
implicite trebuie să fie plasate totdeauna în coada acestei liste. De
asemenea, valoarea implicită trebuie să fie o constantă. Pentru
exemplificare, rescriem exemplul de mai sus şi considerăm drept valoare
implicită, pentru variabila $Prag, valoarea 5(vezi scriptul 9.6.php).
Scriptul 9.6
<html>
<head>
</head>
<body>
<?php
function SituatieStudent($Anl,$Alg,$Mec,$Prag=5){
$media=($Anl+$Alg+$Mec)/3;
return ($media>=$Prag)?"Admis!":"Respins!";
}
$Anl=6;$Alg=9;$Mec=5;
echo "Situatie student pentru pragul de admitere egal cu
5:".SituatieStudent($Anl,$Alg,$Mec);
$Prag=7;
echo "<br>Situatie student pentru pragul de admitere egal
cu 7:".SituatieStudent($Anl,$Alg,$Mec,$Prag);
?>
</body>
</html>
După prima apelare a funcţiei SituatieStudent(), scriptul

9.6.php va afişa valoarea Admis!, iar după a doua apelare se va afişa
valoarea Respins!. În prima situaţie, parametrul $Prag lipseşte din lista
argumentelor efective, iar în prelucrările din corpul funcţiei se consideră
valoarea sa implicită, adică 5. Media notelor fiind (6+9+5)/3=6.33 şi
pragul $Prag=5 rezultatul evaluării 6.33>5 va fi True şi se va returna
valoarea Admis!. În cea de-a doua situaţie, valoarea pragului de admitere
va fi $Prag=7, rezultatul evaluării 6.33>7 va fi False şi în consecinţă se
va returna "Respins!".
154
9.1. Variabile locale
Atât parametrii funcţiilor cât şi variabilele din corpul unei funcţii

sunt entităţi cu caracter local. Ele sunt create la apelul funcţiilor şi dispar
când execuţia funcţiei se termină. Din acest motiv, valoarea unei variabile
create în exteriorul unei funcţii nu e disponibilă în interiorul funcţiei şi
invers. Un avantaj al caracterului implicit local al variabilelor create într-o
funcţie constă în faptul că putem folosi aceleași nume de variabile atât în
script cât şi în oricare altă funcţie a scriptului. Deşi au aceleaşi nume, astfel
de variabile se referă la locaţii diferite de memorie. Drept exemplu,
considerăm scriptul 9.7.php, prezentat mai jos:
Scriptul 9.7
<html>
<head>
</head>
<body>
<?php
$x=32;
echo "In script x=$x<br>";
function Mesaj1() {
$x=100;
echo "In functia Mesaj1(), x=$x<br>";
}
function Mesaj2(){
echo "\nIn functia Mesaj2(), x=$x<br>";
}
Mesaj1();
Mesaj2();
?>
</body>
</html>

In script x=32
In functia Mesaj1(), x=100
In functia Mesaj2(), x=
155
Programarea în PHP
În primul rând se observă că în funcţia Mesaj2() nu se va afişa nici

o valoare, deoarece variabila $x nu a fost definită. În al doilea rând se vede
clar că variabila $x din script are o valoare diferită de valoarea variabilei
$x din funcţia Mesaj1().
9.2. Variabile globale
Totuşi, sunt situaţii când se doreşte ca variabila definită într-o funcţie

să aibă caracter global, adică să fie „văzută” şi în afara funcţiei unde este
definită. Acest lucru este posibil dacă variabila respectivă este declarată sub
forma:
global nume_variabilă;
Următorul script, scriptul 9.8.php, se deosebeşte de precedentul doar
prin faptul că în funcţia Mesaj2() variabila $x a fost declarată global.
Scriptul 9.8
<html>
<head>
</head>
<body>
<?php
$x=32;
echo "In script x=$x<br>";
function Mesaj1(){
$x=100;
}
function Mesaj2() {
global $x;
}
Mesaj1();
Mesaj2();
?>
</body>
</html>
156

In script x=32
Rezultatele obţinute arată că în timp ce variabila $x din funcţia

Mesaj1() şi-a păstrat caracterul local ($x=100), variabila $x din funcţia
Mesaj2() are un caracter global. Practic, datorită declaraţiei
global $x;
variabila $x din funcţia Mesaj2() este aceeași cu variabila $x din script,
fapt ce explică rezultatul afișat, adică:
9.3. Variabile statice
Să presupunem că dorim să elaborăm un script care să afişeze

următorul rezultat:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
De asemenea, dorim ca afişarea unui rând să fie realizată cu ajutorul

unei funcţii numită afisare_rand().
O variantă de rezolvare constă în utilizarea unei variabile globale $i,
în care să se genereze numărul de cifre necesar fiecărui rând. Caracterul
global al acestei variabile permite ca valorile ei să fie accesibile atât în
corpul funcţiei funcţiei afisare_rand(), cât şi în afara ei. Scriptul
9.9.php implementează această variantă.
Scriptul 9.9
<html>
<head>
<body>
<?php
function afisare_rand() {
157
Programarea în PHP

global $i;
echo "<br>";
for ($j=1; $j<=$i; $j++) {
echo "$j ";
}
}
echo "<br>";
for ($i=1; $i<=5; $i++) {
afisare_rand();
}
?>
</body>
</html>
Se observă că folosirea variabile globale $i face ca funcţia să fie

dependentă de aceasta: orice reutilizare a ei în alt cod trebuie să fie însoţită
şi de variabila $i. Pentru a înlătura acest neajuns vom prezenta în
continuare o variantă în care variabila $i va fi declarată static.
Declaraţia statică a unei variabile se face conform sintaxei:
static lista de variabile;
Pe linia de declaraţie, se poate iniţializa o variabilă, ca în exemplul
static $i=1;
Iniţializarea unei variabile statice în cadrul unei funcţii se face o

singură dată, şi anume la primul apel al funcţiei. Deşi îşi păstrează
caracterul local, totuşi, spre deosebire de variabilele locale care-şi pierd
valorile de la un apel la altul al funcţiei, variabilele declarate static au
proprietatea de a le păstra. Aceste proprietăţi ale variabilelor statice permit
construirea unor funcţii „cu memorie”, care au statutul de cod independent.
Această variantă este implementată cu ajutorul scriptului 9.10.php
Scriptul 9.10
<html>
<head>
</head>
158

<body>
<?php
function afisare_rand() {
static $i=1;
echo "<br>";
for ($j=1; $j<=$i; $j++){
echo "$j ";
}
$i++;
}
for ($k=1; $k<=5; $k++) {
afisare_rand();
}
?>
</body>
</html>
9.4. Transfer prin valoare, transfer

prin referinţă
Există două modalităţi de a transfera valori către funcţie prin

intermediul parametrilor: prin valoare şi prin referinţă. Transferul prin
valoare este implicit. Toate exemplele prezentate până acum au folosit
metoda de transfer prin valoare.
În cazul metodei de transfer prin valoare, la apelul funcţiei,
valorile efective sunt copiate în parametrii formali, corespunzători ai
funcţiei. Drept urmare, operaţiile realizate asupra parametrilor formali nu
afectează valorile parametrilor efectivi. Metoda previne, astfel, alterarea
accidentală a valorilor efective, prin operaţii făcute în diverse funcţii ale
scriptului.
Pentru exemplificare, să considerăm exemplul de mai jos, în care
încercăm să comutăm valorile a şi b, transmise prin formular, folosind o
funcţie de comutare numită comut().
159
Programarea în PHP
Scriptul 9.11
<html>
<head>
</head>
<body>
<?php
if (isset($_POST['trimite'])){
function comut($x,$y) {
$z=$x;
$x=$y;
$y=$z;
}
$a=$_POST['a'];
$b=$_POST['b'];
comut($a,$b);
echo "valorile comutate sunt:a=$a, b=$b ";
}
?>
<html>
="POST" >
<br> a=<input type="text" name="a" value =3 size="3">
<br> b=<input type="text" name="b" value =5 size="3">
<br> <input type="submit" name="trimite" value ="Trimite
datele de intrare">
</form>
</html>
Tastând la intrare valorile a=3 şi b=5, rezultatul afişat în browser, în

urma execuţiei scriptului 9.11.php va fi neschimbat, adică a=3 şi b=5.
Modul de lucru este următorul. La apelul comut($a,$b); valoarea
3 memorată în $a va fi copiată în $x, iar valoarea 5 memorată în $b va fi
copiată în $y. Se execută secvenţa
$z=$x; $x=$y; $y=$z;
care realizează comutarea valorilor din $x şi $y, după care se revine în
script şi se afişează valorile a=3 şi b=5. În Figura 9.1 este ilustrat
algoritmul descris.
160
Script Comut1()
$a = 3 $x = 3 5
$b = 5 $y = 5 3
Figura 9.1. Transfer prin valoare
Se observă foarte clar că operaţiile de comutare din funcţia comut()

se execută asupra copiilor $x şi $y ale variabilelor $a, respectiv $b.
Valorile din $x şi $y sunt comutate, în timp ce valorile din $a şi $b rămân
neschimbate.
În cazul transferului prin referinţă, în parametrul formal se
memorează adresa parametrului efectiv şi nu o copie a valorii acestuia. În
consecinţă, operaţiile din funcţie se vor efectua asupra parametrilor efectivi
înşişi şi nu asupra copiilor lor, ca în cazul transferului prin valoare. Pentru a
ilustra modul în care se realizează transferul prin referinţă vom modifica
antetul funcţiei comut() din
function comut($x,$y) în function comut(&$x,&$y).
Se observă că schimbarea constă în a precede parametrii formali $x
și $y cu operatorul &, consecinţa fiind că la apelarea funcţiei comut(), $x
se va referi la conţinutul variabilei $a, iar $y la conţinutul variabilei $b.
Din acest motiv, operaţiile de comutare asupra lui $x şi $y se aplică, de
fapt, asupra variabilelor $a şi $b. Cu alte cuvinte, comutarea variabilelor
$x şi $y înseamnă şi comutarea variabilelor $a şi $b, iar rezultatele afişate
în browser vor fi $a=5 şi $b=3. Situaţia zonelor de memorie implicate este
ilustrată în figura 9.2.
Script Comut2()
5
$a → 3 ← $x
$b → 5 ← $y
3
Figura 9.2. Transfer prin referinţă
161
P H P
Capitolul 10
10. Clase şi obiecte

În acest capitol ne propunem să trecem în revistă câteva concepte de
bază ale Programării Orientate pe Obiecte, ilustrând prin exemple modul în
care sunt implementate în limbajul PHP.
10.1. Clasa ca un container
Să presupunem că dorim să construim un script care calculează

mediile aritmetice şi geometrice a două note: nota de la disciplina
Matematică ($NotaMat) şi nota de la disciplina Informatică
($NotaInf). O posibilă implementare este scriptul 10.1.php, prezentat
mai jos:
Scriptul 10.1
<html>
<head>
</head>
<body>
<?php
function SetNote($x,$y) {
global $NotaInf, $NotaMat;
$NotaMat=$x;
163
Programarea în PHP

$NotaInf=$y;
}
function AfisNote() {
global $NotaInf, $NotaMat ;
return "Nota la Matematica
este:".$NotaMat."<br>"."Nota la Informatica
este:".$NotaInf;
}
function MediaArit() {
return ($NotaInf+$NotaMat)/2;
}
function MesajMedieArit() {
return "<br>Media aritmetica este:";
}
function MediaGeom() {
return sqrt($NotaInf*$NotaMat);
}
function MesajMedieGeom() {
return "<br>Media geometrica este:" ;
}
$x=3;
$y=7;
SetNote($x,$y);
echo AfisNote();
echo MesajMedieArit().MediaArit();
echo MesajMedieGeom().MediaGeom();
?>
</body>
</html>
Dacă urmărim cu atenţie funcţiile din program, constatăm că, pentru

a-i mări lizibilitatea am putea grupa funcţiile în trei clase:
ü clasa Setari care să conţină funcţiile SetNote() şi AfisNote();
ü clasa MediaAritmetica care să conţină funcţiile MediaArit() şi
MesajMedieArit();
164
Capitolul 10. Clase şi obiecte
ü clasa MediaGeometrica care să conţină funcţiile MediaGeom() şi

MesajMedieGeom().
Limbajul PHP permite definirea unor astfel de clase în care pot fi

depuse ca într-un container variabile şi funcţii. Sintaxa unei clase se
defineşte astfel:
class nume_clasa {
var nume_variabila_1;
var nume_variabila_2;
……………………….
var nume_variabila_n;
definitie-functie_1;
definitie-functie_2;
………………………..
definitie-functie_m;
}
unde:
ü class şi var sunt cuvinte cheie;
ü nume_clasa este numele clasei; aceasta poate fi orice identificator
acceptat în PHP, cu excepţia cuvântului rezervat stdtclass;
ü nume_variabila_i,i=1,2,…,n şi definitie-functie_i,
i=1,2,…,m sunt nume de variabile şi respectiv definiţii de funcţii
PHP. O clasă poate conţine numai nume de variabile, numai nume de
funcţii sau atât nume de variabile cât şi definiţii de funcţii.
Variabilele dintr-o clasă se mai numesc şi proprietăţi, iar funcţiile

se mai numesc şi metode. Variabilele dintr-o clasă pot conţine valori
scalare, vectori sau obiecte.
Ştiind acum sintaxa unei clase, programul de mai sus poate fi
reorganizat utilizând clasele, ca în scriptul 10.2.php.
Scriptul 10.2
<html>
<head>
</head>
<body
<?php
165
Programarea în PHP

class Setari {
$NotaMat=$x;
$NotaInf=$y;
}
function AfisNote() {
global $NotaInf, $NotaMat ;
return "Nota la Matematica
este:".$NotaMat."<br>"."Nota la Informatica
este:".$NotaInf;
}
}
class MediaAritmetica {
function Media() {
return ($NotaInf+$NotaMat)/2;
}
function MesajMedie() {
return "<br>Media aritmetica a notelor
este:";
}
}
class MediaGeometrica {
function Media() {
return sqrt($NotaInf*$NotaMat);
}
function MesajMedie() {
return "<br>Media geometrica a notelor
este:" ;
}
}
$x=3;
$y=7;
Setari::SetNote($x,$y);
echo Setari::AfisNote();
echo MediaAritmetica::MesajMedie();
echo MediaAritmetica::Media();
echo MediaGeometrica::MesajMedie();
echo MediaGeometrica::Media();
?>
</body>
</html>
166
Observaţii
ü Fiecare clasă defineşte un domeniu propriu de vizibilitate. Acest
lucru permite ca variabilele sau funcţiile aflate în clase diferite să
poată avea aceleaşi nume. De exemplu, în programul de mai sus,
funcţiile MediaArit() şi MediaGeom() sunt numite acum
Media(), iar funcţiile MesajMedieArit() şi
MesajMedieGeom() sunt redenumite MesajMedie().Se
observă că funcţiile din două clase diferite (clasele
MediaAritmetică şi MediaGeometrică) pot avea aceleaşi
nume. Din acest motiv, clasele pot fi proiectate separat fără teama de
a apare conflicte de nume.
ü Referirea la variabilele sau funcţiile unei clase din afara acesteia se
face cu ajutorul operatorului de rezoluţie (sau a operatorului scope)
:: sub forma:
nume_clasa::nume_functie
sau
nume_clasa::nume_variabila
De exemplu, în programul de mai sus, funcţia SetNote() este
apelată sub forma Setari::SetNote();
Funcţiile organizate sub forma unor clase, ca în scriptul 10.2.php se

numesc funcţii clasă. Ele pot fi accesate cu ajutorul operatorului de
rezoluţie :: şi pot folosi variabile globale sau locale. Folosirea operatorului
de rezoluţie :: pentru a accesa variabilele declarate în interiorul unei clase
nu este însă posibilă. Cu alte cuvinte, nu există noţiunea de variabilă clasă
în sensul în care există noţiunea de funcţie clasă. Scriptul 10.3.php,
prezentat mai jos, va produce eroare, deoarece se încearcă accesarea
variabilelor $NotaInf şi $NotaMat folosind operatorul :: .
Scriptul 10.3
<html>
<head>
</head>
<body>
<?php
class Student {
167
Programarea în PHP

var $NotaInf=7;
var $NotaMat=9;
}
echo "NotaInf=".$Student::$NotaInf;
echo "NotaMat=".$Student::$NotaMat;
echo "Media=".($Student::$NotaInf+$Student::NotaMat)/2;
?>
</body>
</html>
10.2. Clasa ca un tip de date
Până acum, clasele au fost folosite doar pentru a organiza mai bine
funcţiile unui program. Adevărata putere a noţiunii de clasă apare însă în
momentul în care clasa este folosită ca un tip de date. În această viziune,
obiectul se defineşte ca o instanţă a unei clase, sau mai simplu, ca o
variabilă al cărei tip este o clasă.
Scriptul 10.4.php, prezentat în continuare, conţine clasa Student cu
proprietăţile $NotaInf şi $NotaMat. Definirea obiectului $Student1 ca
instanţă a acestei clase se face cu ajutorul operatorului new, conform
sintaxei:
$variabila_obiect=new nume_clasa();
Proprietăţile $NotaInf şi $NotaMat din clasa Student sunt
iniţializate cu două constante, 7 respectiv 8. În general o proprietate a unei
clase poate fi iniţializată cu o constantă folosind sintaxa:
var nume_proprietate=constanta;
Constanta poate fi un scalar, un vector sau un obiect.
Scriptul 10.4
<html>
<head>
</head>
<body>
<?php
class Student {
var $NotaInf=7;
168

var $NotaMat=8;
function Mesaj() {
return "Media aritmetica = ";
}
}
$Student1=new Student();
echo "<br>NotaInf=".$Student1->NotaInf;
echo "<br>NotaMat=".$Student1->NotaMat;
$MediaArit=($Student1->NotaInf+$Student1->NotaMat)/2;
echo "<br>".$Student1->Mesaj() . $MediaArit;
?>
</body>
</html>
Rezultatul executiei scriptului 10.4.php este:

NotaInf=7
NotaMat=8
Media aritmetica = 7.5
10.3. Accesul la proprietăţile şi

metodele unei clase
După cum se poate observa, în scriptul 10.4.php am accesat

proprietăţile $NotaInf şi $NotaMat, precum şi metoda Mesaj() din
afara clasei Student. Accesul la proprietăţile şi metodele unei clase se
poate face atât din afara cât şi din interiorul clasei. În cele ce urmează vom
discuta câteva chestiuni practice legate de accesul la proprietăţile şi
metodele unei clase.
10.3.1. Accesul din afara clasei
Odată definit obiectul, accesul din afara clasei la proprietăţile şi

metodele acesteia se face cu ajutorul operatorului săgeată → , folosind
sintaxa:
nume_obiect → nume_proprietate
şi respectiv
169
Programarea în PHP
nume_obiect → nume_metoda.
Această facilitate permite în particular şi modificarea proprietăţilor

unui obiect. Astfel, dacă dorim ca notele obiectului $Student1 să fie 10,
respectiv 9, imediat după generarea obiectului şi înainte de afişare se pot
insera instrucţiunile:
$Student1 → Nota1 = 9;
$Student2 → Nota2 = 10;
Programul 10.5.php obţinut astfel prin modificarea scriptului

10.4.php va afişa de data aceasta media notelor ca fiind egală cu 9.5.
Scriptul 10.5
<html>
<head>
<body>
<?php
class Student {
var $NotaInf=7;
var $NotaMat=8;
function Mesaj() {
return "Media aritmetica = ";
}
}
$Student1->NotaInf=9;
$Student1->NotaMat=10;
echo "<br>NotaInf=".$Student1->NotaInf;
echo "<br>NotaMat=".$Student1->NotaMat;
$MediaArit=($Student1->NotaInf+$Student1->NotaMat)/2;
echo "<br>".$Student1->Mesaj() . $MediaArit;
?>
</body>
</html>
Rezultatul executiei scriptului 10.5.php este:

NotaInf=9
NotaMat=10
Media aritmetica = 9.5
170
10.3.2. Accesul din interiorul clasei.

Pseudo variabila this
O clasă poate fi privită ca un şablon, ca un model pe baza căruia se

construiesc obiectele şi ca urmare nu se referă la un obiect (o instanţă)
anume. Practic, în interiorul clasei nu ştim care va fi numele concret al
obiectului, pentru a folosi una din schemele de acces nume_obiect →
nume_proprietate sau nume_obiect → nume_metoda folosite în
exteriorul clasei. Soluţia găsită pentru accesul la o proprietate sau la o
metodă din interiorul clasei constă în folosirea variabilei speciale this în
conjuncţie cu operatorul →. Astfel, this → nume_proprietate sau
this→nume_metoda se referă la proprietatea, respectiv la metoda
instanţei curente a clasei. De exemplu, în scriptul 10.6.php prezentat mai
jos, $this->NotaInf ia valoarea 7 când metoda Media() e accesată sub
forma $Student1->Media() şi valoarea 10 când e accesată sub forma
$Student2->Media(). De asemenea, scriptul 10.6.php este un exemplu
de prelucrare a informaţiilor memorate în proprietăţile unui obiect, de către
metodele sale.
Scriptul 10.6
<html>
<head>
<body>
<?php
class Student {
var $NotaInf;
var $NotaMat;
function Media() {
return ($this->NotaInf+$this->NotaMat)/2;
}
}
echo "<br>Media=".$Student1->Media();
171
Programarea în PHP

?>
</body>
</html>
În particular, metodele unui obiect permit inclusiv modificarea

valorilor memorate în proprietăţi, aşa cum se poate constata din execuţia
scriptului 10.7.php.
Scriptul 10.7
<html>
<head>
</head>
<body>
<?php
class Student {
var $NotaInf=7;
var $NotaMat=8;
function Media(){
}
$this->NotaMat=$x;
$this->NotaInf=$y;
}
}
$x=9; $y=10;
$Student1->SetNote($x,$y);
?>
</body>
</html>
Rezultatul execuţiei scriptului 10.7 este:

Media=7.5
Media=9.5
După apelarea funcţiei SetNote() variabilele $NotaInf şi
$NotaMat primesc valorile 9, respectiv 10, astfel încât, la a doua apelare,
funcţia Media() va furniza ca rezultat valoarea 9.5.
172
10.3.3. Constructori
Un constructor este o metodă care are acelaşi nume cu clasa din care
face parte. Constructorul este apelat automat la fiecare generare a unui
obiect. Această particularitate a sa permite folosirea constructorilor ca
mijloace elegante de iniţializare a proprietăţilor unui obiect. Pentru
exemplificare, prezentăm mai jos scriptul 10.8.php.
Scriptul 10.8
<html>
<head>
</head>
<?php
class Student {
var $NotaInf=7;
var $NotaMat=8;
function Media() {
}
function Student($x,$y) {
$this->NotaMat=$x;
$this->NotaInf=$y;
}
}
$x=9; $y=10;
$Student1=new Student($x,$y);
echo "Media=".$Student1->Media();
?>
</body>
</html>

Media=9.5
Observaţii
ü Acest script este de fapt scriptul 10.7.php modificat .
ü Numele funcţiei SetNote() a fost schimbat în Student(), adică
s-a definit un constructor al clasei.
ü Funcţia Student() nu este apelată în mod explicit pentru a iniţializa
proprietăţile obiectului Student1. Apelul acesteia a fost realizat automat prin
173
Programarea în PHP
instrucţiunea de generare a obiectului $Student1, adică prin

$Student1=new Student($x,$y).
10.3.4. Apelul unei metode din interiorul

altei metode
Scriptul 10.9.php, prezentat mai jos, ilustrează modul de apelare al

unei metode din interiorul altei metode, atunci când metodele aparţin
aceleeaşi clase. Pentru aceasta, am modificat scriptul 10.8.php adăugând
funcţia Afisare() în care se pregăteşte mesajul care va fi afişat. Această
funcţie conţine apelul funcţiei Media() utilizând variabila specială this
şi operatorul →.
Scriptul 10.9
<html>
<head>
</head>
<body>
<?php
class Student {
var $NotaInf;
var $NotaMat;
function Media() {
}
function Student($x,$y){
$this->NotaMat=$x;
$this->NotaInf=$y;
}
function Afisare() {
return "Media este:".$this->Media();
}
}
$Student1=new Student(10,6);
echo $Student1->Afisare();
?>
</body>
</html>

Media = 8
174
10.3.5. Transferul obiectelor unei clase

către metodele altei clase
Metodele şi proprietăţile unei clase pot fi folosite de metodele altei
clase. Mai precis, un obiect al unei clase poate fi transferat către metodele
altei clase. Transferul se poate face atât prin valoare cât şi prin referinţă în
PHP4 şi numai prin referinţă în PHP5.
Scriptul 10.10.php prezentat mai jos, este un exemplu de program în
care se realizează un astfel de transfer.
Scriptul 10.10
<html>
<head>
</head>
<body>
<?php
class Student {
var $NotaInf;
var $NotaMat;
function Media() {
}
function Student($x,$y) {
$this->NotaMat=$x;
$this->NotaInf=$y;
}
}
class PrimireObiectSiAfisare {
var $student;
function PrimireObiectsiAfisare($student) {
$this->student=$student;
}
function Afisare() {
return "Media=".$this->student->Media();
}
}
$transfer=new PrimireObiectSiAfisare($Student1) ;
echo $transfer->Afisare();
?>
</body>
</html>
175
Programarea în PHP

Media = 9.5
Transferul obiectului $Student1 al clasei Student către

constructorul PrimireObiectsiAfisare() al clasei
PrimireObiectSiAfisare se realizează după următorii paşi:
ü se generează obiectul $Student1 ca instanţă a clasei Student cu
ajutorul instrucţiunii:
ü obiectul $Student1 este transmis metodei
PrimireObiectSiAfisare() prin intermediul instrucţiunii:
$transfer=new PrimireObiectSiAfisare($Student1) ;
Deoarece transferul obiectelor în PHP5 se face prin referinţă,
parametrul efectiv $Student1 şi parametrul formal $student se referă la
acelaşi obiect;
ü obiectul $Student1 este memorat în variabila (proprietatea)
$student a clasei PrimireObiectSiAfisare în urma execuţiei
instrucţiunii:
$this → student=$student;
După transfer, în
corpul metodei Afisare() a clasei
PrimireObiectSiAfisare se apelează metoda Media() a clasei
$Student folosind instrucţiunea:
return "Media=".$this->student->Media();
Este de remarcat faptul că, prin intermediul obiectului transferat,
metodele unei clase pot folosi metodele şi proprietăţile clasei din care
provine obiectul. În cazul exemplului prezentat, metoda Afisare() a
clasei PrimireObiectSiAfisare foloseşte metoda Media() a clasei
Student, apelată prin intermediul obiectului $student transferat.
10.4. Moştenirea
Prin mecanismul numit moştenire, obiectele unei clase, numită clasa

copil pot folosi metodele şi proprietăţile altei clase numită clasa părinte.
Moştenirea este o trăsătură importantă a programării orientate pe obiecte.
Utilizarea ei creşte eficienţa programelor prin posibilitatea de a crea noi
176
clase (clasele copil) “adăugând” noi caracteristici la clasele deja existente

(clasele părinte). Sintactic, clasa părinte şi clasa copil se definesc astfel:
class clasa_parinte {
//proprietăţi şi metode ale clasei_parinte
}
class clasa_copil extends clasa_parinte {

//proprietăţi şi metode ale clasei_copil
{
Pentru exemplificare, să presupunem că avem deja o clasă care
permite efectuarea sumei elementelor unui vector x de n elemente. Clasa
poate fi descrisă astfel:
class SSuma {
function suma($n,$x) {
for ($i=0,$s=0; $i<$n; $i++)
$s+=$x[$i];
return $s;
}
}
Dacă dorim să calculăm media aritmetică a elementelor unui vector,

putem utiliza clasa SSuma deja existentă, construind numai clasa copil
MMedia cu următorul cod:
class MMedia extends SSuma {
function medie($n,$x) {
return $this->suma($n,$x)/$n;
}
}
Scriptul 10.11.php, care calculează media aritmetică a elementelor

unui vector generat aleator, poate fi scris acum după cum urmează:
Scriptul 10.11
<html>
<head>
</head>
<body
<?php
class SSuma {
177
Programarea în PHP

for ($i=0,$s=0; $i<$n; $i++) {
$s+=$x[$i];
}
return $s;
}
}
class MMedia extends SSuma {

return $this->suma($n,$x)/$n;
}
}
$ob=new MMedia();
$n=rand(3,4);
echo "n=".$n;
for ($i=0; $i<$n; $i++) {
$x[$i]=rand(2,50);
echo "<br>x[$i]=".$x[$i];
}
echo "<br>Media=".$ob->medie($n,$x);
?>
</body>
</html>
Observaţie. Deşi obiectul $ob este definit ca obiect al clasei

MMedia, totuşi poate accesa metoda suma() a clasei SSuma, deoarece o
moşteneşte.
În cazul în care în cele două clase, clasa copil şi clasa părinte există
proprietăţi sau metode cu acelaşi nume, atunci proprietăţile și metodele
clasei_copil vor suprascrie (redefini) proprietăţile și metodele
corespunzătoare clasei_parinte. Astfel, de exemplu, la apelul unei
metode comune ambelor clase, se va apela întotdeauna metoda din clasa
copil. În scriptul 10.12.php listat mai jos, metoda medie() este comună
claselor SumProd și MMedia. Apelul metodei medie() prin intermediul
obiectului $mediarit al clasei_copil MMedie se referă la metoda
medie() a clasei MMedie. Accesul direct la metoda medie() a clasei
părinte SumProd se poate realiza, de exemplu, prin intermediul obiectului
$mediageom al acestei clase.
178
Scriptul 10.12
<html>
<head>
</head>
<body
<?php
class SumProd {
for ($i=0,$s=0; $i<$n; $i++) {
$s+=$x[$i];
}
return $s;
}
function prod($n,$x) {
for ($i=0,$p=1; $i<$n; $i++) {
$p*=$x[$i];
}
return $p;
}
$z=$this->prod($n,$x);
return exp((1/$n)*log($z));
}
}
class MMedia extends SumProd {

return ($this->suma($n,$x)/$n);
}
}
$n=rand(2,5);
echo "n=".$n;
for ($i=0; $i<$n; $i++) {
$x[$i]=rand(2,50);
echo "<br>x[$i]=".$x[$i];
}
$mediarit=new MMedia();
echo "<br>MediaAritmetica=".$mediarit->medie($n,$x);
$mediageom=new SumProd($n,$x);
echo "<br>MediaGeometrica=".$mediageom->medie($n,$x);
?>
</body>
</html>
179
P H P
Capitolul 11
11. Persistenţa datelor

utilizând câmpuri
ascunse, cookie-uri,
sesiuni
Există numeroase situaţii când suntem interesaţi ca valorile unei
variabile create într-o anumită pagină web să fie regăsite mai târziu sau să
poată fi folosite în cadrul altor pagini web. Exemplul poate cel mai
cunoscut este cel al site-urilor de comerţ electronic, unde coşul de
cumpărături trebuie să-şi păstreze conţinutul atunci când trecem de la o
pagină la alta.
Această proprietate de conservare a unei valoari a unei variabile
chiar și atunci când trecem de la o altă pagină la alta a unui site se numeşte
persistenţă. Ea nu este furnizată în mod natural de protocolul HTTP (Hyper
Text Transfer Protocol) care asigură transportul datelor între browser şi
server. Se spune că HTTP este un protocol fără stare. Posibilitatea de a
regăsi o anumită stare a unei variabile la revenirea în pagina pe care am
vizitat-o sau chiar de a vedea la sfârşitul călătoriei traseul vizitat al site-ului
este totuşi asigurată în scripturile PHP prin folosirea a trei instrumente:
câmpuri ascunse, cookie-uri şi sesiuni.
181
Programarea în PHP
11.1. Câmpuri ascunse
În Capitolul 8 a fost prezentată o modalitate de transmitere a unei

valori „ascunse” către un script. Se spune că această valoare este ascunsă în
sensul că ea nu este afişată în browser; totuşi, utilizatorul poate avea acces
la ea oricând prin vizionarea sursei. În exemplul de mai jos avem listate
scripturile 11.1.php şi 11.2.php. Scriptul 11.1.php trimite către scriptul
11.2.php, prin intermediul unui câmp ascuns, valoarea 6 a variabilei $x.
Scriptul 11.1
<?php
$x=6;
?>
<html>
<head>
</head>
<body>
<form action="S11.2.php" method ="POST" >
<input type="hidden" name="x" value=<?php echo $x?>
size="3">
<input type="submit" name="trimite" value="Trimite datele
">
</form>
</body>
</html>
Scriptul 11.2
<html>
<head>
</head>
<body
<?php<
print '<br> Suntem in scriptul 11.2.php! ';
print '<br>Valoarea transmisa din scriptul 11.1.php este
x='.$_POST["x"];
?>
</body>
</html>
182
Capitolul 11. Persistenţa datelor utilizând câmpuri ascunse, cookie-uri, sesiuni
Observaţii
ü Execuţia scriptului 11.1.php va avea ca efect afişarea butonului de de
trimitere a datelor către scriptul 11.2.php; evident, valoarea ascunsă nu
va fi afişată!
ü Valoarea ascunsă $x=6, trimisă în scriptul 11.2.php, este accesibilă prin
intermediul variabilei globale .$_POST["x"] şi apoi afişată. În urma
execuţiei scriptului 11.2.php se vor afişa mesajele :
Suntem in scriptul 11.2.php!
Valoarea transmisa din scriptul 11.1.php este x=6
Aplicaţie. Să se efectueze media aritmetică a unui şir de numere

reale citite rând pe rând de la tastatură cu ajutorul unui formular: lungimea
şirului poate fi oarecare.
Soluţie. O soluţie posibilă este implementată în scripturile 11.3.php
şi 11.4.php, ambele prezentate mai jos:
Scriptul 11.3
<html>
<head>
</head>
<body>
</form>
</body>
<form action="11.4.php" method ="POST" ><br>
Tasteaza n=<input type="text" name="n" value ="" size="3">
<br>
<input type="submit" name="trimite" value ="Trimite n" >
</form>
</body>
</html>
Scriptul 11.4
<html>
<head>
</head>
<body>
<?php
if (isset($_POST['n']) && is_numeric($_POST['n'])) {
$n=$_POST['n'];
if (!isset($_POST['trimit'])) {
183
Programarea în PHP

$s=0;
$k=1;
} else {
$k=$_POST['k']+1;
$s= $_POST['s']+$_POST['x'];
if ($k > $n) {
print 'Media aritmetica a celor '.$n.' numere
citite este='.$s/$n;
exit();
}
}
} else {
print 'Nu a fost transmisa valoarea lui n sau a fost
transmisa o valoare nenumerica!';
print '<a href="11.3.php"><br>Citeste valoarea lui
n!</a>';
exit();
}
?>
="POST" ><br>
Tasteaza x=<input type="text" name="x" size="3"><br>
<input type="hidden" name="n" value ="<?php echo $n ?>"
><br>
<input type="hidden" name="k" value ="<?php echo $k ?>"
><br>
<input type="hidden" name="s" value ="<?php echo $s ?>"
><br>
<input type="submit" name="trimit" value ="Trimite x"
><br>
</form>
</body>
</html>
Observaţie. Numărul elementelor din șir este citit de la tastatură cu

ajutorul unui formular generat de scriptul 11.3.php şi transmis scriptului
11.4.php cu ajutorul metodei POST. Variabila $k contorizează numărul de
elemente citite din şir, iar în variabila $s se memorează sumele parţiale şi
în final suma totală. Valorile variabilelor $n, $k şi $s sunt transmise de la
o pagină la alta cu ajutorul câmpurilor ascunse. De exemplu, instrucţiunea
$s= $_POST['s']+$_POST['x'];
184
trebuie citită astfel: valoarea actuală a sumei $s este calculată ca suma

dintre valoarea precedentă $s transmisă scriptului printr-un câmp ascuns cu
construcţia
<input type="hidden" name="s" value ="<?php echo $s
?>" ><br>
şi valoarea $x transmisă „la vedere”, cu ajutorul construcţiei
Tasteaza x=<input type="text" name="x" size="3"><br
Atât valoarea anterioară $s cât şi valoarea curentă $x sunt transmise
scriptului 11.4.php cu ajutorul metodei POST.
11.2. Cookie-uri: creare, referire,

ștergere
Un cookie (prăjiturică) este o colecţie de date memorate de browser

în calculatorul clientului la solicitarea unui server sau a unui script.
Crearea şi transmiterea unui cookie se poate face în PHP utilizând
una din funcţiile setcookie() sau header(). Indiferent ce variantă se
alege, cookie-urile trebuie să fie primele care sunt transmise către browser
(înaintea oricărui cod HTML, inclusiv înaintea rândurilor albe), în caz
contrar se generează mesaje de eroare. De asemenea, trebuie precizat faptul
că nu orice browser acceptă cookie-uri şi din acest motiv, în proiectarea
unei aplicaţii care foloseşte cookie-uri trebuie să ţinem cont şi de acest
aspect.
O dată creat, un cookie va fi transmis către un script de pe server ori
de câte ori browserul solicită scriptul respectiv, însă cu respectarea
următoarelor condiţii:
ü scriptul trebuie să aparţină domeniului precizat la crearea cookie-
ului;
ü cookie-ul trebuie să fie în viaţă, adică să nu se fi depăşit data de
expirare precizată la creare.
Sintaxa funcţiei setcookie() este următoarea:
bool setcookie (string nume_cookie, string
valoarea_cookie, int data_expirare, string cale,
string domeniu, int securitate);
unde:
185
Programarea în PHP
ü nume_cookie este un argument obligatoriu alcătuit din litere şi se

referă la numele cookie-ului care se creează; poate fi şi nume de
variabilă;
ü valoare_cookie este un argument opţional şi se referă la
valoarea atribuită cookie-ului creat; poate fi şi nume de variabilă;
ü data_expirare este un argument opţional întreg în format
timestamp UNIX (timpul măsurat în secunde, scurs de la data de 1
ianuarie 1970, până când expiră cookie-ul); dacă argumentul
lipsește, cookie-ul expiră la sfârșitul sesiunii de lucru (închiderea
browserului);
ü cale este un argument opţional care limitează accesul la cookie,
doar din fişierele din calea respectivă; cînd parametrul cale nu
este precizat, accesul se poate face numai din directorul curent;
ü domeniu este un argument opţional care limitează accesul la
cookie-ul creat, doar din domeniul precizat; dacă argumentul
lipsește cookie-ul poate fi accesat din orice domeniu;
ü securitate este un argument opţional; valoarea sa poate fi 1 sau
0: dacă este egală cu 1 cookie-ul va fi transmis printr-o legătură
HTTPS securizată, în caz contrar (valoare 0) transmiterea se face
normal (prin HTTP); implicit, transmiterea va fi nesecurizată.
Funcţia întoarce valoarea booleană False dacă cookie-ul nu a fost

trimis primul către browser și True în caz contrar.
Crearea unui cookie cu numele culoare, care are valoarea egală cu
blue se poate face executând secvenţa de program de mai jos:
<?php
setcookie ("culoare", "blue", time()+3600, "/",
"upg.ro", 0);
?>
Durata sa de viaţă este exact o oră (3600 secunde) din momentul în
care a fost creată. Funcţia time() întoarce valoarea curentă a timpului
măsurată în secunde, având ca punct de referinţă 1 ianuarie 1970. Cookie-
ul va putea fi accesat pe toate directoarele de pe server (prezenţa opţiunii
"/"), însă accesul va fi restricţionat la toate subdomeniile domeniului
upg.ro.
186
Observaţii
ü Un site poate trimite unui utilizator maxim 20 cookie-uri fiecare
având o limită maximă de 4 kb. De exemplu, putem avea:
setcookie("culoare", "alb", ",",0);
setcookie("saptamana", "marti");
etc.
ü Dacă dorim să ignorăm un argument, atunci acesta trebuie să aibă
valoarea 0 dacă este de tip întreg, sau un şir vid (''sau""), dacă
este de tip string. Astfel, în exemplul de mai sus, dacă punem
valoarea 0 în loc de valoarea time()+3600, argumentul va fi
ignorat, iar cookie-ul creat va fi disponibil doar în timpul sesiunii de
lucru respective.
ü Dacă se lucrează cu browserul Internet Explorer cookie-urile sunt
creeate într-un director numit “cookies”.
ü Numele unui cookie poate fi componenta unei variabile de tip
array. Astfel, culoare şi saptamana pot fi, respectiv, indicii a
două componente ale unui tablou tab, după cum urmează:
setcookie("tab[culoare] ", "alb", ",",0);
setcookie("tab[saptamana] ","marti");
Referirea la valoarea unui cookie se poate face cu ajutorul

vectorului superglobal $_cookie sub forma
$_cookie["nume_cookie"];
O modalitate
echivalentă de referire este
$HTTP_POST_VARS["nume_cookie"]. Astfel, dacă s-a creat un cookie
prin instrucţiunea
setcookie("culoare", "alb", ",",0);
valoarea alb va fi memorată în variabila $_cookie["culoare"]; sau
echivalent în $HTTP_POST_VARS["culoare"].
Observaţie. Pentru a referi valoarea unui cookie, ca şi în cazul

metodelor POST sau GET, în loc de $_cookie["nume_cookie"] se
poate folosi forma $nume_cookie. Nu este însă o alternativă
recomandabilă, din cel puţin două motive:
ü se pierde informaţia care arată că variabila se referă la conţinutul
unui cookie;
187
Programarea în PHP
ü dacă parametrul register_global din fişierul php.ini este setat pe

off din motive de siguranţă, accesul la valoarea variabilei nu este
permis.
Conform precizărilor făcute la începutul acestui subcapitol, valoarea
unui cookie creat într-o pagină web este disponibilă sub forma
$_cookie["nume_cookie"]; în orice pagină web accesată dacă:
ü timpul de viaţă al cookie-ului nu a expirat;
ü scriptul care generează pagina unde se accesează cookie-ul se află în
domeniul și în directorul precizat la creare.
Pentru a exemplifica modul în care putem accesa valoarea unui
cookie vom considera scriptul 11.5.php prezentat mai jos.
Scriptul 11.5
<?php
setcookie('x','5',time()+60);
?>
<html>
<head>
</head>
<body>
<?php
print 'Valoarea din cookie este:'.$_COOKIE['x'];
?>
</body>
</html>
</html>
Instrucţiunea setcookie('x','5',time()+60); creează un

cookie numit x, cu o durată de viaţă de 60 secunde. Când se apelează
prima dată scriptul 11.5.php se va afișa mesajul
Valoarea din cookie este:
La acest prim apel al scriptului 11.5.php se creează într-adevăr cokie-
ul x pe calculatorul clientului. Valoarea sa va fi disponibilă însă în acest
script începând cu cel de-al doilea apel al său, dacă acesta are loc în cel
mult 60 de secunde de la crearea cookie-ului. Din acest motiv, la primul
apel, variabila $_COOKIE['x'] nu există, fapt ce explică rezultatul
obţinut. Presupunând că al doilea apel al scriptului 11.5.php se face cât
timp cokie-ului x încă mai există pe calculatorul clientului, valoarea sa 5 va
188
fi atașată adresei URL a scriptului 11.5.php și transmisă către acesta. Din

acest motiv, la cel de-al doilea apel variabila $_COOKIE['x'] există, fapt
ce explică rezultatul:
Valoarea din cookie este:5
Evident, variabila $_COOKIE['x'] va fi disponibilă în orice script
care îndeplinește condiţiile prevăzute la crearea cookie-ului. În consecinţă
apelul scriptului 11.6.php
Scriptul 11.6
<html>
<head>
</head>
<body>
<?php
print 'Valoarea x in scriptul 11.6 este:'.$_COOKIE['x'];
?>
</body>
</html>
</html>
va produce rezultatul:
Valoarea x in scriptul 11.6 este:5
Ştergerea unui cookie se face păstrând în lista de parametrii ai

funcţiei setcookie() doar parametrul obligatoriu nume_cookie.
Comanda de ştergere va fi deci setcookie("nume_cookie");
De exemplu, cookie-ul culoare creat cu
setcookie("culoare","blue",time()+3600,"/","upg.ro",0);
se poate şterge prin execuţia instrucţiunii
setcookie("culoare");
Observaţie. Pentru ştergerea cookie-ului culoare se poate folosi o

alternativă mai sigură, şi anume:
setcookie("culoare","blue",time()-
3600,"/","upg.ro",0);
Această variantă foloseşte o dată care a expirat (time()-3600). Data
expirării unui cookie se calculează în funcţie de fusul orar în care se află
serverul, în timp ce decizia browserului privind ştergerea cookie-ului ca
189
Programarea în PHP
urmare a depăşirii termenului de valabilitate este funcţie de fusul orar în

care se află clientul.
Scriptul 11.7.php, prezentat mai jos, are sarcina să șteargă cookie-ul
x creat cu ajutorul scriptului 11.5.php.
Scriptul 11.7
<html>
<head>
</head>
<body>
<?php
setcookie('x','',time()-120);
print 'Valoarea din cookie dupa stergere este:
'.$_COOKIE['x'];
?>
</body>
</html>
</html>
Ștergerea unui cookie, ca și în cazul referirii sale, devine vizibilă

începând cu al doilea apel al scriptului care conţine funcţia de ștergere sau
la acesarea altui script care face referire la variabilele memorate în cookie.
Explicaţiile sunt similare cu cele cu cele prezentate la crearea și referirea
valorilor memorate într-un cookie. Din acest motiv, la prima apelare a
scriptului 11.7.php se va afișa
Valoarea din cookie dupa stergere este: 5,
iar la a doua apelare rezultatul afişat va fi
Valoarea din cookie dupa stergere este:
Aplicaţie. Să se implementeze în PHP un mecanism care să

contorizeze apelurile unui script.
Soluţie. O posibilă soluţie a acestei probleme este scriptul 11.8.php
prezentat mai jos. Acesta conţine o schemă generală de contorizare a
apelurilor unui script, utilizând cookie-urile pentru a asigura persistenţa
contorului de memorare, de la o încărcare la alta a paginii.
190
Scriptul 11.8
<?php
if (!isset($_COOKIE['contor'])) {
setcookie('contor','1');
print 'Scriptul a fost apelat 1 data ';
} else {
//prelucrari script
$_COOKIE['contor']+=1;
setcookie('contor',$_COOKIE['contor']);
print "Scriptul 11.8 a fost apelat de
{$_COOKIE['contor']} ori";
}
?>
<html>
<head>
</head>
<body>

</body>
</html>
</html>
Observaţie. Variabila $_COOKIE['contor'] este iniţializată în

urma apelului funcţiei setcookie('contor','1');. În continuare,
fiecare pagină nou încărcată va avea acces la valoarea
$_COOKIE['contor'] anterioară deoarece ea a fost deja expediată către
client prin instrucţiunea
setcookie('contor', $_COOKIE['contor']);
11.3. Sesiuni
Când un utilizator răsfoieşte paginile unui site, de cele mai multe ori
are nevoie de un mecanism care să-i permite accesul la anumite informaţii,
indiferent de pagina pe care o traversează.
Sesiunile reprezintă o soluţie alternativă la folosirea cookie-urilor în
revolvarea acestei probleme. În esenţă, mecanismul de lucru al unei sesiuni
este următorul. În momentul când utilizatorul accesează pagina unui site
care beneficiază de o astfel de facilitate, se iniţiază o sesiune care are ca
efect generarea aleatoare a unui identificator unic de sesiune (ID). Acest ID
191
Programarea în PHP
va fi memorat automat într-un cookie, numit implicit PHPSESSID, care

este şi numele sesiunii. Fiind vorba de un cookie, informaţia va fi
memorată într-o variabilă șir numită SID, sub forma:
PHPSESSID=ID
Dacă se atribuie sesiunii în mod explicit un nume, atunci SID-ul va

avea forma:
nume_sesiune=ID
Un fişier temporar care are acelaşi nume cu ID-ul generat este creat
pe server. Acest fișier permite memorarea sub forma unor variabile de
sesiune a informaţiilor care se doresc a fi accesibile şi din alte pagini ale
site-ului. Când se vizitează o astfel de pagină, în cadrul aceleiaşi sesiuni de
lucru, prin intermediul ID-ului prezent în cookie-ul PHPSESSID se
accesează fişierul temporar cu acelaşi nume de pe server. Informaţiile
memorate în acest fișier tempoar devin astfel accesibile, prin intermediul
variabilelor de sesiune, și celorlalte pagini ale site-ului.
Unul din punctele forte ale sesiunilor constă în stabilirea
identificatorului unic ID pentru utilizatorul de sesiune. În felul acesta,
utilizatorul este recunoscut sub acest „nume” în toate paginile dorite ale
site-ului. Faptul că acest ID este memorat într-un cookie, face metoda
dependentă de browser, în sensul că acesta ar putea să accepte sau nu
cookie-uri. Pentru a fi siguri că metoda funcţionează chiar şi atunci când
browserul nu acceptă cookie-uri există posibilitatea de a transmite
identificatorul de sesiune (ID) de la o pagină la alta adăugându-l într-o
referinţă, ca în exemplul de mai jos, sub forma
<a href="Paginak.php?<?php echo SID;?>">Acceseaza o
pagina cu SID adaugat la URL</a>
Spre deosebire de cookie-uri, sesiunile permit memorarea unui

volum mult mai mare de date. În plus, într-o sesiune memorarea datelor se
face pe server, fapt ce elimină „naveta” lor între server şi browser.
Consecinţa este că utilizarea sesiunilor oferă mai multă siguranţă decât
utilizarea cookie-urilor.
192
11.3.1. Funcţii şi variabile de sesiune
Gestiunea activităţilor din cadrul unei sesiuni se face cu ajutorul

funcţiilor şi a variabilelor de sesiune. Prezentăm în continuare câteva
funcţii de bază şi dăm câteva exemple de folosire a variabilelor de sesiune.
Iniţierea unei sesiuni se face cu ajutorul funcţiei
session_start().
Sintaxa funcţiei este:
bool session_start(void);
Funcţia returnează întotdeauna valoarea True.
Apelul unei funcţii session_start() are ca efect iniţierea unei
sesiuni, dacă nu cumva aceasta a fost deja iniţiată. La iniţierea unei sesiuni,
funcţia session_start() realizează următoarele acţiuni:
ü generează indicatorul unic de sesiune memorat în SID;
ü trimite un cookie (cu nume implicit PHPSESSID) către browser în
care se va memora ID-ul sesiunii (dacă browserul acceptă cookie-
uri);
ü crează un fişier temporar pe server cu acelaşi nume cu ID-ul sesiunii
în care vor fi memorate variabilele sesiunii.
Observaţie. Deoarece funcţia session_start() încearcă să

trimită cookie-uri către browser la iniţierea unei sesiuni, ea va trebui să fie
plasată astfel încât aceste date să fie transmise primele către browser. Dacă
la apelul funcţiei session_start() sesiunea este deja iniţiată printr-un
apel anterior al acesteia, utilizatorul va primi acelaşi identificator de
sesiune (ID) fapt ce-i va permite utilizarea variabilelor de sesiune
memorate temporar pe server.
Distrugerea unei sesiuni se face cu ajutorul funcţiei

session_destroy().
bool session_destroy(void);
şi întoarce True în caz de succes şi False în caz contrar.
Funcţia session_destroy() elimină datele sesiunii din server,
mai precis fişierul temporar creat pe server o dată cu lansarea funcţiei
193
Programarea în PHP
session_start(). Funcţia nu şterge însă cookie-ul de sesiune şi nici

variabilele globale asociate sesiunii.
Pentru a şterge cookie-ul de sesiune se foloseşte o construcţie de
genul
setcookie ("nume_sesiune", " ", time()-3600, "/");
Pentru a şterge variabilele de sesiune se poate utiliza funcţia
unset(), ca în exemplele următoare:
unset($_SESSION);//sterge variabilele sesiunii
unset($_SESSION['var']);//sterge variabila $var a
sesiunii.
Denumirea unei sesiuni se face cu ajutorul funcţiei

session_name(). Sintaxa funcţiei este următoarea:
string session_name(string $nume);
unde $nume este un parametru opţional format numai din litere.
Funcţia întoarce numele sesiunii curente, iar dacă parametrul $nume
este prezent, atunci numele sesiunii va fi setat la această valoare. De
exemplu, în urma execuţiei secvenţei:
session_name('Alfa');
print '<p> Numele sesiunii
este:'.session_name().'<p>';
se va afişa
Numele sesiunii este: Alfa.
Dacă parametrul $nume nu este prezent, atunci session_name()
va întoarce numele standard al unei sesiuni, adică PHPSESSID. Astfel, în
urma execuţiei secvenţei:
session_name();
print '<p> Numele sesiunii
este:'.session_name().'<p>';
se va afişa
Numele sesiunii este:PHPSESSID
Observaţie. La apelul unui script funcţia session_name() trebuie

să fie apelată de fiecare dată pentru a redenumi valoarea implicită a
numelui sesiunii, valoare setată în fișierul php.ini. Apelul funcţiei trebuie
să fie făcut înaintea funcţiei session_start().
194
Identificatorul ID al unei sesiuni este gestionat cu ajutorul funcţiei

session_id().
Funcţia session_id() are sintaxa
string session_id(string $id)
unde $id este un argument de tip string opţional.
Funcţia întoarce identificatorul sesiunii curente. Când argumentul
$id este prezent, funcţia setează indicatorul sesiunii curente la valoarea
$id şi întoarce această valoare. Dacă nu este activă nici o sesiune, funcţia
întoarce un şir vid.
print "Nume identificator=".session_id();
întoarce un mesaj asemănător cu
Nume identificator=c30d9e55a70a50bb17c1ecf91c4796cb
dacă este activă o sesiune, iar în caz contrar mesajul
Nume identificator=
Directorul în care sunt memorate datele sesiunii se află sau se

precizează cu ajutorul funcţiei session_save_path().
Funcţia session_save_path() are sintaxa:
string session_save_path(string $cale);
unde argumentul $cale este opţional.
Funcţia întoarce calea către directorul curent unde sunt memorate
datele sesiunii; în plus, când argumentul $cale este prezent, datele sesiunii
vor fi memorate în directorul specificat prin acest argument.
print "Nume director=".session_save_path()
întoarce un mesaj asemănător cu
C:\ProgramData\NuSphere\php_sessions
11.3.2. Generarea unei sesiuni
În scriptul 11.9.php, listat mai jos, este iniţiată o sesiune şi se

generează variabilele de sesiune $_SESSION["x"] şi $_SESSION["y"].
Valorile acestor două variabile sunt transmise de la tastatură prin
intermediul unui formular, prin metoda $_POST.
195
Programarea în PHP
Scriptul 11.9
<php
session_start()
?>
<html>
<head>
</head>
<body>
<?php
if (isset($_POST["trimite"])) {
print '<p>Identificatorul de sesiune(ID)
este:'.session_id().'</p>';
print '<p>Numele sesiunii este:'.session_name().'</p>';
print '<p>Directorul sesiunii curente
este:'.session_save_path("D:\wamp").'</p>';
print '<p>SID este :'.SID.'</p>';
$_SESSION["x"]=$_POST["x"];
$_SESSION["y"]=$_POST["y"];
print 'Variabilele de sesiune sunt:x='.$_SESSION["x"].'
si y='.$_SESSION["y"];
print '<br><p> <a href= "11.10.php">Vezi sesiune</a>
</p>';
} else {
print "<form action=\"$_SERVER[PHP_SELF]\" method
=\"POST\" ><br>
x:<input type=\"text\" name=\"x\" value =3
size=\"3\"><br>
y:<input type=\"text\" name=\"y\" value =7
size=\"3\"><br>
<input type=\"submit\" name=\"trimite\" value
=\"Trimite datele de intrare\">
</form>";
}
?>
</body>
</html>
În urma execuţiei scriptului 11.9.php se vor afișa următoarele

rezultate:
Identificatorul de sesiune(ID) este:
30a9264498390d5d1f84a0e7e5e77dac
Numele sesiunii este:PHPSESSID
Directorul sesiunii curente este:
C:\ProgramData\NuSphere\php_sessions
SID este :PHPSESSID= 30a9264498390d5d1f84a0e7e5e77dac
196
Variabilele de sesiune sunt:x=3 si y=7

Vezi sesiune
De asemenea, execuţia scriptului 11.9.php va genera în directorul

afişat de funcţia session_save_path() un fişier cu numele identic cu
numele identificatorului de sesiune (ID). În acest caz, acest fişier are
numele: sess_ 30a9264498390d5d1f84a0e7e5e77dac
Conţinutul acestui fişier este un şir asemănător cu secvenţa de caractere
x|s:1:"3";y|s:1:"7"; . Șirul reprezintă variabilele globale
$_SESSION["x"] şi $_SESSION["y"], împreună cu valorile lor, 3 și 7.
Executând click pe link-ul Vezi sesiune se va lansa în execuţie
scriptul 11.10.php listat mai jos :
Scriptul 11.10
<?php
session_start();
?>
<html>
<head>
</head>
<body>
<?php
print 'Identificatorul de sesiune
este:'.session_id().'<br>';
print 'In scriptul 11.10.php,variabilele de sesiune
sunt:x='.$_SESSION["x"].' si y='.$_SESSION["y"];
?>
</body>
</html>

Identificatorul de sesiune este:
30a9264498390d5d1f84a0e7e5e77dac
In scriptul 11.10.php variabilele de sesiune sunt:x=3
si y=7
197
Programarea în PHP
Este de reţinut faptul că valorile 3 şi 7 transmise de la tastatură în

scriptul 11.9.php sunt acesibile în scriptul 11.10.php prin intermediul
variabilelor de sesiune $_SESSION["x"] şi $_SESSION["y"].
11.3.3. Ștergerea unei sesiuni
Distrugerea unei sesiuni se realizează cu ajutorul funcţiei

session_destroy(). Pentru a se putea constata efectul acestei funcţii
inserăm în scriptul 11.9.php imediat înainte de instrucţiunea
print '<br><p> <a href= "11.10.php"> Vezi sesiune</a>
</p>';
următoarea secvenţă de instrucţiuni:
session_destroy();
print '<br>Dupa distrugerea sesiunii,in scriptul
11.10.php variabilele de sesiune sunt:x=';
print $_SESSION["x"].' si y='.$_SESSION["y"];
După efectuarea modificărilor, salvarea acestora şi execuţia

scriptului 11.9.php, astfel modificat, se pot face următoarele observaţii:
ü execuţia funcţiei session_destroy() nu a şters imediat
variabilele de sesiune, aşa cum se poate constata din mesajul:
Dupa distrugerea sesiunii,in scriptul 11.9.php
variabilele de sesiune sunt:x=3 si y=7
ü execuţia funcţiei session_destroy() a şters fişierul creat la
iniţierea sesiunii (se poate constata acest lucru inspectând directorul
afişat de funcţia session_save_path()).
Lansând în execuţie scriptul 11.10.php prin activarea link-ului Vezi

sesiune vom observa că se va afişa:
In scriptul 11.10.php, variabilele de sesiune sunt: x=

si y=
În concluzie, după execuţia funcţiei session_destroy(), în

cadrul scriptului care conţine această funcţie, variabilele de sesiune rămân
în continuare accesibile până la relansarea scriptului. În schimb, în celelalte
scripturi, ele nu mai sunt accesibile (vezi cazul scriptului 11.10.php) .
198
Aşa cum s-a precizat deja la prezentarea funcţiei

session_destroy(), eliminarea variabilelor generate în cadrul unei
sesiuni se face utilizând funcţia unset(). Astfel, dacă dorim să eliminăm
toate variabilele de sesiune putem introduce în scriptul 11.9.php înainte de
session_destroy(), instrucţiunea:
unset($_SESSION);
care va avea ca efect distrugerea tuturor variabilelor de sesiune (în cazul
nostru a variabilelor $x şi $y). Evident, ştergerea unei variabile de sesiune
oarecare se face după modelul
unset($_SESSION["x"]);
Exemplu. Aplicaţia care urmează reprezintă o ilustrare şi mai
convingătoare a capacităţii sesiunilor de a asigura persistenţa datelor de la o
pagină la alta. Aplicaţia este alcătuită din scripturile 11.11.php, 11.12.php,
11.13.php şi 11.14.php, pe care le prezentăm mai jos.
Scriptul 11.11
<?php
session_start();
?>
<html>
<head>
</head>
<body
<?php
$_SESSION['traseu'][]='A ';
print '<p> <a href= "11.11.php">A </a></p>';
print '<p> <a href= "11.12.php">B </a> </p>';
print '<p> <a href= "11.13.php">C</a></p>';
print '<p> <a href= "11.14.php">Traseu parcurs</a></p>';
?>
</body>
</html>
Scriptul 11.12
<?php
session_start();
?>
<html>
<head>
</head>
199
Programarea în PHP

<body
<?php
$_SESSION['traseu'][]='B ';
print '<p> <a href= "11.11.php">A</a></p>';
print '<p> <a href= "11.12.php">B </a> </p>';
?>
</body>
</html>
Scriptul 11.13
<?php
session_start();
?>
<html>
<head>
</head>
<body
<?php
$_SESSION['traseu'][]='C ';
print '<p> <a href= "11.12.php">B</a> </p>';
?>
</body>
</html>
Scriptul 11.14
<?php
session_start();
$n=count($_SESSION['traseu']);
?>
<html>
<head>
</head>
<body
<?php
print '<p> <a href= "11.12.php">B</a></p>';
200

for ($i=0;$i<$n;$i++) {
print $_SESSION['traseu'][$i];
}
unset($_SESSION['traseu']);
session_destroy();
?>
</body>
</html>
</html>
Scripturile alcătuiesc împreună un mic site accesibil prin meniul:

A
B
C
Traseu parcurs
Accesarea scripturilor 11.11.php, 11.12.php şi 11.13.php este

marcată prin adăugarea în variabila $_SESSION['traseu'][] a
şirurilor 'A ','B ' şi respectiv 'C '. În felul acesta, în vectorul
$_SESSION['traseu'][] se va memora traseul străbătut de utilizator
prin paginile acestui site-ului. Scriptul 11.14.php afișează acest traseu, după
care va distruge variabila $_SESSION['traseu'], fapt ce echivalează cu
momentul zero al unei noi călătorii prin paginile minisite-ului. Traseele
afișate sunt asemănătoare cu exemplul: A B C A A C B A etc.
11.4. Aplicaţii. Simularea unui

mecanism de autentificare și
autorizare
În cele ce urmează vom încerca să se simulăm un mecanism de

autentificare şi autorizare utilizând coockie-urile sau sesiunile.
Autentificarea se referă la procesul de stabilire a identităţii utilizatorului,
iar autorizarea are în vedere accesul la resurse.
201
Programarea în PHP
Pentru exemplificare vom construi o aplicaţie foarte simplă, formată

numai din trei scripturi: un script de logare (Login), altul care permite
afișarea numelui utilizatorului (AfisareUser) și altul care permite
delogarea (Logout). În funcţie de mecanismul folosit pentru asigurarea
persistenţei datelor, aplicaţia va fi implementatată în două variante:
varianta bazată pe utilizarea coockie-urilor (secţiunea 11.4.1) și varianta
bazată pe utilizarea sesiunilor (secţiunea 11.4.2). Deoarece modalitatea de
stocare a datelor în fişiere şi baze de date va fi prezentată în capitolele
următoare, în continuare vom presupune că doar utilizatorul user poate
avea acces la paginile acestui mini-site pe baza parolei password. Accesul
la paginile site-ului se face prin intermediul meniului următor:
Login
Logout
AfisareUser
În următoarele două secţiuni sunt implementate cele două variante

prezentate mai sus.
11.4.1. Varianta bazată pe utilizarea

cookie-urilor
În această secţiune sunt prezentate siteuri-le 11.15.php, 11.16.php şi
11.17.php care permit logarea, afişarea numelui utilizatorului şi respectiv
delogarea de la aplicaţie, persistenţa datelor fiind asigurată prin cookie-uri.
Scriptul 11.15
<?php
// Acest script permite logarea la mini-site
setcookie('autorizare',"1");
setcookie('nume',"user");
?>
<html>
<head>
</head>
<body>
<?php
202

if( !empty($_POST['nume']) && !empty($_POST['parola']))
{
if ($_POST['nume'] == 'user' && $_POST['parola'] ==
'password') {
print 'Logare reusita!';
} else {
print '<br>Cont sau parola incorecte!<br>';
}
} else {
print '<br> Completati ambele campuri!<br>';
}
print '<br><a href="S11.15.php">Login</a><br>
<a href="S11.16.php">Logout</a><br>
<a href="S11.17.php">AfisareUser </a><br>';
} else {
print '<form action="S11.15.php" method="POST">
Nume cont: <input type="text" name="nume" size="15"
><br>
Parola: <input type="password" name="parola"
size="15"><br>
<input type="submit" name="trimite" value="Log In"
<form>';
}
?>
</body></html>
Scriptul 11.16
<?php
// Acest script realizeaza delogarea
setcookie('autorizare',"",time()-120);
?>
<html>
<head>
</head>
<body>
<?php
print 'Sesiune de lucru terminata!';
?>
</body>
</html>
203
Programarea în PHP
Scriptul 11.17
<html>
<head>
</head>
<body>
<?php
//Acest script testeaza daca utilizatorul este autorizat
if($_COOKIE['autorizare']=="1") {
print 'Acces autorizat la aceasta pagina pentru domnul
'.$_COOKIE["nume"];
} else {
print 'Acces interzis1 Mergeti la pagina de Login<br>' ;
}
?>
</body>
</html>
11.4.2. Varianta bazată pe utilizarea

sesiunilor
În această secţiune sunt prezentate siteuri-le 11.18.php, 11.19.php şi
11.20.php care permit logarea, afişarea numelui utilizatorului şi respectiv
delogarea de la aplicaţie, persistenţa datelor fiind asigurată prin cookie-uri.
Scriptul 11.18
<?php
// Acest script permite logarea la mini-site
session_start();
?>
<html>
<head>
</head>
<body>
<?php
if( !empty($_POST['nume']) && !empty($_POST['parola']))
{
if ($_POST['nume'] == 'user' && $_POST['parola'] ==
'password') {
$_SESSION['nume']=$_POST['nume'];
204

$_SESSION['parola']=$_POST['parola'];
print 'Logare reusita!';
} else {
print '<br>Cont sau parola incorecte!<br>';
}
} else {
print '<br> Completati ambele campuri!<br>';
}
} else {
print '<form action="S11.18.php" method="POST">
Nume cont: <input type="text" name="nume" size="15"
><br>
Parola:<input type="password" name="parola"
size="15"><br>
<input type="submit" name="trimite" value="Log In"
<form>';
}
?>
</body>
</html>
Scriptul 11.19
<?php
// Acest script realizeaza delogarea
session_start();
?>
<html>
<head>
<title>Scriptul S11.19</title>
</head>
<body>
<?php
unset($_SESSION);
session_destroy();
print 'Sesiune de lucru terminata!';
?>
</body></html>
205
Programarea în PHP
Scriptul 11.20
<?php
//Acest script testeaza daca utilizatorul este autorizat
session_start();
?>
<html>
<head>
</head>
<body>
<?php
if (($_SESSION["nume"]=='user')&&
($_SESSION["parola"]=='password')) {
print 'Acces autorizat la aceasta pagina pentru domnul
'.$_SESSION["nume"];
} else {
print 'Acces interzis1 Mergeti la pagina de Login<br>' ;
}
?>
206
P H P
Capitolul 12
12. Fişiere
În acest capitol prezentăm funcţiile de bază care permit crearea şi
exploatarea datelor fişierelor PHP.
12.1. Funcţia de deschidere fopen() şi

funcţia de închidere fclose()
Operaţiile de citire şi scriere asupra unui fişier pot fi efectuate numai

dacă fişierul a fost deschis. Deschiderea unui fişier se realizează cu funcţia
fopen(), care are într-o formă restrânsă are următoarea sintaxă:
int fopen(string nume_fisier, string mod);
unde nume_fisier este numele fişierului, iar mod este un şir prin care se
precizează modul în care va fi deschis fişierul. Dacă deschiderea s-a făcut
cu succes funcţia întoarce valoare True, iar în caz contrar, valoarea
False.
Parametrul mod poate lua următoarele valori:
'r' pentru citire; pointerul fişierului (indicatorul de poziţie) este
poziţionat la începutul fişierului;
207
Programarea în PHP
'r+' pentru citire sau scriere; pointerul fişierului este poziţionat la

începutul fişierului;
'w' pentru scriere; pointerul fişierului este poziţionat la începutul
fişierului; dacă fişierul nu există se încearcă crearea lui, iar
dacă există, conţinutul său va fi şters;
'w+' pentru citire sau scriere; dacă fişierul există, poziţionarea se va
face la începutul său, în ambele situaţii (citire/scriere); la
scriere conţinutul fişierului va fi şters. Dacă fişierul nu există
se va încerca crearea sa;
'a' pentru scriere; dacă fişierul există, pointerul va fi poziţionat la
sfârşitul datelor existente, permiţând adăugarea datelor noi;
dacă fişierul nu există se încearcă crearea lui;
'a+' pentru citire sau scriere; dacă fişierul există, pointerul său este
poziţionat la sfârşitul datelor existente, şi permite la scriere
adăugarea datelor noi; dacă nu există se încearcă crearea lui;
'x' pentru scriere; dacă fişierul nu există se va încerca crearea sa;
pointerul fişierului va fi poziţionat la începutul său ; dacă
fişierul există deja funcţia fopen() va întoarce False şi se
va genera un mesaj de avertizare;
'x+' pentru citire sau scriere; comportament asemănător cu
utilizarea modului 'x'.
Observaţie. Un fişier poate fi deschis în mod text sau binar. În cazul

fişierelor text (care pot fi vizualizate şi cu ajutorul unor editoare de text, de
exemplu Notepad) trebuie avut în vedere faptul că marcarea sfârşitului de
linie este diferită pentru diverse sisteme de operare. De exemplu, simbolul
de întrerupere de rând este \n pentru sistemul de operare Unix şi \r\n
pentru sistemul de operare Windows. Se poate preciza în mod explicit
modul text adăugând caracterul t la sfârşitul valorilor mod deja prezentate
(de exemplu, r+t, w+t etc.). De asemenea, modul de deschidere binar se
poate preciza explicit în aceeaşi manieră, adică r+b, w+b etc.
Exemplu. O instrucţiune de forma

$fp=fopen(nume_fisier, mod);
208
Capitolul 12. Fişiere
încearcă să deschidă fişierul nume_fisier într-una din variantele

precizate de parametrul mod. Rezultatul este memorat în variabila $fp. În
mod normal, orice operaţie de citire/scriere asupra fişierului trebuie făcută
numai după ce suntem siguri că fişierul este deschis. Pentru a verifica acest
lucru testăm valoarea variabilei booleene $fp. Fişierul este deschis dacă şi
numai dacă variabila $fp ia valoarea True). Din acest motiv, pentru a a
se evita erorile generate de încercarea de a prelucra un fişier închis, este
recomandat să se testeze în prealabil valoarea acestei variabile, folosind,
eventual, una din formele de mai jos:
$fp=fopen(nume_fisier, mod)
if ($fp){
//prelucrari
}
sau
if ($fp=fopen(nume_fisier, mod)){
//prelucrari
}
sau
$fp=fopen(nume_fisier, mod) or die ("Nu se poate
deschide fisierul!");
Observaţie. Execuţia funcţiei die() are ca efect întreruperea

execuţiei unui script. În exemplul de mai sus, execuţia ei se va produce
doar în cazul în care fişierul nu se poate deschide.
După efectuarea operaţiilor de citire sau scriere, fişierul trebuie

întotdeauna închis. Funcţia care realizează închiderea unui fişier este
fclose() şi are sintaxa:
bool fclose(bool fp);
unde fp este pointerul fişierului (file pointer) returnat la apelul funcţiei
fopen(). Funcţia întoarce valoarea True în caz de succes şi False în caz
de insucces.
De exemplu, presupunând că fişierul date.txt a fost deschis cu
instrucţiunea
$fp=fopen('date.txt','rb');
închiderea sa se va face cu instrucţiunea fclose($fp);
209
Programarea în PHP
12.2. Scrierea datelor în fişiere
În cele ce urmează vom face o scurtă prezentare, însoţită de exemple,

a principalelor funcţii de scriere în fişiere: fwrite() cu aliasul ei
fputs() şi fie_puts_contents(). De asemenea va fi descrisă şi
funcţia flock() care permite blocarea sau deblocarea fişierelor la citire
sau scriere.
12.2.1. Funcţiile fwrite() şi fputs() pentru

scrierea în fişiere
Funcţia fwrite() permite scrierea unui şir de date într-un fişier.

Sintaxa ei este următoarea:
int fwrite(int fp, string sir, string ls);
unde:
ü fp – este pointerul fişier returnat de funcţia fopen();
ü sir – este şirul care va fi scris în fişier în totalitate sau parţial;
ü ls – numărul de caractere din şir care vor fi scrise în fişier; este un
parametru opţional.
Funcţia întoarce numărul de octeţi scrişi în fişier sau valoarea False
în caz de eroare.
De exemplu, execuţia scriptului 12.1.php, prezentat în continuare, va
crea fişierul test.txt, care va conţine cuvântul clar şi va afişa
mesajele:
Numarul de octeti scris in fisierul test.txt este 4
Uita-te in fisierul test.txt pentru a vedea
rezultatul!
Scriptul 12.1
<html>
<head>
</head>
<body>
<?php
$fis="test.txt";
$f=fopen($fis,'w') or die("Nu se poate deschide fisierul
$fis");
210

if (($nroct=fwrite($f,'claritate',4 ))===False) {
echo "Nu se poate scrie in fisierul $fis";
exit;
} else {
echo "<br>Numarul de octeti scris in fisierul $fis este
$nroct";
echo "<br>Uita-te in fisierul test.txt pentru a vedea
rezultatul!";
}
fclose($f);
?>
</body>
</html>
Dacă vom utiliza apelul fwrite($f,'claritate') în loc de

apelul fwrite($f,'claritate',4), în fişierul test.txt se va scrie
cuvântul claritate.
Exemplu. Execuţia scriptului 12.2.php realizează citirea unui şir de
la tastatură cu ajutorul unui formular şi scrierea sa în fişierul a.txt.
Scriptul 12.2
<html>
<head>
</head>
<body>
<?php
$f=fopen('a.txt','a') or die('Nu se poate deschide
fisierul a.txt!');
$randul=$_POST["randul"];
fwrite($f,"$randul\r\n" ) or die('Nu se poate scrie in
fisierul a.txt!');
echo "S-a scris in fisier sirul de caracterele
".$_POST["randul"];
fclose($f);
} else {
print '<form action="12.2.php" method ="POST">
<br>Sirul:<input type="text" name="randul" size="20">
datele de intrare">';
}
?>
</body>
</html>
211
Programarea în PHP
În urma execuţiei scriptului 12.2.php se va afişa un mesaj

asemănător cu următorul:
S-a scris in fisier sirul de caracterele AbCdEfGh
Evident, conţinutul fişierului a.txt va fi: AbCdEfGh
Pentru a memora mai multe şiruri citite succesiv de la tastatură se

poate scrie o variantă (scriptul 12.3.php) a scriptului 12.2.php. Aceasta
foloseşte un câmp ascuns k pentru a contoriza numărul de şiruri transmise
de la tastatură şi un alt câmp ascuns n pentru a transmite la fiecare apel al
scriptului, numărul maxim de şiruri acceptate. Deoarece se doreşte ca
fiecare şir transmis de la tastatură să fie scris în fişier pe un rând, şirul de
caractere $randul va fi completat cu caracterele \r\n care marchează
trecerea la rândul următor.
Scriptul 12.3
<html>
<head>
</head>
<body>
<?php
if (!isset($_POST["trimite"])) {
$k=0;
$n=5;
echo "n=$n";
} else {
fisierul a.txt!');
fwrite($f,"$randul\r\n" ) or die('Nu se poate scrie in
fisierul a.txt!');
$k=$_POST['k']+1;
$n=$_POST['n'];
if ($k==$n) {
fclose($f);
echo "$k siruri de caractere au fost scrise in
fisierul a.txt!";
exit();
}
}
?>
212

="POST" >
<input type="hidden" name="k" value ="<?php echo $k ?>" >
<input type="hidden" name="n" value ="<?php echo $n ?>" >
datele de intrare">
</form>
</body>
</html>
În urma execuţiei scriptului 12.3.php se va afişa mesajul

5 şiruri de caractere au fost scrise in fisierul
a.txt!
iar conţinutul fişierului a.txt va fi asemănător cu
AbCdEfGh
sddf
erfrtrfr
U0546Gjjj
ecffd$6b7b7
nnvcy^8f655
Observaţie. Funcţia fputs() este un alias al funcţiei fwrite(),

adică are aceeaşi sintaxă şi funcţionează în acelaşi mod.
12.2.2. Funcţia file_puts_contents() pentru

scriere în fişiere
Versiunea PHP5 a limbajului PHP conţine funcţia

file_puts_contents() a cărei execuţie echivalează cu execuţia
succesivă a funcţiilor fopen(), fwrite() şi fclose().
Într-o formă minimală (vezi manualul PHP la adresa
http://php.net/manual/ro/ pentru mai multe detalii), sintaxa funcţiei este
următoarea:
int file_puts_contents(nume_fisier, date, flag);
unde:
ü nume – este numele fişierului în care se scriu datele;
ü date – poate fi un string sau un tablou unidimensional;
213
Programarea în PHP
ü flag – este un parametru opţional care poate lua diferite valori (de
exemplu, FILE_APPEND pentru adăugare în fişier, LOOKEY pentru
blocarea fişierului etc.).
În caz de succes, funcţia întoarce numărul de octeţi scrişi în fişier, iar
în caz contrar valoarea False.
În continuare, vom ilustra utilizarea funcţiei
file_puts_contents() prin două exemple: în primul exemplu se scrie
în fişier un şir de caractere, iar în al doilea un vector.
Scriptul 12.4.php, prezentat mai jos, realizează scrierea unui şir de
caractere într-un fişier. Scriptul este este o copie a scriptului 12.3.php, în
care cele trei funcţii fopen(), fwrite() şi fclose() au fost înlocuite
cu funcţia file_put_contents. Se observă şi prezenţa parametrului
FILE_APPEND care permite adăugarea datelor noi la cele deja prezente în
fişier.
Scriptul 12.4
<html>
<head>
</head>
<body>
<?php
$k=0;
$n=5;
echo "n=$n";
} else {
file_put_contents('a.txt',"$randul\r\n",FILE_APPEND );
$k=$_POST['k']+1;
$n=$_POST['n'];
if ($k==$n) {
echo "$k siruri de caractere au fost scrise in
fisierul a.txt!";
exit();
}
}
?>
="POST" >
<input type="hidden" name="k" value ="<?php echo $k ?>" >
<input type="hidden" name="n" value ="<?php echo $n ?>" >
214

datele de intrare">
</form>
</body>
</html>
Un exemplu de scriere a elementelor unui vector unidimensional,

într-un fişier, este scriptul 12.5.php, prezentat în continuare.
Scriptul 12.5
<html>
<head>
</head>
<body>
<?php
$z=array('a'=>3,'b'=>8,'c'=>7);
file_put_contents('a.txt',$z,FILE_APPEND );
echo "Au fost scrise in fisier componentele vectorului:
{$z['a']},{$z['b']} si {$z['c']}";
?>
</body>
</html>

Au fost scrise in fisier componentele vectorului:
3,8 si 7.
Dacă se deschide cu un editor de text fişierul a.txt se observă că
aici au fost stocate componentele vectorului, sub forma 387.
12.2.3. Funcţia flock() pentru blocarea şi

deblocarea fişierelor
Funcţia flock() permite ca procesul curent de scriere sau citire

asupra unui fişier să se desfăşoare în bune condiţii, chiar dacă alte procese
încearcă să utilizeze fişierul în acelaşi timp. De exemplu, când scriptul
curent scrie într-un fişier, fişierul este blocat temporar pentru alte procese.
Sintaxa funcţiei flock() este:
bool flock(int fp, int operatie);
215
Programarea în PHP
unde:
ü fp este pointerul fişierului;
ü operatie poate lua una din următoarele valori: LOCK_SH,
LOCK_EX, LOCK_UN sau LOCK_NB
Tipurile uzuale de blocaj sunt:
ü partajat – permite altor procese să citească din fişier, dar nu
permite scrierea (se foloseşte la citirea din fişier). Constanta folosită
este LOCK_SH;
ü exclusiv – nu permite altor procese scrierea sau citirea din fisier
(se foloseşte la scrierea în fişier). Constanta folosită este LOCK_EX;
ü eliminare blocaj – elimină blocajul partajat sau exclusiv asupra
fişierului. Se foloseşte constanta LOCK_UN.
Funcţia are efect dacă este utilizată de toate scripturile care scriu sau
citesc din fişier.
Exemplu. În scriptul 12.6.php, prezentat mai jos, se ilustrează modul
în care este utilizată funcţia flock().
Scriptul 12.6
<html>
<head>
</head>
<body>
<?php
$k=0;
echo "k=$k";
} else {
$rindul=$_POST["x"].' '.$_POST["y"];
fisierul a.txt');
flock($f,LOCK_EX); //blocare fisier
fwrite($f,"$rindul\r\n" );
flock($f,LOCK_UN); //deblocare fisier
fwrite($f,"$rindul\r\n" );
$k=$_POST[k]+1;
if ($k>=3) {
fclose($f);
echo "Datele au fost scrise in fisier!";
exit();
}
}
216

?>
="post" >
<br>x:<input type="text" name="x" value =3 size="3">
<br>y:<input type="text" name="y" value =5 size="3">
<br><input type="hidden" name="k" value ="<?php echo $k ?>"
><br>
datele" />
</form>
</body>
</html>
12.3. Citirea datelor din fişier
Limbajul PHP oferă o gamă variată de funcţii care permit citirea

datelor din fişiere.
O primă impresie asupra facilităţilor oferite de PHP în acest domeniu
ne-o putem face din simpla lor enumerare, după cum urmează:
ü fgetc() – citeşte un caracter din fişier;
ü fgets() – citeşte un şir de caractere dintr-un fişier;
ü fgetcsv() – citeşte dintr-un fişier şiruri de caractere delimitate
printr-un caracter precizat ca delimitator şi le memorează într-un
tablou. Dacă nu se precizează un astfel de delimitator, se consideră
implicit ca delimitator, virgula. De altfel, numele funcţiei conţine
şirul csv (comma separated value), adică valori separate prin
virgulă;
ü fgetss() – citeşte un şir de caracter dintr-un fişier ignorând tag-
urile HTML şi PHP;
ü readfile() – citeşte un fişier şi-i afişează conţinutul în fereastra
browserului web;
ü file() – citeşte un fişier într-o matrice. Liniile fişierului sunt
memorate ca linii într-o matrice întoarsă de funcţia file();
ü file_get_contents() – citeşte conţinutul unui fişier şi-l întoarce
ca un şir de caractere.
217
Programarea în PHP
Deosebit de utilă pentru citirea corectă a datelor din fişier este

funcţia feof(). Uzual, funcţia detectează sfîrşitul fişierului. Sintaxa
funcţiei este următoarea:
bool feof(pointer_fisier);
unde pointer_fisier este pointerul fişierului din care se citeşte.
Funcţia întoarce valoarea True dacă s-a atins sfârşitul fişierului sau a
apărut o eroare, şi False în caz contrar.
În continuare vom face o descriere mai amănunţită a funcţiilor de
citire din fişiere, însoţită de exemple.
12.3.1. Funcţia fgetc()
Funcţia citeşte un caracter din fişier. Sintaxa ei este următoarea:

string fgetc(int fp);
unde fp este pointerul fişierului returnat de funcţia fopen().
Funcţia întoarce un caracter (caracterul citit din fişier).
Scriptul 12.7.php, prezentat mai jos, citeşte fişierul caracter cu
caracter şi afişează literele mari conţinute în fişier.
Scriptul 12.7
<html>
<head>
</head>
<body>
<?php
$f=fopen('a.txt','r') or die('Nu se deschide fisierul
a.txt!');
print 'Literele mari continute in fisierul a.txt
sunt:<br>';
while (!feof($f)) {
$ch=fgetc($f);
if ('A'<=$ch && $ch<='Z') {
print $ch.' ';
}
}
fclose($f);
?>
</body>
</html>
218
Pentru exemplificare, considerăm că fişierul a.txt conţine

rezultatele execuţiei scriptului 12.2.php, Rezultatul execuţiei scriptului
12.7.php este următorul:
Literele mari continute in fisierul a.txt sunt:
A C E G U G
Prezentăm mai jos scripturile 12.8.php şi 12.9.php, care reprezintă
două variante ale scriptului 12.7.php care nu utilizează însă funcţia
feof().
Scriptul 12.8
<html>
<head>
</head>
<body>
<?php
a.txt!');
sunt:<br>';
$ch=fgetc($f);
while ($ch!==false) {
if ('A'<=$ch && $ch<='Z') {
print $ch.' ';
}
$ch=fgetc($f);
}
fclose($f);
?>
</body>
</html>
Scriptul 12.9
<html>
<html>
<head>
</head>
<body
<?php
a.txt!');
219
Programarea în PHP

sunt:<br>';
while (($ch=fgetc($f))!==false) {
if ('A'<=$ch && $ch<='Z') {
print $ch.' ';
}
}
fclose($f);
?>
</body>
</html>
Rezultatul execuţiei fiecăruia din scripturile 12.8.php şi 12.9.php

este, aşa cum este de aşteptat, următorul:
A C E G U G
Observaţie. Se observă faptul că în ambele variante, pentru

depistarea corectă a sfârşitului de fişier a fost folosit operatorul !== şi nu
!= . Într-adevăr, dacă în oricare din scripturile 12.8.php sau 12.9.php vom
înlocui operatorul !== prin != rezultatul execuţiei lor va fi
A C E G U
Explicaţia rezultatului este simplă! Operatorul != testează numai
egalitatea valorilor operanzilor, nu şi a tipurilor de date ale acestora. Din
acest motiv, când caracterul citit de funcţia fgetc() este 0 (zero) sau şirul
vid ( ’’) expresia ($ch!==false) are valoarea False în timp ce
expresia ($ch!=false) are valoarea True, fapt ce determină oprirea
ciclului while. În situaţia de faţă, folosirea operatorului != are ca efect
oprirea citirii fişierului a.txt atunci când se întâlneşte prima cifra 0 de pe
linia U0546Gjjj. Cu alte cuvinte, utilizarea operatorului !=, în acest caz,
nu produce depistarea corectă a sfârşitului de fişier.
12.3.2. Funcţia fgets()
Funcţia fgets() citeşte un şir de caractere dintr-un fişier. Funcţia

are următoarea sintaxă:
string fgets(int fp, int ls);
220
unde:
ü fp – reprezintă pointerul fişierului returnat de funcţita fopen();
ü ls – este un argument operaţional care indică lungimea şirului citit
de funcţia fgets(), şi anume maxim ls-1 caractere. Dacă
argumentul ls lipseşte, se citesc toate caracterele până se atinge
sfârşitul liniei sau sfârşitul fişierului.
În general, după ce se apelează funcţia, citirea caracterelor se opreşte
când este îndeplinită una din condiţiile:
ü s-au citit ls-1 caractere;
ü s-a atins sfârşitul fişierului;
ü s-a atins sfârşitul de linie.
În caz de eroare funcţia returnează valoarea False.
Exemplu. Dacă fişierul a.txt conţine şirul abcdefghijklmn, atunci
execuţia scriptului 12.10.php, va afişa următorul rezultat:
abcd
efgh
ijkl
mn
Scriptul 12.10
<html>
<head>
</head>
<body
<?php
$f=fopen('a.txt','r') or die('Nu se poate deschide
fisierul!');
$ls=5;
echo "<br>";
while (!feof($f)) {
$rind=fgets($f,$ls);
print $rind.'<br>';
}
fclose($f);
?>
</body>
</html>
221
Programarea în PHP
După cum se poate observa, la fiecare citire se vor citi maxim

5-1=4 caractere (adică maxim 4 octeţi).
12.3.3. Funcţia fgetcsv()
Funcţia fgetcsv() citeşte dintr-un fişier şiruri de caractere

delimitate printr-un caracter precizat ca delimitator şi le memorează într-un
tablou. Sintaxa funcţiei este următoarea:
array fgetcsv(int fp, int lg, string delimitator);
unde:
ü fp – este pointerul fişierului din care se citeşte;
ü lg – este un parametru opţional care indică faptul că se citesc lg-
1 octeţi. Dacă argumentul lg lipseşte, se citesc toate caracterele
până se atinge sfârşitul liniei sau sfârşitul fişierului;
ü delimitator – este un parametru opţional (un caracter) care
delimitează şirurile de caractere ce vor fi memorate ca linii în
tabloul întors de funcţia fgetcsv(); delimitatorul implicit este
virgula.
Observaţie. Modul de execuţie al funcţiei fgetcsv() este similar

modului de execuţie al funcţiei fgets(), cu singura deosebire că funcţia
fgetcsv() returnează şirurile delimitate de delimitator în liniile unui
tablou unidimensional.
Exemplu. Execuţia scriptului 12.11.php ilustrează modul în care
lucrează funcţia fgetcsv().
Scriptul 12.11
<html>
<head>
</head>
<body
<?php
fisierul!');
$linie=fgetcsv($f);
for ($i=0; $i<count($linie); $i++) {
print $linie[$i].'<br>';
}
222

$linie=fgetcsv($f,7);
}
fclose($f);
?>
</body>
</html>
Presupunând că datele de intrare conţinute în fişierul a.txt sunt

următoarele:
Luni,Marti,Miercuri
Joi,Vineri,Sambata,Duminica
execuţia scriptului 12.11.php va avea următorul rezultat:

Luni
Marti
Miercuri
Joi
Vin
Observaţii
ü În urma execuţiei instrucţiunii
$linie=fgetcsv($f);
se va citi din fişier prima linie, adică şirul Luni,Marti,Miercuri,
iar şirurile delimitate de virgulă se vor memora în vectorul $linie după
cum urmează:
$linie[0]= 'Luni'
$linie[1]= 'Marti'
$linie[2]= 'Miercuri'
ü În urma execuţiei instrucţiunii
$linie=fgetcsv($f,7);
se vor citi din fişier primii 7-1=6 octeţi. Astfel, primii 3 octeţi (echivalenţi
şirului Joi) vor fi memoraţi în $linie[0], iar următorii 3 octeţi
(echivalenţi şirului Vin) vor fi memoraţi în $linie[1].
Dacă se doreşte pur şi simplu afişarea şirurilor delimitate de

delimitatorul virgulă, se poate alege implementarea făcută în scriptul
12.12.php.
223
Programarea în PHP
Scriptul 12.12
<html>
<head>
</head>
<body<?php
fisierul');
while ($linie=fgetcsv($f)) {
}
}
fclose($f);
?>
</body>
</html>

Luni
Marti
Miercuri
Joi
Vineri
Sambata
Duminica
12.3.4. Funcţia fgetss()
Funcţia fgetss() citeşte un şir de caractere dintr-un fişier ignorând

tag-urile HTML şi PHP. Sintaxa funcţiei este următoarea:
string fgetss(int fp, int lg, string tgpermise);
unde:
ü fp – este pointerul fişierului din care se citeşte;
ü lg – este un parametru opţional care arată că se citesc maxim lg-1
octeţi;
ü tgpermise – este un parametru opţional care arată tagurile care
sunt permise.
În cazul în care este prezent argumentul opţional tgpermise,
tagurile precizate aici nu vor fi eliminate. Exceptând faptul că ignoră tag-
224
urile HTML şi PHP, funcţia fgetss() are un comportament identic cu cel

al funcţiei fgets().
Exemplu. Scriptul 12.13.php citeşte toate caracterele fişierului
p17.php, ignorând toate tagurile sale HTML. Mai jos, prezentăm scriptul
12.13.php şi fişierul p17.php.
Scriptul 12.13
<html>
<head>
</head>
<body
<?php
$f=fopen('p17.php','r') or die('Nu se poate deschide
fisierul!');
while (!feof($f)) {
$rind=fgetss($f,filesize('p17.php'));
print $rind.'<br>';
}
fclose($f);
?>
</body>
</html>
Fişierul p17.php
<html>
<head>
<title> formular.html</title>
</head>
<body>
<form action="P18.php" method ="POST" >
<b>x=</b><input type="text" name="x" size="3"> <br>
<input type="submit" name="Trimite" value ="Trimite datele
de intrare">
</form>
</body>
</html>

formular.html
x=
y=
225
Programarea în PHP
Dacă se doreşte păstrarea afişării bolduite a variabilelor x şi y, atunci

se va adăuga ca parametru pentru funcţia fgets(), parametrul '<b>', ca
în scriptul 12.14.php, listat mai jos.
Scriptul 12.14
<html>
<head>
</head>
<body
<?php
$f=fopen('p17.php','r') or die('Nu se deschide');
While (!feof($f)) {
$rind=fgetss($f,filesize('p17.php'),'<b>');
print $rind.'<br>';
}
fclose($f);
?>
</body>
</html>

formular.html
x=
y=
ultimele două rânduri fiind bolduite.
12.3.5. Funcţiile readfile(), file() şi

file_get_contents()
În cele ce urmează, prezentăm funcţiile readfile(), file() şi

file_get_contents() care citesc tot conţinutul unui fişier într-un
singur pas. Aceste funcţii simplifică mult citirea dintr-un fişier, deoarece
efectuează implicit şi operaţiile de deschidere şi închidere a fişierului. În
exemplele care urmează folosim ca fişier de citire fişierul a.txt, cu
următorul conţinut:
Luni,Marti,Miercuri
226
Funcţia readfile() citeşte conţinutul unui fişier şi-l afişează în

fereastra browserului web.
int readfile (string nume_fisier);
Funcţia întoarce numărul de octeţi citiţi din fişier. În caz de eroare
este întoarsă valoarea False.
Exemplu. Scriptul 12.15.php, prezentat mai jos, citeşte şi afişează

conţinutul fişierului a.txt pe ecran.
Scriptul 12.15
<html>
<head>
</head>
<body
<?php
print 'Exemplu de citire a unui fisier cu functia
readfile()';
print '<br>Continutul fisierului a.txt este:<br>';
readfile('a.txt');
?>
</body>
</html>

Exemplu de citire a unui fisier cu functia readfile()
Continutul fisierului a.txt este:
Luni,Marti,Miercuri Joi,Vineri,Sambata,Duminica
Funcţia file() citeşte succesiv liniile unui fişier şi le memoreză într-
un vector. Reamintim faptul că sfârşitul unei linii este marcat prin simbolul
rand nou, adică, \n în Unix şi \r\n în Windows. Sintaxa funcţiei este
următoarea:
array file (string nume_fisier);
Funcţia întoarce un vector în care primul element conţine prima linie
din fişier, al doilea element conţine a doua linie din fişier etc. Pentru
exemplificarea modului de lucru al acestei funcţii prezentăm mai jos
scriptul 12.16.php.
227
Programarea în PHP
Scriptul 12.16
<html>
<head>
</head>
<body
<?php
$fisier=file('a.txt');
print 'Exemplu de citirea unui fisier cu functia file()';
print '<br>Continutul fisierului a.txt este:<br>';
for ($i=0; $i<count($fisier); $i++) {
print "<br>$fisier[$i]";
}
?>
</body>
</html>
Execuţia scriptului 12.16.php are ca efect crearea vectorului $fisier

cu componentele
$fisier[0]= 'Luni,Marti,Miercuri'
$fisier[1]= ' Joi,Vineri,Sambata,Duminica'
şi afişarea următorului rezultat:
Exemplu de citire a unui fisier cu functia file()
Luni,Marti,Miercuri
Funcţia file_get_contents() citeşte conţinutul unui fişier şi-l întoarce

ca un şir de caractere. Aşa cum s-a mai spus, apelul funcţiei înseamnă
implicit deschiderea fişierului, citirea conţinutului acestuia şi închiderea
fişierului.
string file_get_contents(string nume_fisier);
Scriptul 12.17.php citeşte conţinutul fişierului a.txt cu ajutorul
funcţiei file_get_contents() şi-l afişează în fereastra browserului.
Scriptul 12.17
<html>
<head>
</head>
<body>
<?php
228

$fisier=file_get_contents('a.txt');
print 'Exemplu de citire a unui fisier cu functia
file_get_contents()';
print '<br>Continutul fisierului a.txt este:<br>'.$fisier;
?>
</body>
</html
Rezultatele execuţiei scriptului 12.17.php sunt:

Exemplu de citire a unui fisier cu functia
file_get_contents()
Luni,Marti,Miercuri Joi,Vineri,Sambata,Duminica
12.4. Funcţii care permit testarea

stării unui fişier
Limbajul PHP are un set de funcţii care permit testarea stării unui
fişier. În cele ce urmează prezentăm pe scurt funcţiile: file_exists(),
is_file(), is_dir(), is_readable(), is_writeable(),
filesize(). În sintaxa acestor funcţii se utilizează parametrul
nume_fisier care reprezintă numele fişierului sau al directorului vizat,
identificat printr-o cale absolută sau relativă.
12.4.1. Funcţia file_exists()
Funcţia file_exists() verifică existenţa unui fişier sau director.

bool file_exists(string nume_fisier);
Funcţia returnează valoarea True dacă fişierul sau directorul este
găsit, iar în caz contrar valoarea False.
229
Programarea în PHP
12.4.2. Funcţiile is_file() şi is_dir()
Funcţiiile is_file() şi is_dir() se aplică unui parametru care

poate reprezenta un nume de fişier sau un nume de director. Sintaxa
funcţiilor este următoarea:
bool is_file(string nume de fisier sau director);
bool is_dir(string nume de fisier sau director);
Funcţiile returnează valoarea False dacă parametru nu este nume de
fişier sau de director. Aceeaşi valoare, False, se afişează dacă parametrul
funcţiei is_file() reprezintă un director sau dacă parametrul funcţiei
is_dir() reprezintă un fişier. În rest, ambele funcţii întorc valoarea
True.
12.4.3. Funcţiile is_readable(),

is_writable() şi is_executable()
Aceste trei funcţii verifică dacă un fişier există şi, în caz afirmativ
dacă poate fi citit (is_readable), dacă se poate scrie în el
(is_writable) sau dacă este executabil (is_executable).
Sintaxa celor trei funcţii enunţate în titlu este:
bool is_readable(string nume-fisier);
bool is_writable(string nume-fisier);
bool is_executable(string nume-fisier);
Funcţiile is_readable()/is_writable()/is_executable()
returnează valoarea True dacă fişierul există şi dacă este permisă
citirea/scrierea/executarea lui. În caz contrar returnează valoarea False.
12.4.4. Funcţia filesize()
Funcţia filesize() permite aflarea dimensiunii unui fişier.

int filesize(string nume_fisier);
În mod normal funcţia filesize() aplicată fişierului
nume_fisier întoarce dimensiunea sa în octeţi. În caz de eroare funcţia
întoarce False.
230
Scriptul 12.18.php ilustreaza modul de folosire al acestor funcţii în

cazul unui fişier al cărui nume este transmis de la tastatură cu ajutorul unui
formular.
Scriptul 12.18
<html>
<head>
</head>
<body>
<?php
$fisier=trim($_POST['x']);
if (!file_exists($fisier)) {
print '<p>Fisierul '. $fisier.' nu exista </p>';
exit();
} else {
print '<p>Fisierul '. $fisier.' exista </p>';
}
if (is_file($fisier)) {
print '<p>Fisierul '. $fisier.' este fisier </p>';
} else {
print '<p>Fisierul '. $fisier.' nu este fisier
</p>';
}
if (is_dir($fisier)) {
print '<p>Fisierul '. $fisier.' este director </p>';
} else {
print '<p>Fisierul '. $fisier.' nu este director
</p>';
}
if (is_readable($fisier)) {
print '<p>Fisierul '. $fisier.' se poate citi </p>';
} else {
print '<p>Fisierul '. $fisier.' nu se poate citi
</p>';
}
if (is_writeable($fisier)) {
print '<p>In fisierul '. $fisier.' se poate scrie
</p>';
} else {
print '<p>In fisierul '. $fisier.'nu se poate scrie
</p>';
}
print '<p>Fisierul '. $fisier.' are '.filesize($fisier).
' octeti </p>';
exit();
231
Programarea în PHP

}
?>
<br><form action="<?php echo $_SERVER[PHP_SELF]?>" method
="POST" >
<br>Nume fisier:<input type="text" name="x" value =""
size="20">
numele fisierului">
</form>
</body>
</html>
Dacă numele fişierului transmis către scriptul 12.8.php este a.txt,

atunci, rezultatul execuţiei acestui script este:
Fisierul a.txt exista
Fisierul a.txt este fisier
Fisierul a.txt nu este director
Fisierul a.txt se poate citi
In fisierul a.txt se poate scrie
Fisierul a.txt are 52 octeti
12.5. Funcţia include()
Instrucţiunea include() permite includerea unui fişier în fişierul

unde este apelată. Deşi are aspectul unei funcţii ea este de fapt o
construcţie de limbaj (cum este de exemplu echo).
Sintaxa instrucţiunii este :
include ('nume_fisier');
unde nume_fisier este numele fişierului inclus. Instrucţiunea poate

returna un rezultat al prelucrărilor din fişierul nume_fisier. Acest lucru
se poate întâmpla numai dacă în codul care se include există o instrucţiune
return sub forma: return rezultat;
Porţiunile de cod existente după instrucţiunea return nu vor mai fi
incluse în fişierul principal.
O instrucţiuni similară cu instrucţiunea include() este
require(). Există însă o deosebire între ele: eşecul execuţiei instrucţiunii
include() produce doar un avertisment fără a se întrerupe execuţia
232
scriptului, în timp ce orice eroare apare în execuţia instrucţiunii

require() provoacă încetarea execuţiei scriptului. Variantele
include_once(), respectiv require_once() ale celor două
instrucţiuni, nu permit (aşa cum arată şi numele lor) decât o singură
includere a fişierului apelat de ele, chiar dacă pe parcursul execuţiei unui
script se fac mai multe astfel de apeluri. Cu alte cuvinte, dacă fişierul este
deja inclus, el nu va mai fi inclus încă o dată.
Observaţii
ü În locul apostrofurilor se pot folosi şi ghilimele, iar parantezele
rotunde pot lipsi;
ü Referirea la nume_fisier se poate se poate face utilizând căi
absolute sau relative.
Prezentăm mai jos un exemplu de utilizare al istrucţiunii

include() în care fişierul pe care dorim să-l includem este accesat
folosind o cale absolută (în sistemul de operare Windows):
include ('D:/wamp/www/lucru/adunare.php');
Utilizarea căilor absolute către fişierul pe care dorim să-l includem
poate crea probleme de portabilitate aplicaţiilor PHP atunci când le mutăm
pe alt server. Această problemă se poate rezolva setând corespunzător
directiva include_path din fişierul php.ini. Astfel, dacă directiva este
setată sub forma, include_path = ".; D:\wamp\www\lucru\" în
scripturi poate fi utilizată forma include('adunare.php');
Această variantă nu depinde de calea către fişierul adunare.php. În
consecinţă, dacă fişierul adunare.php este mutat pe alt server, singura
modificare ce trebuie făcută se referă la adăugarea noii căi în directiva
include_path din fişierul php.ini.
Observaţie. Directiva include_path poate conţine un număr

nedefinit de căi despărţite prin punct şi virgulă (în Windows) sau prin două
puncte (în Unix). Punctul care apare în exemplul de directivă
include_path de mai sus se referă la directorul curent.
233
Programarea în PHP
Calea relativă către fişierul pe care dorim să-l includem se defineşte

în raport cu fişierul în care dorim să includem, numit în continuare, pentru
uşurinţa exprimării, fişier principal. Astfel, plecând de la exemplul anterior,
dacă atât fişierul principal cât şi fişierul adunare.php, pe care dorim să-l
includem, se află în directorul lucru, instrucţiunea include de mai sus se
poate scrie echivalent:
include ('adunare.php'); sau
include ('./adunare.php');
Dacă directorul părinte al fişierului principal include un director, să-i
zicem test, care include fişierul adunare.php, atunci instrucţiunea de
includere se poate scrie sub forma:
include('test/adunare.php');
Fişierul care se include poate conţine funcţii sau pur şi simplu
porţiuni de cod comune scripturilor unei aplicaţii. Orice modificare în acest
fişier este disponibilă în toare scripturile în care va fi inclus fapt ce
eficientizează activitatea de programare şi permite crearea unor aplicaţii
lizibile.
Exemplu. Analizând scripturile 11.11.php, 11.12.php, 11.13.php şi
11.14.php se constată foarte uşor că partea de script care formează meniul
este comună. Această parte poate fi organizată sub forma unui fişier numit
12.23.php care va fi inclus în fiecare din cele patru scripturi enumerate mai
sus redenumite 12.19.php, 12.20.php, 12.21.php şi respectiv 12.22.php.
Scriptul 12.19
<?php
session_start();
?>
<html>
<head>
</head>
<body>
<?php
$_SESSION['traseu'][]='A ';
include '12.23.php';
?>
</body>
</html
234
Scriptul 12.20
<?php
session_start();
?>
<html>
<head>
</head>
<body>
<?php
$_SESSION['traseu'][]='B ';
?>
</body>
</html>
Scriptul 12.21
<?php
session_start();
?>
<html>
<head>
</head>
<body>
<?php
$_SESSION['traseu'][]='C ';
?>
</body>
</html>
Scriptul 12.22
<?php
session_start();
$n=count($_SESSION['traseu']);
?>
<html>
<head>
235
Programarea în PHP

</head>
<body>
<?php
for ($i=0;$i<$n;$i++) {
print $_SESSION['traseu'][$i];
}
unset($_SESSION['traseu']);
session_destroy();
?>
</body>
</html>
Scriptul 12.23
<?php
print '<p> <a href= "12.20.php">B</a> </p>';
print '<p> <a href= "12.22.php">TraseuSesiune.php</a></p>';
?>
Observaţii. Execuţia codului PHP dintr-un fişier inclus este posibilă

numai dacă acesta este încadrat de marcajele standard <?php şi ?> sau
echivalentele lor. Lipsa acestora are ca efect tratarea codului PHP ca un
text.
De exemplu, după lansarea în execuţie a scriptului 12.24.php mesajul
afişat va fi instrucţiunea echo 'Acesta este un test!'; din
scriptul 12.25.php.
Scriptul 12.24
<html>
<head>
</head>
<body>
<?php
?>
236

</body>
</html>
</html>
Scriptul 12.25
<html>
<head>
</head>
<body>
echo 'Acesta este un test!';
</body>
</html>
</html>
Dacă în scriptul 12.25.php vom încadra instrucţiunea

echo 'Acesta este un test!';
între marcajele <?php şi ?> şi vom salva şi relansa în execuţie scriptul
12.24.php , mesajul afişat va fi: Acesta este un test!
Aşa cum s-a precizat la prezentarea sintaxei sale, instrucţiunea
include() poate returna o valoare, întocmai ca o funcţie. Spre exemplu,
scriptul 12.26.php afişează valoarea 21 întoarsă de instrucţiunea
$z=include'12.27.php';,care include fişierul 12.27.php în scriptul
12.26.php.
Scriptul 12.26
<html>
<head>
</head>
<body>
<?php
$z=include '12.27.php';
echo "Valoarea returnata este $z";
?>
</body>
</html>
237
Programarea în PHP
Scriptul 12.27
<html>
<head>
</head>
<body>
<?php
$x=3;
$y=7;
return $x*$y;
?>
</body>
</html>
238
P H P
Capitolul 13
13. Directoare
Limbajul PHP permite folosirea unui set de funcţii pentru
manipularea directoarelor. Prezentăm în continuare câteva astfel de funcţii
(secţiunile 13.1-13.9) şi exemple de utilizare a lor (scripturile 13.1, 13.2 şi
13.3). De asemenea, în secţiunea 13.10 sunt prezentate două aplicaţii care
utilizează funcţii de lucru cu fişiere şi directoare.
13.1. Funcţia opendir() pentru

deschiderea unui director
Una din variantele de deschidere a unui director, în vederea realizării

unor prelucrări este utilizarea funcţiei opendir(). Sintaxa funcţiei
opendir() este:
int opendir(string cale);
unde cale reprezintă calea către directorul care va fi deschis. Funcţia
returnează False în caz de insucces, iar în caz de succes o valoare care va
fi folosită de alte funcţii de lucru cu directoarele.
Exemplu. În urma execuţiei secvenţei de program
$dirname = "D:/wamp/www/lucru";
$dp = opendir( $dirname );
239
Programarea în PHP
pot apărea două situaţii:

ü directorul indicat de variabila $dirname există şi se poate deschide;
ü directorul indicat de variabila $dirname nu există sau nu se poate
deschide.
În prima situaţie, variabilei $dirname i se atribuie o valoare de tip
manipulator de directoare, care va putea fi folosită de alte funcţii de lucru
cu directoarele.
În a doua situaţie, funcţia opendir() va întoarce valoarea False şi
execuţia secvenţei de program se opreşte.
13.2. Funcţia readdir() pentru citirea

dintr-un director
Funcţia readdir() permite citirea numelor de fişiere sau de

directoare dintr-un director precizat. Precizarea directorului se face cu
ajutorul valorii manipulator de directoare returnate de funcţia opendir().
string readdir(int manipulator_dir);
unde manipulator_dir indică valoarea întoarsă de funcţia opendir().
În caz de succes, funcţia întoarce numele fişierului sau al directorului
citit. În caz de insucces (manipulator de directoare invalid sau sfârşit de
director) funcţia va întoarce valoarea False.
13.3. Funcţia closedir() pentru

închiderea unui director
Efectul execuţiei funcţiei closedir() constă în închiderea

directorului indicat de manipulator_dir.
void closedir(int manipulator_dir);
unde manipulator_dir precizează valoarea întoarsă de funcţia
opendir().
240
Capitolul 13. Directoare
13.4. Funcţia rewinddir() pentru

poziţionarea la începutul
directorului
Efectul execuţiei funcţiei rewinddir() constă în plasarea

pointerului de director la începutul directorului.
void rewinddir(int manipulator_dir);
unde manipulator_dir precizează valoarea întoarsă de funcţia
opendir().
Un exemplu de utilizare a funcţiilor opendir(), readdir(),
rewinddir() şi closedir() este prezentat mai jos (scriptul 13.1.php).
Scriptul 13.1
<html>
<head>
</head>
<body>
<?
$dirname = "D:/wamp/www/lucru/10-Fisiere si directoare";
$dp = opendir($dirname);
$ora=12;
$min=16;
$sec=43;
$luna=6;
$ziua=15;
$anul=2009;
$data_limita_stamp=mktime($ora,$min,$sec,$luna,$ziua,$anul)
;
$data_limita=date("m/d/y G.i:s",$data_limita_stamp);
print 'Fisiere si directore care au fost accesate ultima
oara inainte de '.$data_limita.'<br>';
while (($fis=readDir($dp))!==false) {
if (($fis != '.') && ($fis != '..')) {
$ultimacces_stamp=fileatime($dirname.'/'.$fis);
$ultimacces=date("m/d/y G.i:s",
$ultimacces_stamp);
if ($ultimacces_stamp < $data_limita_stamp) {
print $fis.'<br>';
}
}
241
Programarea în PHP

}
rewinddir($dp);
print 'Fisiere si directore care au fost accesate ultima
oara dupa data de '.$data_limita.'<br>';
while (($fis=readDir($dp))!==false) {
if (($fis != '.') && ($fis!= '..')) {
$ultimacces_stamp=fileatime($dirname.'/'.$fis);
$ultimacces=date("m/d/y G.i:s",$ultimacces_stamp);
if ($ultimacces_stamp>=$data_limita_stamp) {
print $fis.'<br>';
}
}
}
closedir($dp);
?>
</body>
</html>
Scriptul 13.1.php citeşte dintr-un director fişierele şi subdirectoarele

şi afişează două liste: o listă cu fişierele şi subdirectoarele accesate ultima
oară înainte de o anumită dată de referinţă şi o listă cu fişierele şi
subdirectoarele accesate ultima oară, după respectiva dată. Data de referinţă
care departajează cele două liste este memorată în variabila
$data_limita. Directorul dorit este deschis cu ajutorul funcţiei
opendir() şi închis după realizarea prelucrărilor, cu ajutorul funcţiei
closedir(). Fiecare din cele două liste este realizată prin parcurgerea
secvenţială a directorului, folosind instrucţiunea while şi funcţia
readdir(). Deschiderea directorului cu ajutorul funcţiei opendir()
realizează şi poziţionarea pointerului de director $dp la începutul
directorului. După prima parcurgere a directorului, pointerul de director
$dp va indica sfârşitul directorului. Repoziţionarea pointerului de director
la începutul directorului, cu scopul realizării unei noi parcurgeri, se
realizează cu instrucţiunea rewinddir($dp).
Observaţii
ü O alternativă mai puţin sigură la construcţia
while(($fis=readDir($dp))!==false)
este
while($fis=readdir($dp)).
242
Nesiguranţa celei de-a doua variante rezultă din faptul că bucla

while se opreşte dacă un fişier sau un subdirector citit are drept nume cifra
0. În acest caz, expresia
($fis=readdir($dp))
va fi asimilată cu valoarea False.
În varianta folosită în script, în cazul citirii unui nume de fişier sau
subdirector egal cu 0 bucla while nu se opreşte; valoarea False returnată
în acest caz nu este identică cu valoarea False pe care o returnează funcţia
readdir() când întâlneşte sfârşitul de director. Astfel, folosirea
operatorului !== care ia în calcul verificarea valorii, dar şi a identităţii ca
tip a operanzilor, permite ieşirea din bucla while, numai dacă s-a atins
sfârşitul directorului.
ü Am folosit instrucţiunea
if(($fis != '.') && ($fis!= '..'))
pentru a evita afişarea numelor de fişier ascunse (de exemplu, fişierul notat
cu un punct este directorul curent, iar fişierul notat cu două puncte este
directorul părinte).
ü Funcţia readdir() întoarce doar numele fişierului sau
subdirectorului întâlnit. Deoarece funcţia fileatime() (ca de altfel şi
alte funcţii care lucrează cu fişiere şi directoare) au nevoie să primească ca
argument calea completă către un fişier sau director şi nu doar numele
acestora, a fost necesară concatenarea căii complete a directorului
prelucrat, cu numele fişierului citit, sub forma: $dirname.'/'.$fis.
13.5. Funcţia mkdir() de creare a

directoarelor
Funcţia mkdir() permite crearea unui director. Opţiunile de bază

ale funcţiei sunt prezentate în sintaxa de mai jos
bool mkdir(string cale, int mod);
unde:
ü cale este un argument obligatoriu care arată calea către
directorul care va fi creat;
ü mod este un argument opţional care indică drepturile de acces la
fişierele din cadrul directorului nou creat.
243
Programarea în PHP
Pe sistemul de operare Windows, informaţia conţinută în parametrul

mod este ignorată. Dacă parametrul mod lipseşte, atunci se consideră
implicit că mod are valoarea (în octal) 0777, care înseamnă cel mai larg
acces posibil.
Funcţia întoarce True când directorul a fost creat şi False în caz
contrar.
13.6. Funcţia chdir() de schimbare a

directorului curent
Sintaxa funcţiei chdir() este următoarea:

bool chdir(string director);
unde director este un parametru obligatoriu care precizează noul
director curent.
Funcţia întoarce valoarea True dacă operaţia de schimbare a
directorului curent a avut succes şi False în caz contrar.
13.7. Funcţia getcwd() care indică

directorul curent
Sintaxa funcţiei getcwd() este următoarea:

string getcwd(void);
În caz de succes funcţia întoarce numele directorului curent, iar în
caz contrar întoarce valoarea False.
13.8. Funcţia rmdir() de ştergere a

unui director
Sintaxa de bază (fără opţiuni) a funcţiei rmdir() este

bool rmdir(string director);
244
unde director este parametru obligatoriu care precizează directorul care va

fi şters. Funcţia întoarce valoarea True în caz de succes şi valoarea False
în caz contrar.
Directorul poate fi şters numai dacă conţinutul său este vid.
Modul de lucrul al ultimilor patru funcţii prezentate (mkdir(),
chdir(), getcwd(), rmdir()) este ilustrat în scriptul 13.2.php.
Scriptul 13.2
<html>
<head>
</head>
<body>
<?
$dirnou="D:/wamp/www/lucru/10-Fisiere si directoare/index";
if ($_POST['trimite']) {
if ($_POST['x']=='c') {
if (!(file_exists($dirnou))) {
if (mkdir($dirnou)) {
print "Directorul $dirnou a fost creat! <br>";
} else {
print "Directorul $dirnou nu se poate crea!";
exit();
}
} else {
print "Directorul $dirnou deja exista!<br> " ;
}
chdir($dirnou);
echo 'Directorul curent este '.getcwd().'<br>';
if ($fp = fopen("FisierIndex.html", "w")) {
while (($fis=readdir($dp)) !== false) {
$extensie = substr(strrchr($fis, "."), 1);
if (!(strcmp($extensie, "php"))) {
$output='<a ref="'.'http://localhost/lucru/'.
$fis.'">'.$fis.'</a><br>';
fputs ($fp, $output);
}
}
fclose($fp);
print "Fisierul FisierIndex.html a fost creat!<br>";
} else {
print "Fisierul FisierIndex.html nu se poate crea!
;<br>";
}
245
Programarea în PHP

closedir($dp);
} else {
$fisier=$dirnou.'/'.'FisierIndex.html';
if (file_exists( $fisier)) {
if (unlink($fisier)) {
print "Fisierul $fisier a fost sters!<br>";
} else {
print "Fisierul $fisier nu se poate sterge!
<br>";
}
} else {
print "Fisierul $fisier nu exista!<br>";
}
if (file_exists( $dirnou)) {
if (rmdir($dirnou)) {
print "Directorul $dirnou a fost sters!<br>";
} else {
print "Directorul $dirnou nu se poate
sterge!<br>";
}
} else {
print "Directorul $dirnou nu exista!<br>";
}
}
} else {
print '<form action="13.2.php" method ="POST" >
Creeaza director(c)/Sterge director(s):<input
type="text" name="x" value ="c" size="1">
<br><input type="submit" name="trimite" value =
"Trimite">
</form>';
}
?>
</body>
</html>
După lansarea în execuţie, scriptul 13.2.php afişează formularul:
c
Creeaza director(c)/Sterge director(s):
Trimite
Cu ajutorul acestui formular, utilizatorul poate alege una din cele

două opţiuni:
246
ü Creeaza director – se tastează c

ü Sterge director – se tastează s
Dacă se alege opţiunea c:

ü se încearcă crearea unui director nou utilizând funcţia mkdir();
ü în caz de succes se foloseşte funcţia chdir() pentru a se preciza
faptul că directorul nou creat este directorul curent;
ü se obţine directorul curent, folosind funcţia getcwd(), şi se
afişează;
ü se încearcă crearea fişierului FisierIndex.html în interiorul
directorului nou creat. Dacă operaţia reuşeşte, se va scrie în el
numele fişierelor cu extensia .php, din vechiul director. Numele
acestor fişiere sunt de fapt link-uri care permit, printr-un simplu
click, lansarea în execuţie a programului respectiv (se obţine un
index de fişiere);
ü dacă totul decurge normal conţinutul fişierului FisierIndex.html ar
trebui să arate asemănător cu ceea ce este prezentat mai jos:
Afisare.php
body.php
Copy of 21.php
Creare catalog.php
dirsort.php
fincluscorect.php
finclusincorect.php
fis write.php
fisdir.php
fisfile.php
fisfile_put-contents.php
fisgetc.php
fisgetcsv.php
fisgets.php
fisgetss.php
fisiercareinclude.php
fisread.php
fistarefisier.php
fistestfunctii.php
fisupload.php
247
Programarea în PHP
Dacă se alege opţiunea s:

ü se verifică dacă nu cumva atât directorul nou creat cât şi fişierul
FisierIndex.html au fost deja şterse;
ü dacă nu au fost şterse, se încearcă ştergerea fişierului FisIndex.html
şi apoi a directorului nou creat;
ü rezultatele încercărilor de a şterge directorul nou creat cât şi fişierul
FisierIndex.html sunt afişate în browser.
13.9. Funcţia scandir() pentru

deschiderea, citirea şi închiderea
unui director
Funcţia scandir() înlocuieşte secvenţa opendir(), readdir(),

closedir() folosită pentru citirea unui director.
O parte din opţiunile funcţiei sunt prezentate în sintaxa:
array scandir(string director, int mod_sortare);
unde:
ü director este un argument obligatoriu, care indică numele
directorului ce va fi prelucrat;
ü mod_sortare este un argument de tip întreg opţional, care arată
modul în care va fi sortată lista de fişiere din directorul vizat:
ü în ordine alfabetică crescătoare, dacă argumentul lipseşte sau
este egal cu SCANDIR_SORT_ASCENDING;
ü în ordine alfabetică descrescătoare, dacă argumentul are
valoarea SCANDIR_SORT_DESCENDING;
ü nesortat, dacă argumentul are valoarea
SCANDIR_SORT_DESCENDING.
Funcţia întoarce un vector ale cărui componente sunt numele de
fişiere şi de directoare conţinute în directorul precizat de primul argument.
Observaţie. Se observă o analogie puternică între funcţia
scandir() şi funcţia file() folosită la fişiere:
248
ü funcţia file() deschide, citeşte conţinutul unui fişier şi-l

închide, iar funcţia scandir() deschide, citeşte conţinutul unui
director şi-l închide;
ü atât funcţia file() cât şi funcţia scandir() întorc informaţia
citită într-un vector; în plus faţă de funcţia file(), funcţia
scandir() sortează vectorul în ordine alfabetică crescătoare şi,
opţional, în ordine alfabetică descrescătoare.
Un exemplu de folosire a funcţiei scandir() este prezentat mai jos
în scriptul 13.3.php.
Scriptul 13.3
<html>
<head>
</head>
<body>
<?
$dirnou="D:/wamp/www/lucru/10-Fisiere si directoare/index";
if ($_POST['x']=='c') {
if (!(file_exists($dirnou))) {
if (mkdir($dirnou)) {
print "Directorul $dirnou a fost creat! <br>" ;
} else {
print "Directorul $dirnou nu se poate crea! " ;
exit();
}
} else {
print "Directorul $dirnou deja exista!<br> " ;
}
chdir($dirnou);
echo 'Directorul curent este '.getcwd().'<br>';
if ($fp = fopen("FisierIndex.html", "w")) {
$fisiere=scandir($dirname,1);
foreach($fisiere as $fis ){
$extensie = substr(strrchr($fis, "."), 1);
if (!(strcmp($extensie, "php"))) {
$output='<a
href="'.'http://localhost/lucru/'.$fis.'">'.$
fis.'</a><br>';
fputs ($fp, $output);
}
}
249
Programarea în PHP

fclose($fp);
print "Fisierul FisierIndex.html a fost creat!<br>";
} else {
print "Fisierul FisierIndex.html nu se poate
crea!<br>";
}
} else {
$fisier=$dirnou.'/'.'FisierIndex.html';
if (file_exists( $fisier)) {
if (unlink($fisier)) {
print "Fisierul $fisier a fost sters!<br>";
} else {
print "Fisierul $fisier nu se poate
sterge!<br>";
}
} else {
print "Fisierul $fisier nu exista!<br>";
}
if (file_exists( $dirnou)) {
if (rmdir($dirnou)) {
print "Directorul $dirnou a fost sters!<br>";
} else {
print "Directorul $dirnou nu se poate sterge!
<br>";
}
} else {
print "Directorul $dirnou nu exista!<br>";
}
}
} else {
print '<form action="13.3.php" method ="POST" >
Creaza director(c)/Sterge director(s):<input type="text"
name="x" value ="c" size="1">
<br><input type="submit" name="trimite" value
="Trimite">
</form>';
}
?>
</body>
</html>
Observaţii
ü Scriptul 13.3.php a fost obţinut prin modificarea scriptului
13.2.php. Principalele modificări se referă la înlocuirea funcţiilor
250
opendir(), readdir() şi closedir()cu funcţia

scandir().
Întregul conţinut al directorului $dirname este transferat în vectorul
$fisiere cu ajutorul secvenţei $fisiere=scandir($dirname,1);
ü Bucla while(($fis=readdir($dp))!==false)
care permitea, în scriptul 13.2.php, parcurgerea listei de nume de fişiere şi
directoare din directorul $dirname, este înlocuită în scriptul 13.3.php prin
secvenţa foreach($fisiere as $fis);
ü Bucla foreach de mai sus parcurge de data aceasta lista
sortată alfabetic a numelor de fişiere şi de directoare ale directorului
$dirname, memorată în vectorul $fisier. Deoarece parametrul care
indică modul de sortare este SCANDIR_SORT_NONE vectorul $fisiere nu
va fi sortat şi în consecinţă, nici fişierul FisierIndex.html.
13.10. Aplicaţii care utilizează

funcţii ce manipulează fişiere şi
directoare
În cele ce urmează prezentăm două aplicaţii care afişează

caracteristici ale unor fişiere sau directoare.
Aplicaţia 1. Să se construiască un script care să afişeze în browser
caracteristici ale fişierelor şi directoarelor unui director ; numele
directorului este transmis de la tastatură printr-un formular.
Soluţie. Soluţia este realizată în scriptul 13.4.php, care, după cum se
poate constata uşor, este o generalizare a scriptului 12.18.php.
Scriptul 13.4
<html>
<head>
</head>
<body>
<?php
if (isset($_POST["trimite"]) ) {
$dirname=trim($_POST['dir']);
echo getcwd() . "\n";
251
Programarea în PHP

$dp=opendir($dirname) or die(" Directorul $dirname nu se
poate deschide!");
while (($fis=readDir($dp)) !== false) {
if (($fis == '.') || ($fis == '..')) {
continue;
}
$fis="$dirname/$fis";
if (!file_exists($fis)) {
print '<p>'. $fis.' nu exista </p>';
continue;
} else {
print '<p>'.$fis.' exista </p>';
}
if (is_file($fis)) {
print '<p>'. $fis.' este fisier </p>';
} else {
print '<p>'. $fis.' nu este fisier </p>';
}
if (is_dir($fis)) {
print '<p>'. $fis.' este director </p>';
} else {
print '<p>'. $fis.' nu este director </p>';
}
if (is_readable($fis)) {
print '<p>'. $fis.' se poate citi </p>';
} else {
print '<p>'. $fis.' nu se poate citi </p>';
}
if (is_writeable($fis)) {
print '<p>in '. $fis.' se poate scrie </p>';
} else {
print '<p>in '. $fis.' nu se poate scrie ';
}
print '<p>'. $fis.' are '.filesize($fis). '
octeti';
}
exit();
}
?>
<form action="13.4.php" method ="POST" >
<br> Nume director:<input type="text" name="dir" value =""
size="20">
numele directorului">
</form>
</body>
</html>
252
Aplicaţia 2. Să se construiască un script care să afişeze caracteristici

ale fişierelor şi directoarelor dintr-un director al cărui nume este transmis
de la tastatură printr-un formular. Datele vor fi afişate într-un tabel cu
următoarea structură:
Nume Lungime Data Data ultimei

Tip
fisier/director in octeti crearii modificari
Numele coloanelor tabloului trebuie să fie link-uri, astfel încât

printr-un simplu click executat pe numele unei coloane, liniile tabloului să
fie permutate în aşa fel încât informaţia conţinută în coloana respectivă să
fie ordonată crescător.
Soluţie. Scriptul 13.5.php, prezentat mai jos, rezolvă problema
enunţată.
Scriptul 13.5
<html>
<head>
</head>
<body>
<?php
$dir="D:/wamp/www/lucru/";
$d=opendir($dir);
$k=0;
while ($fis = readdir($d)) {
$x[$k]=$fis;
$fis=$dir.'/'.$fis;
$y[$k]=filesize($fis);
$z[$k]=date('Y M d D g:i A',fileatime($fis));
$w[$k]=date('Y M d D g:i A',filemtime($fis));
$t[$k]=is_file($fis)?'f':'d';
$k++;
}
if (!isset($key)) {
$key = "x";
}
print $_GET[key];
253
Programarea în PHP

switch ($_GET[key]) {
case "x":array_multisort($x,SORT_STRING,$y,$z,$w,$t);
break;
case "y":array_multisort($y,$z,$w,$t,$x); break;
case "z":array_multisort($z,$w,$t,$x,$y); break;
case "w":array_multisort($w,$t,$x,$y,$z); break;
case "t":array_multisort($t, SORT_STRING,$x,$y,$z,$w);
break;
}
print "<table border = 1>";
print "<tr>
<th><a href=\"dirsort.php?key=x\"> Numele fisier/director
</a></th>
<th><a href=\"dirsort.php?key=y\"> Lungime fisier/director
in octeti</a></th>
<th><a href=\"dirsort.php?key=z\"> Data creerii
fisier/director </a></th>
<th><a href=\"dirsort.php?key=w\"> Data ultimei modificari
fisier/director </a></th>
<th><a href=\"dirsort.php?key=t\"> Tip(d=director/f=fisier)
</a></th></tr>";
for ($i=0; $i<count($x); $i++) {
print "<td>$x[$i]</td><td>$y[$i]</td><td>$z[$i]</td>
<td>$w[$i]</td><td>$t[$i]</td>";
print "</tr>";
}
print "</table>";
closedir($dir);
?>
</body>
</html>
Observaţii. Numele coloanei care va fi ordonată se transmite către

scriptul 135.php, manual, printr-un URL, şi va fi disponibil în script cu
ajutorul variabilei globale $_GET[]. Variabila în care se memorează
numele coloanei este key, iar coloanele sunt denumite de la stânga la
dreapta după cum urmează: x, y, z w şi respectiv t. De exemplu, dacă
dorim ca a doua coloană să apară ordonată, se va executa click pe link-ul
Lungime in octeti
Datorită construcţiei
<a href=\"dirsort.php?key=y\"> Lungime <br>
fisier/director in octeti</a>
254
valoarea y a variabilei key va fi transmisă scriptului 135.php prin

intermediul variabilei globale $_GET[key]. Cu ajutorul instrucţiunii de
selecţie switch() se selectează instrucţiunea
array_multisort($y, $z, $w, $t, $x);
a cărei execuţie va avea ca efect permutarea liniilor coloanelor memorate în
$y, $z, $w, $t, $x astfel încât, coloana ordonată să fie cea
corespunzătoare variabilei $y, adică a doua din tabel. După această
ordonare se parcurg liniile tabelului cu ajutorul instrucţiunii for şi se
afişează. Rezultatul execuţiei scriptului 13.5.php este asemănător cu
Tabelul 13.1, prezentat mai jos.
Tabelul 13.1. Rezultatul execuţiei scriptului 13.5

Nume Lungime Data ultimei
Data creării Tip
fişier/director în octeti modificări
2009 Apr 28 2009 Apr 28
.. 0 d
Tue 4:51 PM Tue 4:51 PM
2009 Apr 28 2009 Apr 28
1-Introducere 0 d
2-Elemente de
2009 Apr 28 2009 Apr 28
baza ale 0 d
limbajului
6-Elemente de
baza in 2009 Apr 28 2009 Apr 28
0 d
constructia Tue 4:51 PM Tue 4:51 PM
formularelor
2009 Apr 28 2009 Apr 28
grafica 0 d
2009 May 30 2009 May 30
test 0 d
Sat 9:53 PM Sat 9:53 PM
2009 Apr 28 2006 Dec 20
33.php 1 f
Tue 4:51 PM Wed 2:01 PM
255
P H P
Capitolul 14
14. Crearea şi
prelucrarea bazelor de
date MySql utilizând PHP
Posibilitatea de a stoca date în fişiere sau în baze de date creşte
spectaculos utilitatea unui script PHP. Limbajul PHP are suport încorporat
pentru diferite tipuri de baze de date, dintre acestea MySQL fiind un sistem
de gestiune a bazelor de date folosit foarte des. În acest capitol vom
prezenta câteva exemple comentate referitoare la gestiunea bazelor de date
MySQL, prin intermediul scripturilor PHP. Pentru a uşura înţelegerea lor
facem şi o scurtă prezentare a sintaxei de bază pentru comenzile MySQL
utilizate. Totuşi, acest capitol nu îşi propune să înveţe cititorul cum să
proiecteze o bază de date şi nici să prezinte în detaliu MySQL, ci reprezintă
mai degrabă o abordare simplă şi practică a unui domeniu deosebit de
important în informatică, din perspectiva utilizării limbajului PHP.
257
Programarea în PHP
14.1. Conectarea la serverul de date

MySql
Conectarea la serverul de date MySql se face prin intermediul

funcţiei mysql_connect(), care, într-o formă simplă, are următoarea
sintaxă.
mysql_connect(nume_gazda, nume_utilizator, parola);
unde:
ü nume_gazda este numele calculatorului pe care se află serverul
MySql;
ü nume_utilizator este numele utilizatorului;
ü parola este parola de conectare la serverul MySql.
Funcţia returnează un indice de conexiune în caz de succes şi
valoarea False în caz contrar. Toate argumentele funcţiei sunt opţionale.
În lipsa argumentului nume_gazda, valoarea implicită este
'localhost:3306'. Când lipseşte argumentul parola, valoarea
implicită a parolei este şirul vid. Dacă atât scriptul PHP cât şi baza de date
MySql se află pe acelaşi calculator, atunci valoarea argumentului
nume_gazda va fi 'localhost'.
Închiderea conexiunii se realizează o dată cu închiderea execuţiei
scriptului, iar în mod explicit prin apelarea funcţiei mysql_close().
Sintaxa acestei funcţii este următoarea:
bool mysql_close( identificator_conexiune);
unde identificator_conexiune este un argument opţional care
reprezintă identificatorul de conexiune returnat de funcţia
mysql_connect().
Funcţia returnează valoarea True în caz de succes şi valoarea False
în caz contrar. Dacă identificatorul de conexiune este absent, execuţia
funcţiei are ca efect închiderea ultimei conexiuni deschise cu
mysql_connect().
Exemplu. Scriptul 14.1.php, prezentat mai jos, realizează o

conexiune la serverul MySql.
258
Capitolul 14. Crearea şi prelucrarea bazelor de date MySql utilizând PHP
Scriptul 14.1
<html>
<head>
</head>
<body>
<?php
$con=@mysql_connect('localhost','root','');
if ($con) {
print '<p> S-a creat conexiunea!';
print '<p>Resursa conexiunii este: '.$con;
mysql_close();
} else {
die ('<p> Nu s-a putut crea conexiunea
deoarece:'.mysql_errno().': '.mysql_error());
}
?>
</body>
</html>

S-a creat conexiunea!
Resursa conexiunii este: Resource id #1
Observaţii. Prezenţa simbolului @ în faţa numelui unei funcţii, (ca în

exemplul @mysql_connect('localhost','root',''); ) are rolul
de a bloca afişarea eventualelor mesaje de eroare şi de avertizare, rezultate
din execuţia funcţiei.
Funcţia mysql_error() afişează în caz de eroare versiunea text a
codurilor de eroare MySql. Aceste coduri de eroare pot fi afişate cu ajutorul
funcţiei mysql_errno().
Sintaxa funcţiei mysql_error() este
string mysql_error (identificator_conexiune );
unde identificator_conexiune este un argument opţional care
reprezintă identificatorul de conexiune returnat de funcţia
mysql_connect(). Dacă acest argument lipseşte, funcţia
mysql_error() va afişa un mesaj relativ la cea mai recentă funcţie
MySql apelată (cu excepţia funcţiilor mysql_error() şi
mysql_errno() ). Funcţia returnează fie un text de eroare, fie un şir vid
,dacă execuţia funcţiei MySql apelată anterior a fost fără erori.
Sintaxa funcţiei mysql_errno() este
259
Programarea în PHP
int mysql_errno(identificator_conexiune );
Comentariile făcute în cazul funcţiei mysql_error() sunt valabile
şi aici, cu precizarea că funcţia mysql_errno() returnează fie un cod de
eroare, fie valoarea 0, dacă execuţia funcţiei MySql apelată anterior a fost
fără erori.
Pentru a ilustra modul de execuţie al funcţiilor mysql_error() şi
mysql_errno() producem intenţionat o eroare în execuţia scriptului
14.1.php, scriind localhos în loc de localhost.
Scriptul 14.2
<html>
<head>
</head>
<body>
<?php
$con=@mysql_connect('localhos','root','');
if ($con) {
print '<p>Resursa conexiunii este: '.$con;
mysql_close();
} else {
deoarece:'.mysql_errno().': '.mysql_error());
}
?>
</body>
</html>
În urma execuţiei scriptului 14.2.php se va afişa mesajul:

Nu s-a putut crea conexiunea deoarece:2005: Unknown
MySQL server host 'localhos'
Observaţie. Funcţia die() este un alias al funcţiei exit(),

execuţia lor producând întreruperea execuţiei scriptului. De fapt, atât
die() cât şi exit() nu sunt funcţii propriu-zise ci construcţii de limbaj,
nu întorc valori şi pot fi folosite atât cu paranteze cât şi fără paranteze. În
cazul folosirii parantezelor, între paranteze poate fi introdus un întreg sau
un şir de caractere, elemente care vor fi afişate înainte de întreruperea
scriptului.
260
14.2. Selectarea unei baze de date
Presupunând că baza de date cataloage este deja creată, selectarea ei

din PHP se face cu ajutorul funcţiei mysql_select_db(). Sintaxa
funcţiei mysql_select_db() este următoarea:
bool mysql_select_db(string nume_baza_de_date,
resource identificator_conexiune);
unde:
ü nume_baza_de_date este numele bazei de date care se selectează;
ü identificator_conexiune este numele identificatorului de
conexiune returnat de funcţia mysql_connect().
În scriptul 14.3.php, se prezintă un exemplu de folosire a funcţiei
mysql_select_db() pentru selectarea unei baze de date.
Scriptul 14.3
<html>
<head>
</head>
<body
<?php
if ($con) {
$sel=@mysql_select_db("cataloage",$con);
if ($sel) {
print '<p> S-a selectat baza de date cataloage!';
} else {
die ('<p> Nu s-a putut selecta baza de date
cataloage deoarece:'.mysql_error());
}
//prelucrari
mysql_close();
} else {
deoarece:'.mysql_error());
}
?>
</body>
</html>
261
Programarea în PHP

S-a selectat baza de date cataloage!
14.3. Interogarea unei baze de date
În continuare vom prezenta funcţia mysql_query() care permite

interogarea unei baze de date date MySql. Funcţia mysql_query() are
resource mysql_querry(string interogare, resource
identificator_conexiune);
unde:
ü interogare poate fi una din funcţiile de interogare MySql:
CREATE DATABASE, CREATE TABLE, INSERT, SELECT,
DELETE, UPDATE etc.
ü identificator_conexiune este un parametru opţional care
reprezintă numele identificatorului de conexiune returnat la apelul
funcţiei mysql_connect(). Dacă acesta lipseşte, se consideră
implicit identificatorul de conexiune al ultimei conexiuni deschise de
funcţia mysql_connect().
În caz de succes, funcţia mysql_query() poate returna o resursă
(de exemplu când se foloseşte interogarea SELECT) sau valoarea True (de
exemplu, pentru interogările CREATE, INSERT, DELETE, UPDATE). În
caz de insucces, funcţia returnează valoarea False.
14.3.1. Crearea unei baze de date
O bază de date MySql poate fi creată lansând comanda CREATE

DATABASE, fie de pe linia de comandă, fie din interiorul unui script PHP.
Crearea unei baze de date MySql dintr-un script PHP se realizează cu
ajutorul funcţiei mysql_query(), utilizând o construcţie de forma
mysql_query('CREATE DATABASE nume_baza_de_date ');
În scriptul 14.4.php este prezentat un exemplu de creare a unei baze
de date.
262
Scriptul 14.4
<html>
<head>
</head>
<body>
<?php
$con=mysql_connect('localhost','root','');
if ($con) {
$crea=mysql_query('CREATE DATABASE cataloage');
if ($crea) {
print '<p> S-a creat baza de date cataloage!';
} else {
die ('<p> Nu s-a putut crea baza de date cataloage
}
mysql_close();
} else {
}
?>
</body>
</html>
14.3.2. Crearea unei tabele într-o bază de

date
O dată creată baza de date, aceasta poate fi populată cu tabele în care

se vor memora datele aplicaţiei. Sintaxa de bază pentru crearea unei tabele
este următoarea:
CREATE TABLE nume_tabela (tip coloana_1,tip coloana_2,
....,tip coloana_n)
unde:
ü coloana_1,coloana_2,....,coloana_n reprezintă coloanele
tabelei;
ü tip reprezintă tipul datelor care pot fi memorate în coloana
respectivă. Tipurile de date frecvent utilizate sunt:
ü tipuri numerice: INT, FLOAT, DOUBLE;
ü tipuri de şiruri de caractere: CHAR, VARCHAR;
ü tipuri calendaristice: DATE, DATETIME, TIME.
263
Programarea în PHP
Observaţii. INT, FLOAT, DOUBLE reprezintă valori numerice

intregi, în virgulă mobilă simplă precizie şi respectiv, în virgulă mobilă
dublă precizie. CHAR reprezintă un şir de caractere de lungime fixă, iar
VARCHAR un şir de caractere de lungime variabilă. DATE reprezintă o dată
calendaristică în format AAAA-LL-ZZ, DATETIME o dată calendaristică
plus ora în format AAAA-LL-ZZ HH:MM:SS, iar TIME se referă la ora
reprezentată în format HH:MM:SS. Faptul că o coloană este considerată
cheie primară se precizează cu ajutorul cuvintelor PRIMARY KEY,
precizarea suplimentară AUTO_INCREMENT arată că pentru respectiva
coloană, valorile se incrementează automat cu 1 pentru fiecare linie a
tabelei. Marcarea unei coloane cu cuvintele NOT NULL impune ca această
coloană să aibă valori pentru fiecare linie a tabelei.
Pentru ilustrare am construit scriptul 14.5.php care creează tabela
catalog cu următoarele câmpuri:
ü id - numărul de identificare al studentului. Numărul de identificare
este unic, va fi generat automat şi va fi folosit ca o cheie primară;
ü nume - numele studentului este declarat ca un string cu maxim 30
de caractere;
ü prenume - prenumele studentului este declarat ca un string cu
maxim 40 de caractere;
ü nota - nota obţinută de student la un examen este un câmp de tip
întreg.
Scriptul 14.5
<html>
<head>
</head>
<body><?php
if ($con) {
if ($sel) {
} else {
264

}
$query='CREATE TABLE catalog
(id INT NOT NULL PRIMARY KEY AUTO_INCREMENT ,
nume VARCHAR(30) NOT NULL,
prenume VARCHAR(40) NOT NULL,
nota INT NOT NULL)';
if (@mysql_query($query)) {
print '<p>Tabela catalog a fost creata!';
} else {
die( '<p> Nu se poate crea tabela catalog
}
mysql_close();
} else {
}
?>
</body>
</html>

Tabela catalog a fost creata!
14.3.3. Adăugarea datelor într-o tabelă
Adăugarea (inserţia) datelor într-o tabelă se face cu ajutorul comenzii

INSERT. O variantă a comenzii INSERT, frecvent utilizată, este
următoarea:
INSERT INTO nume_tabela(lista_nume_coloane_tabela)

VALUES (lista_valori_pentru_coloane)
unde:
ü nume_tabela reprezintă numele tabelei în care se face adăugarea;
ü lista_nume_coloane_tabela este lista numelor coloanelor
tabelei;
265
Programarea în PHP
ü lista_valori_pentru_coloane este lista de valori care se

memoreză în coloanele corespunzătoare ale tabelei.
Elementele ambelor liste sunt despărţite prin virgulă.
Observaţie. Instrucţiunea INSERT, prezentată mai sus, poate avea şi

următoarea formă simplificată:
INSERT INTO nume_tabela VALUES
(lista_valori_pentru_coloane)
Ca exemplu, considerăm instrucţiunea
INSERT INTO catalog (nume, prenume, nota) VALUES
('Ionescu', 'Ion', 8)
a cărei execuţie în MySql va determina memorarea valorilor 'Ionescu',
'Ion', 8 respectiv în câmpurile nume, prenume şi nota ale tabelei
catalog.
Scriptul 14.6.php, prezentat mai jos, permite adăugarea unei
înregistrări în tabela catalog. Datele se transmit către script prin
intermediul unui formular. De remarcat faptul că valoarea corespunzătoare
câmpului id este un şir vid; valoarea acestuia va creşte automat cu o
unitate, cu fiecare înregistrare adăugată.
Scriptul 14.6
<html>
<head>
</head>
<body>
<?php
if ($con) {
if ($sel) {
} else {
}
$ins="INSERT INTO catalog(id,nume,prenume,nota)
VALUES('','$_POST[nume]','$_POST[prenume]',
'$_POST[nota]')";
if (@mysql_query($ins)){
266

print '<p> Inregistrarea a fost adaugata in
tabela catalog!';
} else {
die ('<p> Nu se poate face adaugarea
}
mysql_close();
} else {
}
} else {
print ' <form action="14.6.php" method="POST">
<p>Nume:<br><input type=text name="nume" size=30>
<p>Prenume:<br><input type=text name="prenume" size=40>
<p>Nota:<br><input type=text name="nota" size=2><br>
<input type=submit name="trimite" value="Adaugare
inregistrare"> </p>
</form>';
}
?>
</body>
</html>
14.3.4. Afişarea datelor dintr-o tabelă
Pentru afişarea datelor dintr-o tabelă se foloseşte comanda SELECT.

Deoarece sintaxa comenzii SELECT este destul de stufoasă, vom reţine
pentru prezentare numai câteva din clauzele sale:
SELECT lista_expresii_select_coloana FROM nume _tabela
[WHERE conditie]
[ORDER BY nume_coloana [ASC|DESC]
[LIMIT start_poz, numar _randuri]
unde:
ü lista_expresii_select_coloana indică ce coloane se
selectează; trebuie să se selecteze cel puţin o coloană;
ü nume_tabela indică tabela din care se selectează;
ü conditie reprezintă condiţia pe care trebuie să o îndeplinească
răndurile care sunt selectate din tabelă;
267
Programarea în PHP
ü nume_coloana este coloana care va fi sortată, fie crescător (clauza

ASC), fie descrescător (clauza DESC); rândurile tabelei vor fi
permutate corespunzător;
ü start_poz reprezintă numărul primei înregistrări care se
selectează.
Observaţie. Dacă parametrul start_poz lipseşte, se consideră

implicit că selectarea înregistrărilor începe cu poziţia 0, adică cu prima
înregistrare.
Scriptul 14.7.php, prezentat mai jos, realizează afişarea tuturor
înregistrărilor din tabela catalog. Semnul * indică faptul că se selectează
toate coloanele tabelei.
Scriptul 14.7
<html>
<head>
</head>
<body>
<?php
if ($con) {
if ($sel) {
} else {
}
$sql="SELECT * FROM catalog";
$rezultat=@mysql_query($sql);
if ($rezultat) {
print '<p> Lista inregistrarilor din catalog:';
print "<table border='1'>";
while ($rand=mysql_fetch_array($rezultat)) {
$id=$rand['id'];
$nume=$rand['nume'];
$prenume=$rand['prenume'];
$nota=$rand['nota'];
print "<tr><td>$id</td><td>$nume
</td><td>$prenume</td><td>$nota</td></tr>";
}
print "</table>";
268

mysql_close();
} else {
print '<p> Catalogul nu a fost gasit!';
}
} else {
}
?>
</body>
</html>
Rezultatul execuţiei acestui script este asemănător cu următorul :

Lista înregistrărilor din catalog:
37 Vasilescu Vasile 10
38 Georgescu George 6
39 Iliescu Ilie 7
36 Ionescu Ion 8
Exemplu. Scriptul următor, 14.8.php, utilizează pentru afişarea

selectivă a informaţiilor din tabela catalog, căteva din clauzele prezentate în
sintaxa comenzii SELECT. Mai precis, se doreşte să se listeze numele şi
prenumele celor mai buni doi studenţi, fiecare dintre ei având nota mai
mare decât 9.
Scriptul 14.8
<html>
<head>
</head>
<body>
<?php
if ($con) {
if ($sel) {
269
Programarea în PHP

} else {
die ('<p> Nu s-a putut selecta baza de date cataloage
}
$sql="SELECT nume, prenume FROM catalog
WHERE nota>=9 ORDER BY nota DESC LIMIT 2";
if ($rezultat) {
print '<p> Lista inregistrarilor din catalog:';
$id=$rand['id'];
}
print "</table>";
mysql_close();
} else {
print '<p> Catalogul nu a fost gasit!';
}
} else {
}
?>
</body>
</html>
Rezultatul execuţiei scriptului 14.8.php este asemănător cu următorul:

Lista inregistrarilor selectate din catalog:
Vasilescu Vasile
Observaţii
ü Selectarea coloanelor nume şi prenume s-a făcut cu ajutorul
comenzii
SELECT nume, prenume FROM catalog;
270
ü Selectarea înregistrărilor cu note mai mari decât 9 s-a realizat

folosind clauza WHERE nota>=9;
ü Utilizarea clauzei ORDER BY nota DESC a asigurat ordonarea
descrescătoare după coloana nota a înregistrărilor selectate.
ü Utilizarea clauzei DESC LIMIT 2 a fost făcută cu intenţia de a
reţine în listă primii 2 studenţi care au notele cele mai bune;
deoarece în exemplul prezentat nu există decât un student cu nota
mai mare decât 9 (studentul Vasilescu Vasile), a fost selectat
numai acesta.
14.3.5. Ştergerea datelor dintr-o tabelă
Ştergerea unei înregistrări dintr-o tabelă se face cu ajutorul comenzii

DELETE. Într-o versiune restrânsă, frecvent utilizată, comanda DELETE are
DELETE FROM nume _tabela
[WHERE conditie]
[ORDER BY nume_coloana [ASC|DESC]
[LIMIT numar _randuri]
unde:
ü nume_tabela indică tabela din care se şterg înregistrările;
rândurile care sunt şterse din tabelă;
ü nume_coloana este coloana după care rândurile tabelei vor fi
sortate, fie crescător (clauza ASC), fie descrescător (clauza DESC);
ü numar _randuri reprezintă numărul maxim de înregistrări care se
şterg.
Observaţii
ü Comanda DELETE şterge întotdeauna o întreagă înregistrare; nu este
posibilă ştergerea doar a anumitor coloane dintr-o înregistrare.
ü Atenţie! Dacă se utilizează numai forma
DELETE FROM nume_tabela
se şterg toate înregistrările din tabela cu numele nume_tabela !
271
Programarea în PHP
În cele ce urmează vom prezenta trei exemple de ştergere a unei

înregistrări dintr-o tabelă, materializate în scripturile 14.9, 14.10 şi 14.11.
Scripturile 14.10 şi 14.11 utilizează scriptul 14.12 pentru a realiza ştergerea
efectivă din baza de date.
Scriptul 14.9.php, prezentatat mai jos, realizează următoarele
acţiuni:
ü afişează înregistrările unei tabele ca elemente ale unei liste derulante;
ü permite selectarea din această listă a înregistrării dorite;
ü efectuează ştergerea înregistrării selectate.
Scriptul 14.9
<html>
<head>
</head>
<body>
<?php
if ($con) {
} else {
}
$sel=@mysql_select_db('cataloage',$con);
if ($sel) {
} else {
}
if ($_POST['trim']) {
$del="DELETE FROM catalog WHERE id=".$_POST['id'];
if (@mysql_query($del)) {
print '<p> Inregistrarea selectata a fost
stearsa!';
} else {
print '<p> Nu se poate face stergerea
deoarece:!'.mysql_error();
}
} else {
print ' <form action="14.9.php" method ="POST">
<select name="id">';
$sql="SELECT * FROM catalog ORDER BY nume ASC";
272

if ($rezultat) {
$id=$rand['id'];
$afis='<option value="'.$id.'">';
$afis.=$id.' '.$nume.' '.$prenume.' '.$nota.'
'.'</option>';
print $afis;
}
} else {
die ('<p> Catalogul nu a fost gasit
}
print '</select>
<input type="submit" name="trim" value="Selecteaza Si
Sterge!">';
}
mysql_close();
?>
</form>
</body>
</html>
Pentru selectarea înregistrării dorite se afişează o listă derulantă de

forma:
37 Vasilescu Vasile 10 Selecteaza si Sterge!
În acest script, apăsarea butonului Selecteaza Si Sterge!

produce ştergerea efectivă a înregistrării selectate, urmată de afişarea
mesajului:
Inregistrarea selectata a fost stearsa!
Scripturile 14.10.php şi 14.11.php permit afişarea înregistrării
selectate cu scopul de a fi ştearsă. O dată cu afişarea, utilizatorul primeşte
un mesaj de atenţionare de genul :
Sunteti sigur ca doriti stergerea urmatoarei
inregistrari?
273
Programarea în PHP
În scriptul 14.10.php selectarea înregistrării pentru ştergere se face,

ca şi în cazul utilizării scriptului 14.9.php, dintr-o listă derulantă.
Transmiterea identificatorului înregistrării către scriptul care face efectiv
ştergerea (14.12.php) se realizează cu ajutorul unui formular, prin
intermediul unui cămp ascuns.
Alegerea răspunsului la întrebarea de mai sus se face selectând una

din variantele:
Da,sterge!
Nu sterge!
Prezentăm mai jos scriptul 14.10.php:
Scriptul 14.10
<html>
<head>
</head>
<body>
<?php
if ($con) {
} else {
}
if ($sel) {
} else {
}
$sql="SELECT id, nume, prenume, nota FROM catalog
WHERE id=".$_POST['id'];
if ($rezultat) {
print '<br>Sunteti sigur ca doriti stergerea
urmatoarei inregistrari?';
print '<form action="14.12.php" method="GET">';
274

$id=$rand['id'];
}
print "</table>";
print '<input type="hidden" name="idst" value
="'.$_POST['id'].'">';
print '<br><input type="submit" name="submit"
value="Da,sterge!">';
print '</form>';
print '<a href="14.10>.php"> Nu sterge!</a>';
}
} else {
print' <form action="14.10.php" method ="POST">
if ($rezultat) {
$id=$rand['id'];
$afis.=$id.' '.$nume.' '.$prenume.'
'.$nota.' '.'</option>';
print $afis;
}
} else {
}
print '</select>
<input type="submit" name="trim" value="Selecteaza
pentru Stergere">';
}
mysql_close();
?>
</form>
</body>
</html>
275
Programarea în PHP
În scriptul 14.11.php, selectarea înregistrării pentru ştergere se

realizează executând click pe pe link-ul Stergere aferent fiecărei
înregistrări, dintr-o listă cu componente asemănătoare cu :
Stergere
Transmiterea identificatorului înregistrării către scriptul care face
efectiv ştergerea (14.12.php) se face folosind metoda GET, prin ataşare la
referinţa către acest script:
print "<a
href=\"Stergere.php?idst={$_GET['id']}\">DA<br></a>";
Acceptul pentru ştergere se face selectând link-ul DA din cele două
posibilităţi afişate :
DA
NU
Selectarea link-ului NU ne va redirecţiona către scriptul 14.12.php
Prezentăm mai jos scriptul 14.11.php:
Scriptul 14.11
<html>
<head>
</head>
<body>
<?php
if($con) {
} else {
}
if ($sel) {
} else {
}
if (is_numeric($_GET['id'])) {
$idst=$_GET['id'];
print "id=".$idst;
$sql="SELECT id, nume, prenume, nota FROM catalog
WHERE id=".$_GET['id'];
276

if ($rezultat) {
print '<br>Sunteti sigur ca doriti stergerea
urmatoarei inregistrari?';
$id=$rand['id'];
}
print "</table>";
print "<a
href=\"14.12.php?idst={$_GET['id']}\">DA<br></a>";
print '<a href="S14.11>.php"> NU</a>';
}
} else {
print '<br>Selecteaza o inregistrare pentru
stergere:<br>';
if ($rezultat) {
$id=$rand['id'];
$afis=$id.' '.$nume.' '.$prenume.' '.$nota;
print "<br>$afis";
print "<br><a
href=\"14.11.php?id=$id\">Stergere</a><br>";
}
} else {
}
}
mysql_close();
?>
</form>
</body>
</html>
Aşa cum s-a precizat deja, scriptul care realizează efectiv ştergerea
este scriptul 14.12.php.
277
Programarea în PHP
Scriptul 14.12
<html>
<head>
</head>
<body>
<?php
if ($con) {
print '<p> S-a creat conexiunea! </p>';
if ($sel) {
} else {
}
$id="DELETE FROM catalog WHERE id=".$_GET['idst'];
if (@mysql_query($id)) {
print '<p> Inregistrarea a fost stearsa! </p>';
} else {
print '<p> Nu se poate face stergerea
deoarece:!'.mysql_error().'</p>';
}
mysql_close();
} else {
deoarece:'.mysql_error().'</p>');
}
?>
</body>
</html>
14.3.6. Modificarea datelor dintr-o tabelă
Modificarea unei înregistrări dintr-o tabelă se face cu ajutorul

comenzii UPDATE sau, echivalent, cu comanda REPLACE.
Comanda UPDATE are sintaxa:
UPDATE nume_tabela
SET coloana_1='valoare_1',coloana_2='valoare_2',…,
coloana_n='valoare_n'
[WHERE conditie]
278
unde:
ü nume_tabela indică tabela in care se modifică înregistrările;
ü coloana_1, coloana_2, …, coloana_n reprezintă coloanele
care vor fi modificate respectiv cu valorile: valoare_1,
valoare_2,…, valoare_n;
răndurile din tabelă care sunt selectate pentru modificare.
Comanda REPLACE are următoarea sintaxă:
REPLACE INTO nume_tabela(lista_nume_coloane_tabela)
VALUES (lista_valori_pentru_coloane)
unde:
ü nume_tabela reprezintă numele tabelei în care se face modificarea;
ü lista_nume_coloane_tabela este lista numelor coloanelor
tabelei;
ü lista_valori_pentru_coloane este lista de valori care se
memorează în coloanele corespunzătoare ale tabelei.
Se observă că sintaxa comenzii REPLACE este foarte asemănătoare

cu sintaxa comenzii INSERT.
Vom prezenta în continuare trei variante de scripturi pentru
modificarea valorilor câmpurilor unei înregistrări: 14.13.php, 14.14.php,
14.15.php. Fiecare din cele trei scripturi selectează înregistrarea care se
doreşte a fi modificată şi trimite identificatorul înregistrării către scriptul
14.16.php, care face efectiv modificarea.
Execuţia scriptului 14.13.php impune parcurgerea următorilor paşi:
ü obţinerea identificatorului unei înregistrări prin selecţia înregistrării
respective dintr-o listă derulantă;
ü transmiterea identificatorului înregistrării selectate prin metoda
POST către acelaşi script şi afişarea unui formular ( Nume,
Prenume, Nota) cu valori vide;
ü completarea tuturor câmpurilor înregistrării, chiar şi a acelora care nu
se modifică (se rescriu);
ü transmiterea către scriptul 14.6.php (printr-un câmp ascuns), o dată cu
datele din formular, a identificatorului înregistrării care se modifică.
279
Programarea în PHP
Observaţie. Dezavantajul acestei versiuni constă în faptul că trebuie să

fie rescrise chiar şi câmpurile care nu se modifică, fapt ce ar putea
conduce la alterarea informaţiei iniţiale.
Scriptul 14.13
<html>
<head>
</head>
<body>
<?php
if($con) {
} else {
}
if ($sel) {
} else {
}
print '<p>Completeaza modificarile:
<p> <form action="14.16.php" method="POST">
<p> Nume:<input type="text" name="nume" value="" size
="30">
<p> Prenume:<input type="text" name="prenume"
value="" size ="40">
<p> Nota:<input type="text" name="nota" value="" size
="2">
<input type="hidden" name="idmod" value
="'.$_POST['id'].'">
<input type="submit" name="submit" value="Trimite
modificarile">';
} else {
if ($rezultat) {
$id=$rand['id'];
280

$afis.=$id.' '.$nume.' '.$prenume.'
'.$nota.' '.'</option>';
print $afis;
}
} else {
}
print '</select>
<input type="submit" name="trim" value="Selecteaza
pentru Modificare">';
}
mysql_close();
?>
</form>
</body>
</html>
Execuţia scriptului 14.14.php, impune parcurgerea următorilor paşi:

ü obţinerea identificatorului unei înregistrări prin selecţia înregistrării
respective dintr-o listă derulantă;
ü transmiterea identificatorului înregistrării selectate prin metoda
POST către acelaşi script şi afişarea valorilor câmpurilor înregistrării
selectate ( Nume, Prenume, Nota) într-un formular;
ü efectuarea modificărilor acolo unde este cazul;
ü transmiterea către scriptul 14.6.php (printr-un câmp ascuns), o dată
cu datele din formular, a identificatorului înregistrării care se
modifică.
Observaţie. Această variantă este avantajoasă deoarece permite

rescrierea numai a câmpurilor care trebuie să fie modificate.
Scriptul 14.14
<html>
<head>
</head>
<body>
<?php
281
Programarea în PHP

if ($con) {
print '<p> S-a creat conexiunea! </p>';
} else {
}
if ($sel) {
} else {
}
$sql="SELECT nume, prenume, nota FROM catalog WHERE
id=".$_POST['id'];
if ($rezultat) {
print '<form action="14.16.php" method="POST">';
$id=$rand['id'];
print '<p> Efectueaza modificarile:
<p>Nume:<input type="text" name="nume"
value="'.$nume.'">
<p>Prenume:<input type="text" name="prenume"
value="'.$prenume.'">
<p>Nota:<input type="text" name="nota"
value="'.$nota.'">';
}
print '<input type="hidden" name="idmod" value
="'.$_POST['id'].'">';
print '<input type="submit" name="submit"
value="Trimite modificarile">';
} else {
print '<p> Catalogul nu a fost gasit !</p>';
}
} else {
if ($rezultat){
while ($rand=mysql_fetch_array($rezultat)){
282

$id=$rand['id'];
$afis.=$id.' '.$nume.' '.$prenume.' '.$nota.'
'.'</option>';
print $afis;
}
} else {
}
print '</select>
<input type="submit" name="trim" value="Selecteaza pentru
Modificare">';
}
mysql_close();
?>
</form>
</body>
</html>
Execuţia scriptului 14.15.php, impune parcurgerea următorilor paşi:

ü afişarea tuturor înregistrărilor din tabelă ; fiecare înregistrare este
însoţită de link-ul Modificare, care permite transmiterea manulă
(metoda GET) către acelaşi script a identificatorului înregistrării pe
care o însoţeşte;
ü Activarea link-ului Modificare pentru înregistrarea care va fi
modificată urmată de afişarea valorile câmpurilor înregistrării
selectate (Nume, Prenume, Nota) într-un formular;
ü efectuarea modificărilor acolo unde este cazul;
ü transmiterea către scriptul 14.6.php (printr-un câmp ascuns), o dată
cu datele din formular, a identificatorului înregistrării care se
modifică.
Observaţie. Şi această variantă permite rescrierea numai a

câmpurilor care trebuie să fi modificate.
283
Programarea în PHP
Scriptul 14.15
<html>
<head>
<title>14.15</title>
</head>
<body>
<?php
if ($con) {
} else {
}
if ($sel) {
} else {
}
if (is_numeric($_GET['id'])) {
$sql="SELECT nume, prenume, nota FROM catalog WHERE
id=".$_GET['id'];
if ($rezultat) {
print '<form action="14.16.php" method="POST">';
$id=$rand['id'];
print '<p> Efectueaza modificarile:
<p> Nume:<input type="text" name="nume"
value="'.$nume.'">
<p> Prenume:<input type="text"
name="prenume" value="'.$prenume.'">
<p> Nota:<input type="text" name="nota"
value="'.$nota.'">';
}
print '<input type="hidden" name="idmod" value
="'.$_GET['id'].'">';
print '<input type="submit" name="submit"
value="Trimite modificarile">';
} else {
print '<p> Catalogul nu a fost gasit !';
}
} else {
284

if ($rezultat) {
$id=$rand['id'];
$afis=$id.' '.$nume.' '.$prenume.' '.$nota;
print "<br>$afis";
print "<br><a
href=\"14.15.php?id=$id\">Modificare</a><br>";
}
} else {
}
}
mysql_close();
?>
</form>
</body>
</html>
Scriptul care face efectiv modificarea este scriptul 14.16.php,

prezentat în continuare:
Scriptul 14.16
<html>
<head>
</head>
<body>
<?php
if ($con) {
if ($sel) {
} else {
die('<p> Nu s-a putut selecta baza de date
}
285
Programarea în PHP

$rep="UPDATE catalog SET nume='".$_POST['nume']."'
,prenume='".$_POST['prenume']."',nota='".$_POST['nota']
."' WHERE id=".$_POST['idmod'];
if (@mysql_query($rep)) {
print '<p> Inregistrarea a fost modificata!';
} else {
die ('<p> Nu se poate face modificarea
}
mysql_close();
} else {
}
?>
</body>
</html>
Observaţie. În locul comenzii

$rep="UPDATE catalog SET nume='".$_POST['nume']."',
prenume='".$_POST['prenume']."',
nota='".$_POST['nota']."' WHERE id=".$_POST['idmod'];
se poate utiliza, cu acelaşi efect, comanda:
$rep="REPLACE INTO catalog(id,nume,prenume,nota)

VALUES('$_POST[idmod]','$_POST[nume]','$_POST[prenume]
','$_POST[nota]')";
286
P H P
Bibliografie
1. Meloni Julie C., Învaţă singur PHP, MYSQL şi APACHE-Toate într-o
singură carte, Editura Corint, Bucureşti, 2005
2. Ullman Larry, PHP pentru World Wide Web: în imagini, Editura Teora,
2004
3. Anghel Traian, Programarea în PHP:ghid practic, Editura Polirom,
2005
4. Marinoiu Cristian, Programarea în C, Editura Universităţii din Ploieşti,
2000
5. Gilmore Jason W., A Programmer’s Introduction to PHP 4.0. APRESS,
U.S.A, 2001
6. Converse Tim, Park Joyce, Morgan Clark, PHP5 and MySql Bible,
Wiley Publishing Inc., Indianapolis, Indiana, U.S.A,2004
7. Zandstra Matt, Teach yourself PHP in 24 hours, Sams Publishing,
U.S.A 2004
8. Gugoiu Teodoru, HTML prin exemple, Editura Teora, Bucureşti, 2001
9. PHP şi MySQL pe înţelesul tuturor-Soluţia completă pentru un magazin
online, Revista Chip, nr.2,2003
10.http://php.net/manual/ro/index.php
11.http://www.w3school.com
287

Programarea in PHP - Marinoiu - Cu Adnotari

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Programarea in PHP - Marinoiu - Cu Adnotari

Încărcat de

Drepturi de autor:

Formate disponibile

Programarea în PHP

Editura Universităţii Petrol-Gaze din Ploiești

Autorul poartă întreaga răspundere morală, legală şi materială faţă

Descrierea CIP a Bibliotecii Naţionale a României

Adresa: Editura Universităţii Petrol-Gaze din Ploieşti, Bd. Bucureşti 39,

Lucrarea este alcătuită din 14 capitole şi are un pronunţat caracter

Mulţumesc pe această cale colegilor mei de la colectivul de

Ploieşti, Septembrie, 2011 Autorul

4.2.1. Instrucţiunea if ....................................................................... 44

BIBLIOGRAFIE ........................................................................ 287

1.1. PHP – scurt istoric

Limbajul PHP (Personal Home Page) este succesorul aplicaţiei

1.2. PHP - caracteristici de bază

Ajuns la versiunea a 5-a, limbajul PHP oferă utilizatorilor săi o gamă

interfeţe pentru o mare parte din sistemele de gestiune a bazelor de date

Client Server web

Practic, clientul (utilizatorul) realizează o cerere către serverul de

1.3. PHP – Noţiuni introductive

Pentru a putea fi executate, scripturile PHP trebuie să fie editate în

şi ?>. Practic, numai textul cuprins între aceste etichete va fi interpretat de

Acest script poate fi accesat sub forma http://localhost/1.1.php.

Executând scriptul astfel modificat obţinem acelaşi rezultat. În acest

Rezultatul execuţiei scriptului 1.3.php este:

Comentariile la nivel de linie se specifică prin semnele // sau #.

sau liniuţă de subliniere. În plus, numele trebuie să fie precedat de

Numele unei variabile este dependent de capitalizare (case-

$_GET, $_COOKIE, $_SESSION etc. Acestea sunt disponibile permanent

Definirea unei constante se face cu ajutorul funcţiei predefinite

caracter global (pot fi accesate în orice parte a scriptului), nu pot fi

2.3. Tipuri de date

2.3.1. Tipuri de date scalare

Tipul de date integer acoperă o submulţime a mulţimii numerelor

Un întreg care depășeste valoarea maximă admisă pentru întregi va fi

Tipul de date float (numit și double din motive istorice) acoperă o

Tipul de date boolean se referă la valorile de adevăr adevărat şi

Tipul de date string se referă la mulţimea șirurilor de caractere.

"Sirul "cda" e un exemplu de sir marcat cu ghilimele"

2.3.2. Tipuri de date compuse

Tipul de date array permite reprezentarea tablourilor. În PHP,

În cazul în care cheile lipsesc, indicii vor fi generaţi automat

nume prenume nota

poate fi modelat în PHP sub forma:

Referirea la elementele unui tablou multidimensional se face

Tipul de date object permite utilizarea facilităţilor oferite de

2.3.3. Tipuri de date speciale

Tipul de date NULL are o singură valoare, valoarea NULL. Cuvântul

Tipul de date resource se referă la valori speciale, cum ar fi:

3.1. Clase de precedenţă

O clasă de precedenţă reuneşte operatorii care au aceeaşi prioritate.

Tabelul 3.1. Clase de precedenţă

Tabelul 3.1. (continuare)

Exemple. Operatorii aritmetici aditivi au asociativitate la stânga:

$x=$y=3; este echivalentă cu $x=($y=3);

3.2. Operatori aritmetici

Operatorii aritmetici sunt binecunoscuţi: - (negaţie), + (adunare), -

Reguli de conversie automată

ü Dacă șirul începe cu un subșir care reprezintă un număr întreg sau

3.3. Operatori de comparaţie

Operatorii de comparaţie permit comparaţia dintre doi operanzi.

Reguli de conversie automată

3.4. Operatori logici

Operatorii logici se pot aplica valorilor de tip boolean False sau

Modul de acţiune al acestor operatori este sintetizat în tabelul 3.2