Amg MA 11180

_____________________________________________________________________________________________
Acest document este proprietatea Institutului Multimedia Romano-Elvetian.

SUPORT DE CURS

PHP

Modulul 4 Tehnologii Web avansate

Specializare:
WebProgramator

Modulul 4 Tehnologii Web avansate Curs: PHP
_______________________________________________________________________________________________

CUPRINS

CAPITOLUL 1. INTRODUCERE IN LIMBAJUL PHP .......................................................................................................... 3
1.2.CREAREA UNUI SCRIPT PHP ............................................................................................................................................ 4
CAPITOLUL 2. ELEMENTE DE BAZA ALE LIMBAJULUI PHP............................................................................................ 6
2.1.TIPURI DE VARIABILE ..................................................................................................................................................... 6
2.2.DECLARAREA VARIABILELOR IN PHP ............................................................................................................................... 12
2.3.DOMENIUL DE VALABILITATE AL VARIABILELOR ................................................................................................................. 13
2.4.OPERATORI ............................................................................................................................................................... 15
2.5. STRUCTURI DE CONTROL ............................................................................................................................................. 17
2.6. UTILIZAREA MATRICELOR ............................................................................................................................................. 23
CAPITOLUL 3. FUNCTII PHP ....................................................................................................................................... 27
CAPITOLUL 4. PHP SI FORMULARELE HTML .............................................................................................................. 31
4.1. CREAREA UNUI FORMULAR .......................................................................................................................................... 31
4.2. UTILIZAREA METODELOR GET SI POST .......................................................................................................................... 31
4.3. RECEPTIONAREA DATELOR DE LA UN FORMULAR HTML .................................................................................................... 32
4.4. TRATAREA ERORILOR .................................................................................................................................................. 35
4.5. EXERCITIU ................................................................................................................................................................ 35
CAPITOLUL 5. FISIERE SI DIRECTOARE ....................................................................................................................... 36
5.1. CREAREA, SCRIEREA FISIERELOR .................................................................................................................................... 36
5.2. BLOCAREA FISIERELOR ................................................................................................................................................ 38
5.3. CITIREA FISIERELOR .................................................................................................................................................... 40
5.4. CREAREA SI PARCURGEREA DIRECTOARELOR. ................................................................................................................... 43
5.5. DREPTURI DE ACCESS LA FISIERE .................................................................................................................................... 45
CAPITOLUL 6. SITE-URI DINAMICE, LUCRUL CU BAZELE DE DATE .............................................................................. 46
6.1. CONECTAREA LA SERVERUL MYSQL; TRATAREA ERORILOR ................................................................................................. 46
6.2. CREAREA SI SELECTAREA UNEI BAZE DE DATE ................................................................................................................... 48
6.3. CREAREA TABELELOR, SCRIPTURI SQL ............................................................................................................................ 50
6.4. ADAUGAREA, INSERAREA DATELOR INTR-O TABELA ........................................................................................................... 52
6.5. CITIREA DATELOR DINTR-O TABELA SAU INTEROGARE ........................................................................................................ 53
6.5. CITIREA DATELOR DINTR-O TABELA SAU INTEROGARE ........................................................................................................ 55
CAPITOLUL 7. SESIUNI SI COOKIE-URI ....................................................................................................................... 56
7.1. DESPRE SESIUNI, CREAREA UNEI SESIUNI PHP .................................................................................................................. 56
7.2 MANIPULAREA VARIABILELOR SESIUNII. ........................................................................................................................... 58
7.2. STERGEREA UNEI SESIUNI ............................................................................................................................................ 59
7.3. CREAREA SI CITIREA COOKIE-URILOR .............................................................................................................................. 60
7.3. INTRODUCEREA PARAMETRILOR INTR-UN COOKIE ............................................................................................................. 63
7.4. MONITORIZAREA VIZITATORILOR UNUI SITE ..................................................................................................................... 64
7.5 STERGEREA COOKIE-URILOR .......................................................................................................................................... 67
CAPITOLUL 8. UTILIZAREA CLASELOR IN PHP ............................................................................................................ 68
8.1 DESPRE POO, AVANTAJELE UTILIZARII CLASELOR ............................................................................................................... 68
8.2. DECLARAREA CLASELOR, CLASE DERIVATE ....................................................................................................................... 68
8.3. INSTANTIEREA CLASELOR; STERGEREA INSTANTELOR UNEI CLASE .......................................................................................... 70
CAPITOLUL 9. EXEMPLU DE SCRIPT PHP ................................................................................................................... 74
_______________________________________________________________________________________________

Capitolul 1. INTRODUCERE IN LIMBAJUL PHP

1.1.Notiuni elementare de sintaxa PHP

Limbajul PHP a fost creat in anul 1994 de catre Rasmus Lerdorf, care incerca sa-si personalizeze
propria pagina Web; din acest motiv limbajul a fost numit initial PHP adica: Personal Home Page
(pagina de baza personala). Ulterior limbajul a fost perfectionat, utilitatea si caracteristicile sale s-
au dezvoltat treptat, ajungand sa aiba semnificatia Hypertext Preprprocesor (PHP). Preprocesarea
consta in aceea ca datele sunt interpretate(preprocesate) de catre serverul Web inainte ca acesta
sa genereze cod HTML.

Secventele de cod PHP pot fi incluse intr-un fisier HTML; ulterior serverul Web va identifica
aceasta secventa de cod , va procesa acesta secventa de cod generand cod HTML iar la final va
inlocui secventa de cod PHP cu codul HTML.

Limbajul PHP este folosit pentru o gama impresionanta de operatii, cu ajutorul acestui limbaj
putem crea site-uri dinamice, adica site-uri care vor interactiona cu end-userul, furnizand continut
in concordanta cu optiunile selectate de utilizator.

Printre caracteristicile cele mai importante ale limbajului enumeram:
-simplitate: acest limbaj este simplu de folosit, fiind accesibil si ne-programatorilor.
Datorita acestui fapt el a devenit cel mai popular limbaj de script pentru generarea de pagini
HTML dinamice.

-usor de folosit : limbajul are o sintaxa asemanatoare limbajului C, care este foarte popular
in randul programatorilor. De aceea programatorii cu cunostine de C sau Perl vor face foarte rapid
trecerea spre PHP. Pe de alta parte anumite aspecte cum ar fi: declararea si folosirea variabilelor
este mult simplificata in PHP, spre deosebire de C++ sau alte limbaje de nivel inalt.

-eficienta: specificatiile limbajului includ folositea tehnicilor de POO (Programare orientata
pe obiecte) iar acest lucru contribuie la marirea productivitatii: un programator PHP poate folosi
module scrise de un alt programator fara sa fie nevoit sa cunoasca detalii specifice de
impementare a codului.

-cross-platform : exista implementari ale limbajului pe mai multe sisteme de operare, cele
mai populare fiind cele de pe sistemele Linux si Windows. In acest caz daca scriem cod PHP care
ruleaza pe un sistem Linux, ulterior vom putea folosi acest cod pe un server care ruleaza Windows
si viceversa.

-free : PHP reprezinta un Open Source software, oricine poate folosi acest limbaj fara a fi
nevoit sa plateasca ceva. De asemenea utilizatorii au access la sursele PHP (scrise in limbajul C).
Site-ul oficial al limbajului PHP se afla la : www.php.net , datorita popularitatii acestui limbaj
exista numeroase site-uri Web care prezinta informatii despre PHP, exemple de cod, forum de
discutii , etc.

_______________________________________________________________________________________________

Limbajul PHP reprezinta o tehnologie server, de aceea el nu poate fi folosit pentru operatii pe
partea de client . Din acest punct de vedere limbajul PHP nu poate inlocui limbajul Java Script. Pe
de alta parte putem folosi limbajul PHP pentru a generera cod Java Script.

O secventa de cod PHP incepe intotdeauna cu caracterul escape : <?php , urmat de una sau mai
multe instructiuni PHP. Sfarsitul secventei de cod PHP este marcat de caracterul escape : ?>.

In acest fel serverul Web va identifica secventele <?php si ?> si va interpreta tot ce se afla in
interiorul acestor doua secventa ca si cod PHP. Pentru a vedea daca serverul Web este configurat
astfel incat sa interpreteze codul PHP putem crea un fisier simplu ( folosind un editor de text, de
exemplu Notepad), iar in acest fisier vom scrie urmatoarea secventa:

<?php
phpinfo();
?>

Salvam acest fisier cu numele de : phpinfo.php in directorul pentru documente Apache, in general
acest director se numeste htdocs si se gaseste in directorul unde a fost instalat serverul Apache.
In acest moment deschideti browserul de pe sistemul dvs., iar ca adresa URL introducem :
http://localhost/phpinfo.php; ar trebui sa vedeti o pagina Web cu informatiile de configurare a
modulului PHP.

1.2.Crearea unui script PHP

Codul PHP poate fi inserat intr-un fisier HTML, de aceea, pentru inceput, vom crea o pagina HTML
asupra careia vom face unele modificari:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head><title>Test</title> </head>
<body>
<?php
echo <p>Bun venit la site-ul nostru !!! <p>;
?>
</body>
</html>
Dupa cum observati am inserat in aceasta secventa de cod HTML o secventa de cod PHP, care
incepe cu secventa <?php si se termina cu secventa ?>.

Elementul echo reprezinta o instructiune a limbajului PHP si va instrui serverul Web sa insereze
secventa: <p>Bun venit la site-ul nostru !!! <p> in codul HTML.

Astfel secventa HTML generata de serverul Web va fi urmatoarea:
Secventa sfarsit cod
PHP
Instuctiune PHP
Secventa pentru
start cod PHP
_______________________________________________________________________________________________

<html>
<head><title>Test</title></head>
<body>
<p>Bun venit la site-ul nostru !!! <p>
</body>
</html>

In realitate nu avem nevoie de PHP pentru a genera o secventa atat de simpla de cod HTML.

In exemplul urmator vom declara citeva variabile PHP, dupa care vom insera continutul acestora
in codul HTML:

<?php
//Declaram cateva varibile
$site_title = "My Site";
$bg_color = "white";
$user_name = "Popescu Ion";
?>
<html>
<head>
<title><?php echo $site_title; ?></title>
</head>
<body bgcolor=<?php print $bg_color; ?> >
<?php
echo "<p>Salut ".$user_name."<br>";
echo "Astazi este:".date("F d, Y");
?>
</body>
</html>

Salvam acest fisier sub numele test1.php, dupa care deschidem browserul iar ca adresa folosim
http://localhost/test1.php. In fereastra browserului va fi incarcata o pagina ca in figura de mai jos:

Observam cum variabilele declarate in prima sectiune de cod PHP au fost utilizate pentru a
genera cod HTML corespunzator.

_______________________________________________________________________________________________

Capitolul 2. ELEMENTE DE BAZA ALE LIMBAJULUI PHP

2.1.Tipuri de variabile

In limbajul PHP exista 8 tipuri pricipale de variabile: boolean, integer, float, string, array, object,
resource, NULL.

In mod normal, tipul variabilelor nu este specificat explicit; acesta va fi evaluat de catre
interpretorul PHP la momentul run-time (in momentul executarii scriptului).

De exemplu secventa urmatoare:

<?php
$boolVar = TRUE; // o variabila de tip boolean
$intVar = 200; // o variabila de tip integer
$strVar = Popescu Ion; // o variabila de tip string
echo gettype($boolVar); // afiseaza boolean
echo gettype($strVar); // afiseaza string
if (is_int($intVar)) { // daca variabila $intVar este de tip integer
$intVar += 100; // adauga 100 ; noua valoare va fi $intVar = 300;
}
echo dump_var($strVar); // afiseaza tipul si valoarea variabilei $strVar
?>

defineste trei variabile, tipurile acestora sunt respectiv: boolean, intreg respectiv string. Putem
afla tipul unei variabile folosind functia gettype() care returneaza un string continand tipul
variabilei cercetate.

Functia is_int() returneaza TRUE daca variabila furnizata ca parametru este de tip integer. Alte
functii similare sunt : is_string(), is_bool().

Functia dump_var() afiseaza tipul si valoarea unei variabile si este folosita de obicei in scopul
depanarii codului PHP.

Tipul boolean variabilelele de tipul boolean pot lua doar doua valori : FALSE sau TRUE

<?php
$boolVar = TRUE; // aceste doua declaratii
$boolVar1 = True; // sunt echivalente
$boolVar2=FALSE; // Expresiile TRUE si FALSE sunt case-insensitive
$boolVar3=False;
echo dump_var($strVar); // afiseaza tipul si valoarea variabilei $strVar
?>

In exemplul de mai sus am declarat patru variabile de tipul boolean. Se observa ca putem initializa
valoarea variabilelor folosind literalele TRUE sau True, respectiv FALSE sau False; nu se face
distinctie aici intre literele mari sau mici.

_______________________________________________________________________________________________

Variabilele de alt tip decat boolean pot fi convertite la tipul boolean prin operatorul cast (bool) .
Urmatoarele valori vor fi convertite implicit in variabile booleene cu valorea false:
- variabile booleene cu faloarea false
- variabile intregi cu valoarea 0
- variabile float cu valoarea 0.0
- variabile string cu continut nul :
- variabile array (tablou) cu numar de elemente zero
- obiecte cu numar de membrii zero
- tipul special NULL , folosit in general pentru referinte spre obiecte

<?php
var_dump( (bool) 0); // bool(false)
var_dump( (bool) ); // bool(false)
var_dump( (bool) 1); // bool(true)
var_dump( (bool) mystring); // bool(true)
?>

Tipul integer reprezinta numere, ele pot fi specificate in format zecimal, hexazecimal sau octal.
In tabelul urmator prezentam cateva declaratii de variabile intregi:

<?php
$var1 = 215678; //Numar in reprezentare zecimala
$var2 = 0x1A8; //Numar in reprezentare hexazecimala
//reprezinta: 1*16*16 + 10*16 + 8 = 424 (in zecimal)
$var3 = 067; //reprezinta: 6*8 + 7 = 55 (in zecimal)
?>

Valorile minime, respectiv maxime pe care le poate lua o variabila de tip integer depind de
sistemul de operare pe care ruleaza modulul PHP. De exemplu pentru un sistem Windows
valoarea unui integer se memoreaza pe 32 de biti: 31 bit pentru numar si un bit pentru semn. In
acest caz valorile unui intreg se afla in intervalul :-2
13
repectiv: 2
13
.

Daca incercam sa folosim un integer cu valori care ies din acest inteval vo avea de-a face cu un
fenomen de depasire : integer overflow. In acest caz interpretorul PHP converteste acesta valoare
intr-o valoare de tip float (care are un interval mai extins de valori).

In PHP simpla impartire a doua valori intregi va produce ca rezultat o variabila de tip float. Pentru
a obtine doar partea intreaga a acestui rezultat putem folosi operatorul cast (int).Pentru a rotunji
rezultatul la intregul cel mai apropiat de valoarea reala folosim functia round() :

<?php
var_dump(25 / 7); //float(3.5714285714286)
var_dump((int)25 / 7); //int(3)
var_dump(round(25 / 7)); //float(4)
?>

Tipul float reprezinta variabile de tip real. De exemplu:

_______________________________________________________________________________________________

<?php
$var1 = 234.4324356; //variabila de tip float
$var2 = 1.2e3; //reprezinta :1.2 * 10
3

$var3 = 8E-10; //reprezinta : 8*10
-10

?>

Tipul string reprezinta o insiruire de caractere, fiecare caracter este memorat pe 1 byte; setul de
caractere este limitat la 256 valoari distincte. Dimensiunea sirurilor poate fi oricat de mare in PHP,
nu exista specificatii care sa limiteze numarul maxim de caractere dintr-un sir.

In PHP, un sir poate fi declarat in mai multe feluri:
prin delimitare cu ghilimele simple: '
prin delimitare cu ghilimele duble: "
prin sintaxa heredoc

Delimitarea cu ghilimele simple este cea mai simpla reprezentare a sirurilor de caractere in PHP.
Daca dorim ca sirul sa contina caracterul ' va trebui sa folosim inseram inaintea lui caracterul
escape \. Daca dorim ca sirul sa contina caracterul \ va trebui sa dublam acest caracter. Aceast
comportament este exemplificat in exemplul urmator:

<?php
$var1 = ' Acesta este un sir de test'; //variabila de tip sir
echo $var1; // afiseaza : Acesta este un sir de test
echo 'Institultul \'Multimedia\''; // afiseaza : Institutul 'Multimedia'
echo 'Vrei sa stergi C:\\*.* ?'; // afiseaza Vrei sa stergi C:\*.* ?
echo 'Variabila var1=$var1'; // afiseaza : Variabila var1=$var1
?>

Dupa cum se observa in ultima linie variabila $var1 nu este expandata adica nu va fi afisat:
Variabila var1=Acesta este un sir de test. Pentru a realiza acest lucru se folosesc ghilimelele duble.
Delimitarea cu variabile duble permite expandarea valorilor variabilelor continute in sir. Pe de alta
parte sunt recunoscute urmatoarele caractere ESCAPE:

\n Linie noua
\r Carriage return ( rand nou)
\t Tab orizontal
\\ backslash
\$ Semnul dolar
\" Ghilimele duble

Daca un caracter dolar: $ va fi intalnit in sirul de caractere delimitate cu ghilimeme duble, PHP va
analiza urmatoarele caractere incercand sa gaseasca o variabila cu acelasi nume declarata
anterior. Daca va fi gasita valoarea acestei variabile va inlocui sirul $(nume variabila). Acest lucru
este exemplificat in exemplul urmator:

<?php
$var1 = 'Popescu';
echo "Candidatul $var1 a fost admis"; // afiseaza: Candidatul Popescu a fost admis
echo "Candidatul $var1a fost admis"; // afiseaza: Candidatul $var1a fost admis
_______________________________________________________________________________________________

echo "Candidatul ${var1}a fost admis"; // afiseaza: Candidatul Popescua fost admis
?>

In anumite situatii pentru a nu da nastere la confuzii este bine sa includem numele variabilelor
intre acolade {} ; in acest caz vom fi siguri ca interpretorul PHP va folosi numele corect al
variabilelor.

Pe langa imbricarea variabilelor in cadrul sirurilor delimitate prin ghilimele duble, PHP pune la
dispozitie operatorul de concatenare a sirurilor: .(punct) . Acest operator adauga un sir la sfarsitul
altui sir . De exemplu:

<?php
$nume = 'Popescu';
$prenume='Ion';
echo 'Numele de familie este '.$nume. 'iar prenumele este '.$prenume;
?>

In acest caz ultima linie de cod va afisa: Numele de familie este Popescu iar prenumele este Ion.
Se observa cum operatorul de concatenare a sirurilor combina textul predefinit cu variabilele
declarate anterior.

In anumite situatii este necesar sa accesam unul dintre caracterele unui sir. Pentru aceasta putem
folosi parantezele{} ca in exemplul de mai jos:

<?php
$var1 = ' Acesta este un sir de test'; //variabila de tip sir
echo $var1{0}; // afiseaza A (primul caracter din sir)
echo $var1{1}; // afiseaza c ( al doilea caracter din sir)
$var1{0} = 'C'; // modifica primul caracter din sir la valoarea C
?>

Functii importante pentru manipularea sirurilor:
- strlen($var1) retuneaza lungimea sirului $var1
- string ltrim ( string str) elimina caracterele spatiu de la inceputul sirului
- string rtrim ( string str) elimina caracterele spatiu de la sfarsitul sirului
- int strncmp ( string str1, string str2, int len ) compara primele len caractere din cele doua
siruri
- string strtolower ( string str ) converteste la setul de caractere mici
- string strtoupper ( string str ) converteste la caractere mari
- string strtr ( string str, string from, string to ) translateaza un sir
- int stripos ( string haystack, string needle [, int offset] ) gaseste prima aparitie a sirului needle in
sirul haystack

In continuare exemplificam folosirea acestor functii:

<?php
$var1 = ' Sir de test'; //variabila de tip sir
echo $var1; // afiseaza: Sir de test
echo ltrim($var1); // afiseaza:Sir de test
$var2 = ' Sir de test modificat'; //variabila de tip sir
_______________________________________________________________________________________________

echo strncmp($var1,$var2,strlen($var1)) // afiseaza 0
$var3 = 'CarAcTere MixTe';
echo strtolower($var3); // afiseaza: caractere mixte
echo strtoupper($var3); // afiseaza : CARACTERE MIXTE
$var4 = strtr($var4, 'Files', 'Fiiere'); // inlocuieste in $var4 toate aparitiile sirului Files
// cu valoarea translatiei: Fiiere
echo $var4;
echo stripos($var1, 'de'); // afiseaza 9
echo stripos($var1, 'Sururi'); // afiseaza false
?>

Sintaxa heredoc este o alta modalitate de a delimita siruri. In acest caz delimitatorul este ("<<<");
acesta trebuie urmat de un identificator unic, dupa care urmeaza sirul de caractere, iar secventa
se incheie din nou cu identificatorul mentionat. Identificatorul de incheiere trebie sa se afle in
prima coloana a liniei, acesta poate contine caractere alfanumerice dar neaparat trebuie sa
inceapa cu o litera , nu cu o cifra sau alt semn.

Exemplu:
<?php
$var1 = <<< EOT
Exemplu de sir care
foloseste delimitatorul
heredoc.
EOT;
echo $var1; //afiseaza: Exemplu de sir care
// foloseste delimitatorul heredoc.
?>

Tipul array reprezinta un vector de valori, fiecare element al vectorului are asociata o cheie.
Aceasta cheie va fi folosita ulterior la identificarea unui element specific at vectorului. In PHP tipul
array se mai numeste si tip map ordonat , deoarece elemente vectorului sunt ordonate dupa
campul cheie.

O variabila de tip array se poate declara in mai multe feluri:
<?php
$fructe[3];
$fructe[0] = 'mere';
$fructe[1] = 'pere';
$fructe[2] = 'cirese';
//Variabila $fructe de mai sus se mai poate declara si astfel:
$fructe1 = array("mere", "pere", "cirese");

//Referirea elementelor se face in felul urmator:
echo $fructe[0]; // afiseaza mere
echo $fructe[1]; // afiseaza pere
echo $fructe[2]; // afiseaza cirese
echo $fructe1[0]; // afiseaza mere
echo $fructe1[1]; // afiseaza pere
?>
Cheile pot avea valori intregi sau pot fi siruri de caractere; este posibil sa mixam chei intregi si de
tip caracter, ca in exemplul urmator:

_______________________________________________________________________________________________

<?php
$myArray = array( 10 => 200, 20 => 400, "a" => 600);

echo $myArray[10]; //afiseaza 200
echo $myArray[20]; //afiseaza 400
echo $myArray["a"]; //afiseaza 600

//Variabila $fructe de mai sus se mai poate declara si astfel:
$fructe1 = array("mere", "pere", "cirese");

//Referirea elementelor se face in felul urmator:
echo $fructe[0]; // afiseaza mere
echo $fructe[1]; // afiseaza pere
echo $fructe[2]; // afiseaza cirese
echo $fructe1[0]; // afiseaza mere
echo $fructe1[1]; // afiseaza pere
unset($myArray[20]]; // sterge elementul cu cheia 20 din array
unset($myArray); // strege elementul myArray in intregime
?>

Este posibil ca un element al vectorului sa fie de asemenea de tip array. In acest caz avem de-a
face cu un array multidimensional:

<?php
$multiDimArray = array("firstLine" => array(1 =>10, 2 => 20, "a" =>"alpha"));
$multiDimArray["nextLine"] = array(1 =>20, 2 => 40, "b" =>"beta");
echo $multiDimArray["firstLine"][1]; //afiseaza 10
echo $multiDimArray["nextLine"][1]; //afiseaza 20
echo $multiDimArray["firstLine"][2]; //afiseaza 20
echo $multiDimArray["firstLine"]["a"]; //afiseaza alpha
echo $multiDimArray["nextLine"]["b"]; //afiseaza beta
?>

In cazul de mai sus am declarat un array cu 2 linii si 3 coloane.Prima linie este identificata de
array-ul cu numele fisrtLine, iar ce-a de-a doua linie este identificata de nextLine.

Tipul object reprezinta de fapt instanta unei clase declarate in PHP. O cllasa este o structura
care contine variabile membru si functii membru. De exemplu declaram o clasa care
Memoreaza datele personale ale unui user:

<?php
class PersUI = {
var $name=null;
var $adresaEmail=null;
var $logged=null;
//PersUI constructor
function PersUI() {
$name="";
$adresaEmail=";
$logged=FALSE;
}
//functie pentru setarea numelui
function setName($aName) {
$name=$aName;
_______________________________________________________________________________________________

}
//functie pentru obtinerea numelui
function getName() {
return $name;
}
function setAdresaEmail($emailAdress) {
$adresaEmail = $emailAdress;
}
function getAdresaEmail() {
return $adresaEmail;
}
function isLogged() {
return $logged;
}
}
$myPers = new PersUI();
$myPers->setName("Ionescu");
$myPers->setAdrresaEmail("Ionescu@yahoo.com");
echo $myPers->getName(); // Afiseaza Ionescu
echo $myPers->getAdresaEmail(); // Afiseaza Ionescu@yahoo.com
echo $myPers->isLogged(); // Afiseaza false
?>

Declaratia clasei incepe cu variabilele membru : name, adresaEmail, logged care initial au valoarea
null, adica nu sunt initializate( nu au nici un fel de valoare asociata).

Urmeaza portiunea unde sunt declarate functiile; acestea pot avea un argument sau pot fi fara
argumente. De exemplu functia setName($aName) va asocia variabilei membru $name valoarea
continuta in varibila furnizata ca parametru : $aName;
Functia getName() nu are nici un parametru dar ea returneaza valoarea continuta in variabila
$nume.

Crearea unui obiect de tipul PersUI se face prin linia: $myPers = new PersUI; myPers este o
variabila de tip obiect si reprezinta o instanta a clasei PersUI.

Tipul resource este un tip special de variabila care pastreaza o legatura spre resurse externe.
Exemple de resurse externe: manipulatori pentru deschidere de fisiere, conectare la baze de date,
compresia fisierelelor, resurse COM, etc...

Odata cu PHP 4.0 a fost introdus un mecanism care elibereaza automat memoria alocata pentru
referintele care nu mai sunt referite in program. Acest mecanism se numeste garbage collection
(colectorul de gunoaie) ; un mecanism similar functioneaza in limbajul Java.

Tipul NULL reprezinta varibilele care nu au inca atribuita o valoare.
O variabila se considera a avea valoarea Null daca
- este setata explicit prin atribuirea valorii NULL
- nu a fost asignata inca o valoare acestei variabile
- varibila a fost stearsa prin functia unset();

2.2.Declararea variabilelor in PHP

_______________________________________________________________________________________________

In limbajul PHP variabilele sunt reprezentate prin semnul $ urmat de numele variabilei. Numele
variabilei este case sensitive, adica conteaza faptul ca numele este scris cu litere mari sau mici.
Intotdeuna numele variabilelor incepe cu o litera sau underscore(_) si poate fi urmat de litere sau
cifre. In PHP tipul variabilelor se specifica in momentul declararii lor:

<?php
$varInt = 12371; //variabila de tip integer
$varBool = TRUE; //variabila de tip boolean
$varStr = "sir de test"; //variabila de tip string
$myArray = array("alpha","beta","gama"); // variabila de tip array
$var1 = 124;
$var2 = &$var1;
echo $var2;
$var2 = "valoarea lui var2= $var2";
echo $var2; //afiseaza: valoarea lui var3= 124
echo $var1; //afiseaza: valoarea lui var3= 124
?>

In exemplul de mai sus am folosit si o alta metoda de initializare a variabilelor si anume
initializarea prin referinta: $var2 = &$var1; in acest caz variabila var2 va referi zona de memorie
alocata variabilei $var1.In acest caz o modificare facuta asupra lui var2 se va propaga automat si
asupra variabilei var1.

Variabilele declarate mai sus sunt definite de utilizator. In PHP exista si alte variabile numite
variabile predefinite care rezida in nucleul PHP, sunt alocate automat de catre modulul PHP, si
sunt accesibile in program.

In continuare enumeram citeva dintre aceste Variabile Superglobale (accesibile din toate
scripturile PHP):
$GLOBALS contine referinte la variabilele globale disponibile in scriptul curent.
$_SERVER variabile definite de Web Server sau relative la contextul in care se executa scriptul
curent
$_GETvariabile furnizate scriptului via URL
$_POSTvariabile furnizate scriptului prin metoda HTTP POST
$_COOKIE variabile furnizate scriptului via HTTP cookie
$_FILES furnizeaza scriptului fiseierele uploadate
$_SESSION variabile care sunt inregistrate in sesiunea scriptului

2.3.Domeniul de valabilitate al variabilelor

Domeniul de valabilitate al variabilelor(variable scope) reprezinta contextul in care aceste
variabile sunt definite. In afara acestui domeniu variabilele nu exista(nu sunt recunoscute). Sa
consideram urmatorul exemplu in care declaram doua variabilede tip intreg si o functie care
incearca sa faca suma celor doua variabile:

<?php
$var1 = 124;
$var2 = 200;
function makeSum() {
return $var1 + $var2;
_______________________________________________________________________________________________

}
echo makeSum(); //nu afiseaza nimic
?>

Functia makeSum() foloseste variabilele $var1 si $var2 declarate anterior, dar aceste variabile nu
au domeniu de valabilitae in interiorul functiei.Prin urmare rezultatul functiei este NULL. Pentru a
rezolva aceasta problema vom declara cele douva variabile ca fiind externe functiei , adica
variabile globale:
<?php
$var1 = 124;
$var2 = 200;
global $var1,$var2;
return $var1 + $var2;
}
echo makeSum(); //afiseaza 224
?>

In exemplul de mai sus declaratia: global $var1,$var2 face ca variabilele $var1,$var2 sa fie
recunoscute si in interiorul functiei.

O alta metoda prin care putem solutiona aceasta problema este prin folosirea variabilei PHP
predefinite $GLOBALS.

<?php
$var1 = 124;
$var2 = 200;
return $GLOBALS['var1'] + $GLOBALS['var2'];
}
?>

$GLOBALS este de fapt un array ; elementele acestui array au cheia egala cu numele variabilelor
declarate, iar urmatorul cimp egal cu valoarea lor.
$GLOBALS este o variabila superglobala, ea va fi recunoscuta in orice script.

Variabilele declarate in interiorul unei functii se numesc variabile locale functiei si nu au doeniul
de valabilitate in afara functiei. Aceste variabile sunt create pe stiva, de aceea la iesirea din
functie acestea vor fi automat distruse.

<?php
$var1 = 124;
$var2 = 200;
return $var1+ $var2;
}
echo $var1; //nu afiseaza nimic. Variabila $var1 out of scope
echo $var2; //nu afiseaza nimic. Variabila $var2 out of scope
?>
_______________________________________________________________________________________________

O alta categorie importanta de varibile (din punctul de vedere al domeniului) sunt variabilele
statice. Aceste variabile sunt valabile in domeniul functiei unde au fost declarate , dar au
proprietatea ca valaorea lor nu se altereaza la un apel succesiv al functiei:

<?php
function increment() {
static $var1 = 0;
$var1++;
return $var1;
}
echo increment(); //afiseaza 1
?>

In anumite situatii avem nevoie ca numele variabilelor sa fie variabil , adica sa putem schimba
numele variabilei in momentul executiei programului (run-time). In acest scop exista asa numitele
variable variables :

<?php
$var1 = 'nume';
$$var1='Ionescu';
echo $var1; // afiseaza nume
echo $nume; // afiseaza Ionescu
echo ${$var1}; // afiseaza Ionescu
?>

Se observa ca a doua declaratie: $$var1='Ionescu' creeaza o noua variabla cu numele $nume si ii
atribuie valoarea 'Ionescu'.

2.4.Operatori

Operatorii sunt simboluri specifice care realizeaza o actiune specifica in cadrul unei expresii.
Operatorii actioneaza asupra variabilelor prezente in expresie. De exemplu in cadrul expresiilor
matematice vom folosi operatori aritmetici.

Exemple de operatori aritmetici:
$a + $b Adunare : a+b
$a - $b Scadere : a-b
$a * $b Inmultire: a*b
$a / $b Impartire: a/b
$a%$a Moule :restul impartirii lui a la b
$a +=$b Echivalent cu: $a = $a + $b
$a -=$b Echivalent cu: $a = $a - $b
$a *=$b Echivalent cu: $a = $a * $b
$a /=$b Echivalent cu: $a = $a / $b
$a++ Incrementare ; Ecivalent cu $a = $a +1
$a-- Decrementare; Echivalent cu $a = $a -1

_______________________________________________________________________________________________

Operatori pe siruri actioneaza asupra sirurilor de caractere:

<?php
$var1 = 'Ionescu';
echo 'Numele candidatului este '.$var1; //Afiseaza Numele candidatului este Ionescu
$var2 = 'Candidat: ';
$var2 .= $var1;
echo $var2; //Afiseaza: Candidat: Ionescu
?>

In exemplul de mai sus se observa folosirea operatorului de concatenare . (punct)
Acest operator adauga la sfarsitul sirului curent noul sir furnizat ca parametru.
Expresia $a .= 'Sir de test' este echivalenta cu : $a = $a . 'Sir de test'.

Operatori logici sunt folositi pentru a lua decizii la un moment dat in program . Rezultatul
operatorilor logici este o variabila de tip boolean , care poate fi folosita ulterior in instructiuni
conditionale (if , asa cum vom vedea in continuare)

$a && $b TRUE daca a si b sunt TRUE
$a AND $b TRUE daca a si b sunt TRUE
$a || $b TRUE daca a sau b sunt TRUE
$a OR $b TRUE daca a sau b sunt TRUE
$a TRUE daca $a=FALSE
NOT $a TRUE daca $a=FALSE
$a XOR $b TRUE daca numai $a sau numai $b sunt TRUE
$a == $b TRUE daca $a=$b
$a = $b TRUE daca $a diferit de $b
$a < $b TRUE daca $a mai mic ca $b
$a <= $b TRUE daca $a mai mic sau egal cu $b
$a > $b TRUE daca $a mai mare ca $b
$a >=$b TRUE daca $a mai mare sau egal cu $b

Operatori pe biti sunt folositi pentru a realiza operatii logice pe biti asupra operanzilor.
$a & $b And logic pe biti intre a si b
$a | $b Sau logic pe biti intre a si b
$a ^ $b XOR (Exclusive OR) pe biti intre a si b
~$a Negare pe biti 01; 10
$a >> $b Deplasare cu $b biti la dreapta a operandului $a
$a << $b Deplasare cu $b biti la stanga a operandului $a

_______________________________________________________________________________________________

2.5. Structuri de control

reprezinta de fapt instructiuni PHP care permit programatorilor luarea de decizii privind
executia codului.

2.5.1. Instructiunea IF

If(conditie) {
Instructiune(1);
Instructiune(2);
..................
}

Dupa cum se observa, dupa if urmeaza o pereche de paranteze rotunde in interiorul carora se
plaseaza conditia, adica o expresie logica a carei rezultat poate fi TRUE sau FALSE. Daca rezultatul
expresiei logice este true, se vor executa instuctiunile: Instructiune(1), apoi Instructiune(2), etc...
Se observa ca acest set de instructiuni se plaseaza intre acolade. Doar intr-un singur caz aceste
acolade nu sunt necesare si anume: in cazul in care setul de instructiuni contine doar o singura
instructiune.

Daca rezultatul expresiei logice dintre paranteze rotunde este FALSE, setul de instructiuni dintre
acolade nu se va executa, controlul programului va fi plasat la instructiunea care urmeaza dupa
acolada:}.

Instructiunea if poate fi completata cu clauza : else, dupa cum urmeaza:

If(conditie) {
Instructiune(1);
Instructiune(2);
..................
}
else {
Instructiune(01);
Instructiune(02);
..................
}

In acest din urma caz, daca expresia logica conditie este adevarata se vor executa
instructiunile: Instructiune(1); Instructiune(2); , iar daca valoarea expresiei logice : conditie are
valoarea FALSE se vor executa instructiunile: Instructiune(01); Instructiune(02);

Clauza else poate fi urmata de asemenea de o instructiune if :

If(conditie1) {
Instructiune(1);
Instructiune(2);
..................
_______________________________________________________________________________________________

}
else If(conditie2) {
Instructiune(01);
Instructiune(02);
..................
}
else {
Instructiune(001);
Instructiune(002);
..................
}

In acest caz daca conditie1 este TRUE se executa Instructiune(1), respectiv Instructiune(2);

Daca conditie1 este FALSE, dar conditie2 este TRUE se executa: Instructiune(01), respectiv
Instructiune(02);

Daca conditie1 este FALSE si conditie2 este FALSE se executa : Instructiune(001), respectiv
Instructiune(002).

In continuare vom vedea cum se foloseste instructiunea if pentru a compara valorile a doua
variabile numerice:

<?php
if($a > $b) {
echo 'Valoarea variabiei a este mai mare ca variabila b';
}
else if($a == $b) {
echo 'Valoarea variabilei a este egala cu variabila b';
}
else {
echo 'Valoarea variabilei a este mai mica decat cea a variabilei b';
}
?>

In exemplul de mai sus am presupus ca variabilele $a si $b sunt create anterior si au valori
numerice.

Observatie: in locul instructiunii compuse else if(conditie ) se poate folosi clauza elseif.

In cazul in care vrem sa comparam valoarea unei singure variabile cu o succesiune de valori, in
locul instructiunii if putem folosi instructiune switch:
<?php
switch($a) {
case 0:
echo 'Valoare variabilei $a este 0';
break;
_______________________________________________________________________________________________

case 1:
break;
case 2:
break;
case 3:
break;
}
?>

Executia instructiunii switch continua pana cand se intalneste o valoare corespunzatoare pentru
variabila $a. In acest caz, se afiseaza un mesaj, iar daca instructiunea este urmata de clauza:
break; instructiunea switch se va sfarsi. De retinut ca instructiune break; opreste executia
instructiunii switch.

Variabila $a poate avea si tipul string, de exemplu; in aest caz valorile cu care se compara vor avea
de asemenea tipul string.

Structuri de control repetitive (cicluri):
- while
- do-while
- for
- foreach

2.5.2. Instructiunea WHILE

Instructiunea while executa un set de instructiuni atata timp cat valoarea expresiei: conditie este
adevarata:

while(conditie) {
Instructiune(1);
Instructiune(2);
Instructiune(3);
.............
}

Setul de instructiuni Instructiune(1), Instructiune(2), etc... se vor executa atata timp cat valoarea
expresiei logice : conditie are valoarea TRUE.
<?php
$iCrt=0;
while($iCrt < 10) {
echo 'Valoare variabilei $iCrt este:'.$iCrt;
$iCrt++;
}
?>
_______________________________________________________________________________________________

Secventa de mai sus va genera urmatoarea secventa:
Valoare variabilei $iCrt este:0

Se observa ca ciclul are 10 iteratii, instructiunea $iCrt++; este echivalenta cu $iCrt=$iCrt+1, si
incrementeaza valoarea variabilei $iCrt cu 1.

Executia ciclului while poate fi oprita cu instructiunea break:
<?php
$iCrt=0;
while($iCrt < 10) {
if($iCrt >5) {
break;
}
$iCrt++;
}
?>
In cazul de mai sus , in momentul in care valoarea variabilei $iCrt este mai mare ca 5 se va executa
instructiune break; care opreste executia ciclului while.

2.5.3. Instructiunea DO-WHILE

Instructiunea do-while se aseamana cu instructiunea while de mai sus, dar in acest caz conditia se
testeaza la sfarsitul ciclului, cel putin o data. Sintaxa instructiunii este urmatoarea:
do {
Instructiune(1);
Instructiune(2);
Instructiune(3);
.............
} while(conditie);
<?php
$iCrt=0;
do {
$iCrt++;
} while($iCrt < 10);
?>
In exemplul de mai sus instructiunile dintre acolade {} se vor executa de 10 ori.
_______________________________________________________________________________________________

2.5.4. Instructiunea FOR

Sintaxa generala a instructiunii for este urmatoarea:

for(expresie1; conditie; expresie2) {
Instructiune(1);
Instructiune(2);
Instructiune(3);
.............
}

expresie1 se executa o singura data si anume la inceputul instructiunii;
conditie este o expresie logica ; instructiunea for se executa atita timp cat valoarea expresiei :
conditie are valoarea TRUE.

De fiecare data dupa executia instructiunilor dintre acolade se executa : expresie2.

Exemplu:
<?php
for($iCrt=0; $iCrt < 10 ; $iCrt++) {
}
?>

Exemplul de mai sus produce acelasi rezultat ca si ciclul while discutat mai sus. Se observa ca in
acest caz instructiunea este mai compacta, initializarea variabilei si incrementarea se executa intr-
o singura instructiune.

La fel ca si in cazul instructiunilor while sau do-while, se poate folosi clauza for pentru a opri
executia instructiunii for:
<?php
for($iCrt=0; $iCrt < 10 ; $iCrt++) {
if($iCrt >5) {
break;
}
}
?>
In acest caz , in momentul in care variabila $iCrt are valoarea 6 (mai mare ca 5) , executia ciclului
for se va stopa.

2.5.5. Instructiunea FOREACH

Aceasta instructiune a fost introdusa pentru a usura manipularea variabilelor de tip array. Sintaxa
generala a instructiunii foreach este urmatoarea:
foreach(expresie_array as $valoare) {
_______________________________________________________________________________________________

Instructiune(1);
Instructiune(2);
Instructiune(3);
.............
}
sau:
foreach(expresie_array as $key =>$valoare) {
Instructiune(1);
Instructiune(2);
Instructiune(3);
.............
}
In primul caz pentru fiecare element din array se va asocia valoarea variabilei : $valoare, iar dupa
fiecare executie a instructiunilor se va face trecerea la urmatorul element din array.

In cel de-al doilea caz pentru fiecare element din array se va face asocierea cheie-array cu
variabila $key si valoare-element-array cu $valoare.
<?php
$arr = array(0, 1, 2, 3, 4, 5);
foreach($arr as $iCrt) {
echo 'Elementul current este:'.$iCrt;
}
?>

In anumite situatii este util sa aflam perechea cheie=>valoare a fiecarui element din array:

<?php
$arr = array('zero', 'unu', 'doi', 'trei', 'patru', 'cinci');
foreach($arr as $key => $iCrt) {
echo 'Cheia curenta este:'.$key;
echo 'Elementul current este:'.$iCrt;
}
?>

In cazul tablourilor multidimensionale , putem parcurge elementele din array in felul urmator:

<?php
$multiDimArray = array("firstLine" => array(1 =>10, 2 => 20, "a" =>"alpha"));
$multiDimArray["nextLine"] = array(1 =>20, 2 => 40, "b" =>"beta");
foreach($multiDimArray as $lines) {
foreach($lines as $columns) {
echo 'Elementul curent este:'. $columns;
}
}
?>
_______________________________________________________________________________________________

2.6. Utilizarea matricelor

Matricele sunt create folosind sintaxa array(). In acest sens notiunile de array si matrice au acelasi
inteles. Fiecare element al unei matrici are doua elemente importante: cheia si valoarea
elementului. PHP pune la dispozitia utilizatorului un set de functii pentru sortarea matricelor.

Sortarea dupa valoare:

Consideram urmatorul exemplu:
<?php
$arr = array(0=>'Popescu', 1=>'Avram', 5=>'Cristian',3=>'Dan');
echo '<br>Matrice initiala';
foreach($arr as $key=>$nume) {
echo '<br>Cheie='.$key.' Valoare='.$nume;
}
sort($arr);
echo '<br>Matrice sortata dupa valoare';
}
?>
Codul PHP de mai sus va produce urmatorul rezultat:
Matrice initiala
Cheie=0 Valoare=Popescu
Cheie=1 Valoare=Avram
Cheie=5 Valoare=Cristian
Cheie=3 Valoare=Dan
Matrice sortata dupa valoare
Cheie=2 Valoare=Dan

Se observa ca instructiunea sort($arr) sorteaza matricea $arr dupa campul valoare (ordine
alfabetica). Observam de asemenea ca valorile campului cheie au fost alterate.

Daca dorim sa sortam aceasta matrice in ordine inversa folosim functia arsort() :

<?php
}
rsort($arr);
_______________________________________________________________________________________________

}
?>
Acest cod va produce urmatorul rezultat:
Matrice initiala
Cheie=3 Valoare=Dan
Cheie=1 Valoare=Dan
Se observa ca si in acest caz au fost alterate valorile initiale ale cheilor.

Pentru a sorta matricea $arr pastrand corelarea initiala dintre valori si cheile corespunzatoare se
folosesc functiile asort() , respectiv arsort()
<?php
}
asort($arr);
}
?>

Matrice initiala
Cheie=3 Valoare=Dan
Cheie=3 Valoare=Dan

In anumite situatii este nevoie de a sorta elementele matricei dupa valoarea cheilor. In acest caz
folosim functiile ksort(), respective krsort(), care pastreaza corespondenta dintre valori si cheile
corespunzatoare:
<?php
_______________________________________________________________________________________________

}
ksort($arr);
}
?>

Matrice initiala
Cheie=3 Valoare=Dan
Cheie=3 Valoare=Dan

Transformarea sirurilor in matrice si invers:
PHP pune la dispozitia utilizatorilor functii pentru conversia dintre siruri si matrice, utile atunci
cand valorile matricelor trebuie memorate in baza de date.

Pentru a transforma un sir intr-o matrice folosim functia explode(). Sintaxa aceste functii este:
$matrice = explode(' ', $sir);

<?php
$sir = 'Popescu Avram Cristian Dan';
$matrice = explode(' ',$sir);
foreach($matrice as $key=>$nume) {
}
?>
Cheie=3 Valoare=Dan

In continuare, folosind exemplul de mai sus sortam matricea $matrice alfabetic si apoi transferam
matricea intr-un alt sir , de aceasta data sortat:
<?php
_______________________________________________________________________________________________

$sir = 'Popescu Avram Cristian Dan';
$matrice = explode(' ',$sir);
foreach($matrice as $key=>$nume) {
}
sort($matrice);
$sir_sortat = implode(' ',$matrice);
echo '<br> Sirul rezultat: '.$sir_sortat;
?>

Cheie=3 Valoare=Dan

Sirul rezultat: Avram Cristian Dan Popescu
_______________________________________________________________________________________________

Capitolul 3. FUNCTII PHP

CUPRINS
Apelarea functiilor care accepta argumente
Folosirea functiilor care returneaza o valoare
Definirea valorilor implicite ca argumente ale functiei
Variabile interne functiilor, domeniul de valabilitate al variabilelor

Functiile reprezinta secvente de cod care sunt apelate foarte frecvent in cadrul codului PHP.
Folosirea intensiva a functiilor contribuie la o structurare mai buna a codului: o problema
complexa poate fi divizata in mai multe sub-probleme, fiecare astfel de sub-problema fiind
executata in cadrul unei functii.

Pe de alta parte, folosirea frecventa a functiilor duce la micsorarea cantitatii de cod scris; prin
urmare vom avea un cod care se executa mai eficient.

In PHP functiile incep intotdeauna cu declaratia: function, ca in exemplul ca urmeaza:

<?php
/******************************
Function makeSum
Parameters: $a : integer
$b : integer
Returns: integer
******************************/
function makeSum($a, $b) {
return $a + $b;
}
$a = 10;
$b = 126;
$c = makeSum($a,$b);
?>

In exemplul de mai sus am declarat functia makeSum care accepta doi parametrii de tip integer:
$a si $b. Functia returneaza de asemenea o valoare de tip integer. Argumentele care se trimit
functiei se delimiteaza prin virgula: ,.

Functia din exemplul urmator calculeaza suma elementelor dintr-un array:

<?php
/******************************
Function sumArray
Parameters: $arr : array
Returns: integer
******************************/
_______________________________________________________________________________________________

function sumArray($arr) {
$total=0;
foreach($arr as $val) {
$total += $val;
}
return $total;
}
$arr = array(0=>356,1=>125,2=>543243,3=>12,4=>1643,5=>432,6=>7775);
foreach($arr as $cheie=>$val) {
echo "<br>Elemenul $cheie Valoare=$val";
}
echo " <br>Suma elementelor din array este ".sumArray($arr);
?>

In exemplul de mai sus functia sumArray are un singur parametru de tip array(). In interiorul
functiei declaram o variabila locala: $total, care initial are valoarea 0. In continuare cu ajutorul
instructiunii foreach parcurgem array-ul: $arr si aduna la valoarea $total valoarea
corespunzatoare elemetului curent din array. La final functia va returna valoarea $total care
reprezinta de fapt suma elementelor din array.

In anumite situatii este necesar sa modificam continutul variabilelor transmise ca parametru
functiei. Consideram exemplul de mai sus in care ne propunem sa modificam valoarea primului
element din array cu valoarea rezultata din suma:

<?php
/******************************
Function sumArray
Parameters: $arr : array
Returns: integer
******************************/
function sumArray($arr) {
$total=0;
$total += $val;
}
$arr[0] = $total;
return $total;
}
$arr = array(0=>356,1=>125,2=>543243,3=>12,4=>1643,5=>432,6=>7775);
}
echo " <br>arr[0] = $arr[0]; // va afisa 356 (nemodificat)
?>
Se observa ca instructiunea: $arr[0] = $total; introdusa in functia de mai sus nu a modificat
valoarea finala a variabilei $arr[0] din tablou. Acest lucru se datoreaza faptului ca in PHP, in mod
_______________________________________________________________________________________________

implicit, argumentele functiei sunt transmise prin valoare. Cu alte cuvinte atunci cand transmitem
o variabila unei functii, interpretorul PHP va realiza o copie a acestei variabile si va transmite
valoarea acesteia din urma functiei.

O alta modalitate de a transmite valori(variabile) unei functii este prin referinta. In acest caz
interpretorul de PHP nu mai realizeaza nici o copie a variabilei, in schimb se transmite functiei
adresa din memorie a variabilei ca parametru:

<?php
/******************************
Function sumArray
Parameters: &$arr : referinta la array
Returns: integer
******************************/
function sumArray(&$arr) {
$total=0;
$total += $val;
}
$arr[0] = $total;
return $total;
}
$arr = array(0=>356,1=>125,2=>543243,3=>12,4=>1643,5=>432,6=>7775);
}
echo " <br>arr[0] = $arr[0]; // va afisa 553586 (modificat)
?>

In exemplul de mai sus argumentul functiei este &$arr, care specifica ca argumentul functiei se
transmite prin referinta. In acest caz instructiunea: $arr[0] = $total; va modifica continutul final al
elementului $arr[0] . Transmiterea argumentelor prin referinta se recomanda in cazul utilizarii ca
argumente a tablourilor cu multe elemente sau al sirurilor continand multe caractere. Folosind
transmiterea argumentelor prin referinta, codul se va executa mai rapid deoarece in cazul unui
tablou, se va transmite doar adresa de memorie unde incepe tabloul in memorie(memorat pe 32
biti) in schimbul transmiterii intregului tablou de valori.

In cazul transmiterii mai multor parametri, este posibil sa specificam anumite valori implicite
pentru unele din argumentele functiei:
<?php
/******************************
Function cafeaFavorita
Parameters: $type: string
Returns: nothing
******************************/
function cafeaFavorita($type="espresso") {
_______________________________________________________________________________________________

echo "<br>Cafeaua mea favorita este $type";
}
echo cafeaFavorita(); // afiseaza Cafeaua mea favorita este espresso
echo cafeaFavorita("capuccino"); // afiseaza Cafeaua mea favorita este capuccino
?>

In exemplul de mai sus instructiunea : Echo cafeaFavorita(); nu are specificat nici un argument, in
acest caz PHP va folosi valoarea implicita a parametrului ( in cazul nostru espresso).

In toate cazurile in care se specifica argumente implicite pentru parametrii unei functii trebuie
tinut cont de faptul ca argumentele cu valorile implicite trebuie plasate la sfarsitul listei de
parametrii. Exemplul urmator este eronat deoarece dupa parametrul cu valoare implicita
urmeaza un alt argument fara valoare implicita:

<?php
/******************************
Function cafeaFavorita
Parameters: $type: string
Returns: nothing
******************************/
function cafeaFavorita( $type="espresso",$producator) {
echo "<br>Cafeaua mea favorita este $type producator $producator";
}
echo cafeaFavorita("BRANCO SRL"); // nu creeaza rezultatul asteptat
?>
Daca schimbam ordinea parametrilor in exemplul de mai sus functia : cafeaFavorita va functiona
conform asteptarilor.

Functiile PHP pot returna o valoare sau rezultatul unei expresii. In exemplul urmator cream
functia ridicareLaPatrat care returneaza valoarea argumentului ridicat la patrat:

<?php
/******************************
Function ridicareLaPatrat
Paramteres: $a: integer
Returns: integer
******************************/
function ridicareLaPatrat ( $a) {
return $a * $a;
}
$a = 12;
echo "$a la patrat egal cu ". ridicareLaPatrat($a);
?>

Functiile pot returna in principiu orice fel de valori, inclusiv valori de tio array, object, sau valori
de tip referinta.

_______________________________________________________________________________________________

Capitolul 4. PHP SI FORMULARELE HTML

4.1. Crearea unui formular

Formularele se creaza folosind eticheta <form> ca in exemplul de mai jos:
<form action="test5.php" method="GET">
Nume:<input type="text" name="nume">
</form>

Fiecare element al formularului trebuie introdus intre etichetele <form> si </form>. Atributul
action indica serverului scriptul care va primi datele de la formular si reprezinta una dintre cele
mai importante precizari.

4.2. Utilizarea metodelor GET si POST

Atributul method poate avea doua valori: GET si POST. Diferenta intre metodele GET si POT
consta in modul in care informatia din formular este transmisa scriptului care o prelucreaza.
Metoda GET trimite toate informatiile adunate ca parte a adresei URL; aceste informatii sunt
vizibile pentru utilizator. Metoda POST transmite informatia intr-o maniera invizibila pentru
utilizator.

Folosind exemplul de formular de mai sus, metoda GET va transmite serverului o adresa ca mai
jos:
http://www.MySite.ro/test5.php?nume=Popescu
iar in cazul folosirii metodei POST:
http://www.MySite.ro/test5.php

Metoda GET permite transmiterea unui volum limitat de informatii catre server; de asemenea nu
este recomandata folosirea acestei metode in cazul in care dorim sa transmitem date personale
(de exemplu parolele introduse intr-un formular pot fi vizualizate de oricine in browser).

Pentru a introduce butoane de tip radio intr-un formular PHP se foloseste eticheta: <input
type=radio> , ca in exemplul de mai jos:
Ocupatia:
<br>Elev< input type="radio" name="ocupatie" value="Elev">
<br>Student< input type="radio" name="ocupatie" value="Student">
<br>Profesor< input type="radio" name="ocupatie" value="Profesor">
</form>

Pentru a introduce un meniu de selectie intr-un formular se foloseste eticheta <select></select> ,
ca in exemplul de mai jos:

_______________________________________________________________________________________________

<?php
$orase = array('Hunedoara','Deva','Calan','Simeria','Orastie');
echo "<select name=orase>";
foreach($orase as $oras) {
echo "<option value=$oras>$oras</option>";
}
echo "</select>";
?>
</form>

In exemplul de mai sus denumirile oraselor sunt pastrate in tabloul: $orase. Am folosit
instuctiunea foreach pentru a parcurge fiecare element din tablou si a crea o intrare in combobox.

Pentru trimiterea datelor din formular catre un script de pe server vom folosi o intrare speciala de
tip submit: <input type=submit>, ca in exemplul de mai jos:
Nume:<input type="text" name="nume"><br>
Adresa email:<input type="text" name="email"><br>
<br>
Ocupatia:
<br>Elev< input type="radio" name="ocupatie" value="Elev">
<br>Student< input type="radio" name="ocupatie" value="Student">
<br>Profesor< input type="radio" name="ocupatie" value="Profesor">
<br><input type = ="submit" name="submit" value="Trmite formular">
</form>
In momentul in care user-ul va actiona butonul submit datele din formular vor fi trimise catre
scriptul test5.php.

4.3. Receptionarea datelor de la un formular HTML

In cele mai multe versiuni de PHP valorile din formular sunt accesibile prin preluarea atributului
name al diferitelor date de intrare si adaugarea semnului $ pentru a se crea variabila
corespunzatoare.

Folosind formularul de mai sus , in scriptul test5.php , vom accesa variabilele:
$nume contine informatia introdusa in campul nume
$email contine informatia introdusa in campul Adresa email
$ocupatie contine informatia introdusa in butoanele radio Ocupatia

Deoarece cunoastem metoda prin care trimitem datele catre scriptul PHP, putem folosi variabila
PHP globala _GET sau _POST pentru a receptiona datele din formular:
_GET['nume']
_GET[' email']
_GET[' ocupatie']
_______________________________________________________________________________________________

Variabile PHP globale: _GET si _POST reprezinta de fapt variabile de tip array, fiecare element se
poate accesa prin cheia sa; in cazul nostru cheia este data de atributul : name din formular.

In continuare cream un formular care preia informatii de login ( nume si parola):
<html>
<head>
<title>Untitled</title>
</head>
<body>
<form action="test2.php" method="POST">
<table summary="" bgcolor="#808080">
<tr>
<td>
<table cellpadding="1" cellspacing="1" border="0">
<caption><font color="#3399ff" size="4">User authentification</font></caption>
<tr align="right">
<td align="right">Name</td>
<td><input type="text" size="25" name="name"></td>
</tr>
<tr align="right">
<td>Password</td><td><input type="password" size="25" name="password"></td>
</tr>
<tr>
<td colspan="2" align="center"><input type="submit" value="Logon"></td>
</tr>
<tr>
<td colspan="2" align="center"><a href="autentif.php">New user?</a>
</tr>
</table>
</td>
</tr>
</table>
</form>
</body>
</html>

Aceasta pagina HTML va genera un formular ca mai jos:

_______________________________________________________________________________________________

Introducem in continuare secventa care va prelua datele din formular(test2.php). In cazul in care
Name=Ion si Password=computer scriptul va afisa :
<br>Salut Ion .Autentificare realizata' ;
In alte cazuri scriptul va afisa :
Nume sau parola incorecte<br>Incercati din nou
<html>
<head>
</head>
<body>
<?php
if(isset($_POST)) {
if($_POST['name'] == 'Ion' && $_POST['password']== 'computer') {
echo '<br>Salut'.$_POST['name'].'<br>Autentificare realizata';
die;
}
else
echo '<br>Nume sau parola incorecte<br>Incercati din nou';
}
}
?>
<tr>
<td>
<tr align="right">
</tr>
<tr align="right">
<td>Password</td><td><input type="password" size="25" name="password"></td>
</tr>
<tr><td colspan="2" align="center"><input type="submit" value="Logon"></td></tr>
<tr><td colspan="2" align="center"><a href="autentif.php">New user?</a></tr>
</table>
</td>
</tr>
</table>
</form>
</body>
</html>
_______________________________________________________________________________________________

Scriptul PHP de mai sus se executa doar daca functia isset($_POST) returneaza TRUE. Functia
isset() returneaza FALSE daca variabila transmisa ca parametru este neinitializata(are valoarea
NULL); in caz contrar returneaza valoarea TRUE.

4.4. Tratarea erorilor

Modulul PHP poate fi configurat astfel incat sa afiseze erorile intalnite in codul PHP. Acest lucru
poate fi foarte util in cazul depanarii programelor. Pentru a activa afisarea erorilor exista doua
metode:
- modificarea parametrului display_errors din fisierul de configurare php.ini
- folosirea functiei ini_set(display_errors);

In cazul primei metode trebuie sa avem drepturi de administrator pentru a modifica fisierul
php.ini. Nu se recomanda setarea parametrului display_errors la valoarea 1(TRUE) in cazul site-
urilor de productie; mesajele de eroare afisate nu sint folositoare utilizatorului.Pe de alta parte
aceasta ar contribui la marirea riscului unui atac.

A doua metoda consta in folositrea functiei ini_set, care permite unui script sa redefineasca
temporar un parametru din fisierul de configurare php.ini.

Consideram un exemplu de cod in care intentionat incercam sa citim variabile care nu exista:
<?php
ini_set('display_errors',1);
echo "Valoarea transmisa este ".$_GET['orase'];
?>

In exemplul de mai sus daca variabila cu nume : orase nu exista PHP va afisa un mesaj de eroare
de genul:
Notice: Undefined variable: "._GET['orase']

Putem determina tipurile de erori pe care le semnaleaza PHP folosind functia: error_reporting().
Aceasta preia o constanta care specifica nivelul la care se afiseaza erorile.
Functia error_reporting(E_ALL ) semnaleaza toate tipurile de erori:
error_reporting(E_ALL & ~E_NOTICE ) semnaleaza toate erorile in afara de anunturi
error_reporting(0 ) dezactiveaza acesta caracteristica.

Exemplu:
<?php
error_reporting(E_ALL & ~E_NOTICE );
echo "Valoarea transmisa este ".$_GET['orase'];
?>

4.5. Exercitiu

Consideram un formular care afiseaza informatii despre utilizator:
_______________________________________________________________________________________________

-nume
-judet
-oras

Intrarile judet si oras sunt introduse intr-un meniu <select>. Campurile judet si oras sunt pastrate
intr-un tablou bidimensional. Sa se modifice scriptul de mai jos astfel incat la selectarea unui
anumit judet, in combobox-ul orase sa fie incarcate orasele corespunzatoare.

<?php
$orase = array('Hunedoara' =>array('Deva','Hunedoara','Calan','Simeria','Orastie'),
'Alba' =>array('Alba-Iulia','Cugir','Brad','Zlatna','Tebea'),
'Timis' =>array('Timisoara','Lugoj','Savirsin','Remetea','Sincraieni'));
echo "<br>Nume:<input type='text' name='nume'><br>";
echo "<br>Judet<select name='judete'>";
foreach($orase as $cheie =>$judet) {
echo "<option value=$cheie>$cheie</option>";
}
echo "</select>";
echo "<br>Localitate<select name='oras'>";
foreach($orase['Hunedoara'] as $oras) {
echo "<option value=$oras>$oras</option>";
}
echo "</select>";
?>
<br><input type="submit" value="Trimite formular">
</form>
?>

_______________________________________________________________________________________________

Capitolul 5. FISIERE SI DIRECTOARE

5.1. Crearea, scrierea fisierelor

Pentru a crea un fisier nou pe un server sunt necesari trei pasi:
-deschiderea fisierului in mod scriere
-scrierea efectiva a datelor in fisier
-inchiderea fisierului.

In PHP aceste lucruri se realizeaza ca in secventa de mai jos:
<?php
error_reporting(E_ALL & ~E_NOTICE );
$fp = fopen('numeFisier', 'mod');
fwite($fp, 'date de scris');
fclose($fp);
?>

Instructiunea fopen deschide fisierul cu numele 'numeFisier', in modul specificat de 'mod'.
Functia returneaza o variabila de tip pointer catre fisier: $fp (file pointer).

Modurile de deschidere a unui fisier sunt urmatoarele:

Mod Descriere
r Permite doar citirea fisierului
r+ Citire sau scriere de la inceputul fisierului
w Creaza fisierul daca nu exista si suprascrie datele existente
w+ Citire sau scriere; la scriere , creeaza fisierul daca nu exista si suprascrie datele
existente
a Adaugare; Creaza fisierul daca nu exista si adauga datele noi la sfarsitul fisierului
existent
a+ Citire sau scriere; la scriere, creaza fisierul daca nu exista si adauga datele noi la
sfarsitul fisierului existent
x Doar scriere; Creaza fisierul daca nu exista si genereaza un averisment daca acesta
exista
x+ Citire sau scriere; Creaza fisierul daca nu exista si genereaza un averisment daca acesta
exista
b Deschide fisierul in mod binar

In continuare prezentam o secventa de cod care preia datele dintr-un formular si apoi scrie aceste
date intr-un fisier pe server:
<html>
<head>
</head>
_______________________________________________________________________________________________

<body>
<?php
error_reporting(E_ALL & ~E_NOTICE);
if(isset($_POST['submit'])) {
if(!empty($_POST['adnotari'])) {
$fp = fopen('..\date.txt','wb');
if($fp) {
$date = $_POST['adnotari']."\r\n";
$dateLen = fwrite($fp,$date);
fclose($fp);
if($dateLen==0) {
echo "Nu pot scrie date in fisierul ..\date.txt";
}
else {
echo "Datele transmise au fost scrise in fisierul ..\date.txt";
}
}
else {
echo "Nu pot deschide fisierul ..\date.txt la scriere";
}
}
}
?>
<form action="scriu_fis.php" method="POST">
Introduceti textul pentru scriere in fisier pe server:<br><br>
<textarea name="adnotari" rows="5" cols="20"></textarea><br><br>
<input type="submit" name="submit" value="Submit text">
</form>
</body>
</html>

Datele sunt preluate intr-un formular folosind eticheta <textarea>. Se observa ca instructiunea
fopen creaza un fisier daca acesta nu exista ; in cazul in care exista va altera vechiul continut al
fisierului.

5.2. Blocarea fisierelor

Secventa de cod descrisa mai sus poate creea probleme in cazul in care, de exemplu doi utilizatori
diferiti acceseaza acelasi fisier, in acelasi timp.

Pentru a evita stfel de conflicte PHP pune la dispozitia utilizatorilor o metoda prin care se poate
bloca accesul temporar la un fisier. Pe durata blocarii , un alt utilizator nu va mai putea scrie/citi
din acest fisier. De aceea durata blocarii trebuie sa fie limitata, in cazul nostru vom bloca fisierul
dor pe durata scrierii in fisier.

Functia care realizeaza blocarea este:
_______________________________________________________________________________________________

Flock($fp, modBlocare);

Unde fp este un pointer catre fisier asa cum am discutat in exemplul de mai sus.

Parametrul modBlocare poate avea urmatoarele valori:
Mod blocare Descriere
LOCK_SH Blocare partajata in scopuri de citire
LOCK_EX Blocare exclusiva in scopuri de scriere
LOCK_UN Eliminarea blocarii
LOCK_NB Blocare fara fixare

Vom modifica secventa de scriere de mai sus dupa cum urmeaza:

if($fp) {
flock($fp,LOCK_EX);
flock($fp,LOCK_UN);
fclose($fp);
}

In acest caz codul PHP de preluare a datelor din formular si scriere in fisier , se va modifica ca mai
jos:

<?php
error_reporting(E_ALL & ~E_NOTICE);
if(!empty($_POST['adnotari'])) {
if($fp) {
flock($fp, LOCK_EX);
flock($fp, LOCK_UN);
fclose($fp);
if($dateLen==0) {
echo "Nu pot scrie date in fisierul ..\date.txt";
}
else {
echo "Datele transmise au fost scrise in fisierul ..\date.txt";
}
}
else {
echo "Nu pot deschide fisierul ..\date.txt la scriere";
}
_______________________________________________________________________________________________

}
}
?>

5.3. Citirea fisierelor

Ne propunem sa cream un script PHP care sa citesca datele pe care le-am scris anterior in fisierul:
..\date.txt . O metoda simpla pentru a realiza acest lucru este folosind functia : file.

Functia file(numeFisier) returneaza un array, fiecare element din array reprezinta de fapt o linie
de text introdusa in formular.Acest lucru este ilustrat in scriptul urmator:
<html>
<head>
</head>
<body>
<?php
//Preluarea datelor dintr-un fisier text
if(file_exists('..\date.txt')) {
$arr = file('..\date.txt');
if(count($arr) >0) {
echo "<br>Datele din fisierul ..\date.txt sunt:<br> ";
foreach($arr as $linie) {
echo $linie;
}
}
}
else {
echo "Fisierul ..\date.txt nu exista";
}
?>
</body>
</html>
In exemplul de mai sus functia file_exists returneaza true daca fisierul exista; functia file
returneaza in variabila $arr continutul fisierului. Am folosit instructiunea foreach pentru a
parcurge array-ul $arr si a afisa toate liniile din fisier.

In anumite situatii avem nevoie sa accesam doar anumite informatii dintr-un fisier, in acest scop
fom folosi instructiuni pentru parcurgerea secventiala a fisierului.

Pentru acest lucru consideram un exemplu in care avem un formular de logare care contine
campurile Nume, Parola, Confirmare parola. Ne propunem sa trimitem aceste date la un script
care sa preia aceste date si sa le adauge la un fisier de pe server:
<html>
<head>
_______________________________________________________________________________________________

</head>
<body>
<?php
if(empty($_POST['nume']) || empty($_POST['parola1'])) {
echo "Nume sau parola necompletate";
}
else {
if($_POST['parola2'] !=$_POST['parola1']) {
echo "Campurile parola si confirmare parola diferite";
}
else if($fp = fopen('..\userData.txt','a+b')){
$date = $_POST['nume']."\t";
$date .= crypt($_POST['parola1'])."\r\n";
fclose($fp);
if($dateLen >0 ) {
echo "Date au fost adaugate cu success";
}
}
}
}

?>
<form action="scriu_pers.php" method="POST">
<caption>Autentificare utilizator</caption>
<tr><td>
<table summary="" border="0">
<tr><td>Nume:</td><td><input type="text" size='15' name='nume'></td></tr>
<tr><td>Parola:</td><td><input type="password" size='20' name='parola1'></td></tr>
<tr>
<td>Confirmare parola:</td><td><input type="password" size='20' name='parola2'></td>
</tr>
<tr align="center">
<td colspan="2"><input type="submit" name='submit' value= 'Logon'></td>
</tr>
</table>
</td></tr>
</table>
</form>
</body>
</html>

Scriptul : scriu_pers.php transmte mesaje de eroare daca Campurile Nume sau Parola sunt vide,
sau daca Campurile Parola si Confirmare paraola sunt diferite.
_______________________________________________________________________________________________

Daca totul este OK se foloseste functia : fopen('..\userData.txt','a+b')) care creeaza fisierul
..\userData.txt daca acesta nu a existat apriori. Daca acesta a existat deschide fisierul fara a altera
datele existente. Functia fwrite, adauga date la sfarsitul fisierului deoarece fisierul a fost deschis
in modul adaugare: a+b.

Am folosit functia crypt care cripteaza un sir de caractere.

In continuare ne propunem sa folosim form-ul precedent , dar de acesta data pentru a verifica
daca Numele si parola exista inregistrate in fisierul: ..\userData.txt. Pentru aceasta vom parcurge
fisierul secvential, linie cu linie, vom identifica Campurile Nume si parola si le vom compara cu
cele transmise de formular:
<html>
<head>
</head>
<body>
<?php
$logOK=FALSE;
if(empty($_POST['nume']) || empty($_POST['parola1'])) {
echo "Nume sau parola necompletate";
}
else if($fp = fopen('..\userData.txt','rb')){
while($linie = fgets($fp,1024)) {
$arr = explode("\t",$linie);
$varCript = crypt($_POST['parola1'],$arr[1]);
if(((($_POST['nume'] == $arr[0]) &&
strncmp($varCript,$arr[1],34)==0) {
$logOK = TRUE;
break;
}
}
fclose($fp);
}
if($logOK) echo "Logare cu success";
else echo "Nume sau parola inexistente";
}
?>
<form action="citesc_pers.php" method="POST">
<caption>Autentificare utilizator</caption>
<tr><td>
<tr><td>Nume:</td><td><input type="text" size='15' name='nume'></td></tr>
<tr>
<td>Parola:</td><td><input type="password" size='20' name='parola1'></td>
_______________________________________________________________________________________________

</tr>
<tr align="center">
<td colspan="2"><input type="submit" name='submit' value= 'Logon'></td>
</tr>
</table>
</td></tr>
</table>
</form>
</body>
</html>
</body>
</html>

5.4. Crearea si parcurgerea directoarelor.

In PHP comanda pentru crearea unui director este:
mkdir(nume_director, permisiuni);

In aceasta functie nume_director reprezinta calea spre un director; ea se poate specifica folosind
calea absoluta sau relativa.

In cazul in care avem un server Windows , al doilea parametru poate fi ignorat; specificarea
permisiunilor nu este obligatorie. In cazul serverelor Unix, permisiunea implicita este, 077, care
atribuie drepturi de scriere , citire si executare utilizatorilor: owner, Group si Others.

<html>
<head>
</head>
<body>
<?php
//Exemplu de folosire a functiei mkdir
if(mkdir("..\myDir"))
echo "Directorul ..\myDir a fost creat";
else
echo "Nu pot creea Directorul ..\myDir ";
?>
</body>
</html>

Exemplul de mai sus creeaza un director ..\myDir sub directorul Web curent : InetPub\wwwRoot\.
Directorul nou creat va fi: c:\ InetPub\myDir

Pentru a parcurge intrarile care se afla intr-un director dat , se folosesc functiile: opendir, readdir
si respectiv closedir.

_______________________________________________________________________________________________

Functia: opendir(nume_director) deschide directorul specificat pentru citire; ea intoarce
valoarea NULL daca directorul specificat nu exista. Daca directorul exista ea returneaza o variabila
de tip pointer spre director: $dp (directory pointer).

Functia readdir($dp) citeste urmatoarea intrare din directorul a carui pointer este specificat ca
parametru. Pentru a afla daca o intrare reprezinta un fisier se poate folosi functia :
is_file(nume_intrare); care intoarce true daca intrarea curenta este un fisier.

Functia is_dir(nume_intrare) returneaza valoarea TRUE daca intrarea curenta este un director.

In continuare prezentam un exemplu in care afisam toate intrarile dintr-un director; mai intai
directoarele apoi fisierele:
<html>
<head>
</head>
<body>
<?php
parcurge_director(".");
function parcurge_director($nume_dir) {
if(!empty($nume_dir)) {
$dp = opendir($nume_dir);
if($dp) {
echo "<table>";
echo"<tr><td>Nume</td><td>Lungime(bytes)</td>";
echo "<td>Ultima modificare</td></tr>";
while($intrare = readdir($dp)) {
if(is_dir($intrare)) {
echo <tr><td>$intrare</td><td></td><td>";
echo date('d/m/y',filemtime($intrare))."</td>";
}
}
rewinddir($dp);
while($intrare = readdir($dp)) {
if(is_file($intrare)) {
echo "<tr><td>$intrare</td><td>".filesize($intrare);
echo "</td><td>".date('d/m/y',filemtime($intrare))."</td>";
}
}
}
echo "</table>";
}
}
?>
</body>
</html>
_______________________________________________________________________________________________

Functia rewinddir($dp) aduce pointerul de director la inceputul intrarilor din director; in
continuare functia readdir va citi din nou prima intrare din director.

5.5. Drepturi de access la fisiere

Din punctul de vedere al programatorului PHP , cele mai importante drepturi de access la fisiere
sau directoare sunt: read, write si execute(sau search in cazul directoarelor).

Aceste drepturi pot fi acordate de catre administrator, urmatoarelor tipuri de utilizatori:
-owner , persoana care l-a creat sau care l-a plasat pe server
-group , membrii unui grup stabilit de administrator
-others, ceilalti utilizatori care nu fac parte din categoriile de mai sus.

In cele mai uzuale cazuri proprietarul: owner are drepturi de citire/scriere asupra fisierului creat,
utilizatorii group si others primind doar drepturi de citire.

Datorita faptului ca exista posibilitatea scrierii intr-un fisier sau director pe server, acest lucru
implica luarea unor masuri de precautie in ce priveste securitatea sistemului. O masura de
securitate care se foloseste este plasarea fisierelor/directoarelor in care se poate scrie, in afara
directoarelor Web . In cazul nostru daca directorul Web este: c:\InetPub\wwwroot\Sites, atunci
daca se plaseaza fisiere/directoare in c:\InetPub , acestea vor fi accesibile doar motorului PHP
care ruleaza local , nu si altor persoane, prin Internet.

Cele mai multe sisteme de operare au un utilizator PHP, care este de fapt utilizatorul aplicatiei
WebServer( Apache, IIS, PWS). In sistemele de operare compatibile Unix, serverul Apache ruleaza
sub utilizatorul Nobody. In serverele Windows aplicatia server IIS ruleaza cu aceleasi drepturi ca
utilizatorul conectat. In acest din urma caz nu este nevoie sa schimbam atributele fisierelor in care
scriem/citim.

PHP are cateva functii pentru modificarea permisiunilor asupra fisierelor si anume: chgrp(),
chown() si chmod(). Acestea reprezinta operatii de modificare a grupului, proprietarului sau
atributelor fisierelor. Aceste functii actioneaza doar in cazul in care modulul PHP are drepturi de
modificare a fisierelor/directoarelor specificate.

_______________________________________________________________________________________________

Capitolul 6. SITE-URI DINAMICE, LUCRUL CU BAZELE DE DATE

6.1. Conectarea la serverul MySQL; tratarea erorilor

Faptul ca de-a lungul timpului, limbajul PHP a devenit atat de popular se datoreaza in mare
masura faptului ca acesta contine suport de functii pentru accesarea informatiilor din bazele de
date. Pentru a utiliza o baza de date MySQL, avem nevoie de o conexiune la serverul de baze de
date(in cazul nostru , serverul MySQL). Aceasta conexiune va fi utilizata ulteruior ca punct de
access pentru comenzi mysql.

Sintaxa acestei comenzi este urmatoarea:

$hDb = mysql_connect(localhost, userName, password);

Primul parametru: localhost, reprezinta gazda pe care ruleaza serverul MySQL. In cazul in care
serverul MySQL ruleaza pe acelasi computer ca si modulul PHP, acest parametru este localhost.
In alte cazuri, daca serverul MySQL ruleaza pe un alt computer, va trebui sa specificati adresa
computerului pe care ruleaza serverul MySQL.

Parametrii , userName, password , vor fi inlocuiti cu numele utilizatorului care se conecteaza la
serverul MySQL, respectiv parola.

O varianta a functiei de conectare mysql_connect este functia de conectare permanenta:
mysql_pconnect. Aceasta functie se apeleaza in mod similar cu functia mysql_connect, dar se
deosebeste de aceasta prin urmatoarele:
-conexiunea la serverul MySQL nu se inchide odata cu terminarea scriptului PHP curent. In
schimb PHP conexiunea ramane deschisa pentru a putea fi utilizata ulterior.
- la apelare, acesta functie va incerca sa gaseasca o conexiune anterioara provenita de la
acelasi host, userName si password. Daca exista o astfel de conexiune anterioara, va fi folosita
aceasta conexiune, daca nu se va deschide una noua.

Pentru terminara unei conexiuni la serverul MySQL se foloseste instructiunea:
mysql_close();

Aceasta functie inchide conexiunea curenta (variabila $hDb nu mai este valida). Aceasta functie
nu inchide conexiunea in cazul initializarii conexiunii cu mysql_pconnect.

In anumite situatii folosirea functiei mysql_connect poate avea un efect benefic asupra
performantelor scriptului PHP; aceasta datorita faptului ca operatia de conectare/deconectare
consuma un interval de timp.

Pentru a ne conecta avem nevoie de un nume si o parola. In cazul serverelor de productie, acest
lucru este furnizat de administratorul serverului. In cazul in care va conectati pe calculatorul dvs.
personal, puteti creea un nou utilizator parcurgand urmatoarele etape:

1.deschideti o consola MySQL conectindu-va cu drepturi de root: mysql u root p
_______________________________________________________________________________________________

2.creati o baza de date de test : create database magazinCD;
3.creati un nou utilizator: grant INSERT,UPDATE,DELETE,ALTER,CREATE on magazinCD.* to
webUser@localhost IDENTIFIED BY computer;

Consideram exemplul urmator in care incercam sa realizam o conexiune la serverul MySQL:
<html>
<head>
<title>Conectare la severul MySQL</title>
</head>
<body>
<?php
//Script de conectare la serverul MySQL
$hDb = mysql_connect('localhost','webUser', 'computer');
if($hDb) {
echo "Conectare reusita la serverul MySQL";
}
else {
die("Conectare esuata".mysql_error());
}
mysql_close();
?>
</body>
</html>

In exemplul de mai sus , daca conectarea a reusit( variabila $hDb nu este nula), se trimite la iesire
sirul: "Conectare reusita la serverul MySQL";

In cazul in care conectarea nu reuseste(variabila $hDb este nula), se trimite la iesire sirul:
Conectare esuata concatenat cu rezultatul functiei mysql_error(). Aceasta functie returneaza un
sir care descrie eroarea . Nu folositi aceasta functie in cazul site-urilor reale de productie,
deoarece ar putea furniza informatii utile pentru un attacher. Folositi mysql_error() doar pentru
depanarea scripturilor PHP.

De asemenea in anumite situatii reale este util sa oprim mesajele de eroare pe care le-ar genera
functia mysql_connect. Putem face acest lucru adaugand un semn @ inaintea functiei. In acest
caz scriptul de mai sus va fi:

<?php
//Script de conectare la serverul MySQL
if($hDb = @mysql_connect('localhost','webuser', 'computer')) {
echo "Conectare reusita la serverul MySQL";
}
else {
die("Conectare esuata deoarece: ".mysql_error());
}
mysql_close();
_______________________________________________________________________________________________

?>

6.2. Crearea si selectarea unei baze de date

Pentru a crea o noua baza de date folosim comanda SQL:

create databse numeBazaDeDate;

pe care o putem lansa de la o consola MySQL, sau o putem apela de la un script PHP.

Aceasta comanda va functiona doar daca aveti suficiente drepturi pentru a creea base de date. In
cazul lansarii comenzii de la consola , va trebui sa va logati ca user cu drepturi de creare baze de
date. De asemenea in cazul scripturilor PHP, la conectare trebuie sa specificati un user cu drepturi
de creare baze de date.

In exemplul urmator cream o conexiune ca utilizator root, si apoi cream o baza de date cu numele
magazinCD:
<html>
<head>
<title> Creearea unei baze de date MySQL </title>
</head>
<body>
<?php
//Script pentru creearea unei baze de date MySQL
$hDb = mysql_connect('localhost','root', 'mypassword');
if($hDb) {
if(mysql_query(CREATE DATABASE magazincd)) {
echo Baza de date : magazincd a fost creata;
}
else {
die(Nu pot creea B.D. magazincd deoarece:.mysql_error());
}
}
else {
}
mysql_close();
?>
</body>
</html>
In exemplul de mai sus am folosit instructiunea:
mysql_query();
care executa o comanda SQL valida. In cazul nostru comanda SQL este:
CREATE DATABASE magazinCD
In cazul in care operatia esueaza, functia intoarce valoarea NULL. Functia die(), afiseaza sirul
prezentat ca parametru, dupa care opreste executia scriptului curent.
_______________________________________________________________________________________________

Pentru a selecta o baza de date deja existenta folosim instructiunea:

mysql_select_db(numeBazaDeDate);

Aceasta functie returneaza valoarea true daca baza de date specificata ca parametru a fost
selectata; returneaza false in cazul in care baza de date nu a putut fi selectata( in general datorita
faptului ca ea nu exista).

Exemplul urmator ilustreaza acest lucru:
<?php
//Script pentru conectare + selectare baza de date MySQL
$hDb = mysql_connect('localhost','webuser', 'computer');
if($hDb) {
if(mysql_select_db(magazincd)) {
echo Baza de date : magazincd a fost selectata;
}
else {
die(Nu pot selecta B.D. magazincd deoarece:.mysql_error());
}
}
else {
}
mysql_close();
?>

In cazul unui site real de productie , creati urmatorul script:

<?php
////////////////////////////////////////////////////////////////////
// dbconnect.php
//Script pentru conectare + selectare baza de date MySQL
////////////////////////////////////////////////////////////////////
if($hDb = mysql_connect('localhost','webuser', 'computer')) {
if(!mysql_select_db(magazincd, $hDb)) {
die(Nu pot selecta baza de date);
}
}
else {
die("Conectare esuata");
}
?>
Salvati acest fisier sub numele de dbconnect.php intr-un director cu un nivel mai sus decat cel in
care se afla paginile Web. Acest fisier contine informatii importante si de aceea trebuie evitate
posibilitatile prin care utilizatori rau intentionati ar putea citi acest fisier.

_______________________________________________________________________________________________

In cazul in care interpretorul PHP nu mai functioneaza, fisierele PHP nu vor mai fi interpretate, ci
va fi afisat codul sursa al acestor. De aceea acest fisier trebuie plasat cu unu sau doua niveluri mai
sus in ierarhia de directoare.

Deoarece acest script va fi apelat frecvent, PHP pune la dispozitie directiva

include(numeFisierPHP);

care va insera in scriptul curent continutul fisierului specificat ca parametru.

<html>
<head>
<title> exedmplu MySQL </title>
</head>
<body>
<?php
//Include scriptul de conectare
include(../dbconnect.php);
?>
</body>
</html>

6.3. Crearea tabelelor, scripturi SQL

Dupa conectare si selectarea bazei de date putem crea tabele in cadrul bazei de date selectate.
Pentru aceasta folosim limbajul SQL:

create table numeTabel (coloana1, coloana2,....);

In exemplul urmator cream tabelul cu numele Albume care contine urmatoarele campuri:

Nume camp Tip
id Identificator unic, nenull, cheie primara
Nume Char(30)
Autor Char(25)
Gen Char(10)
DataIntrarii Date
Pret Decimal(13,2)

<html>
<head>
</head>
<body>
_______________________________________________________________________________________________

<?php
include ("../dbconnect.php");
$SQL = "CREATE TABLE Albume (id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,";
$SQL .= "Nume varchar(30) NOT NULL, Autor varchar(25) , Gen varchar(10) NOT NULL,";
$SQL .= "DataIntrarii date, Pret decimal(13,2))";
if(mysql_query($SQL)) {
echo "Tabelul : magazincd a fost creat";
}
else {
echo "Nu pot creea tabelul magazincd deoarece:".mysql_error();
echo "<br>$SQL";
}
?>
</body>
</html>

In exemplul de mai sus , variabila $SQL contine comanda SQL pentru crearea unui tabel. Se
observa ca in parametrii comenzii sunt incluse campurile din tabela.

Instructiunea mysql_query, executa aceasta comanda si in cazul in care rezultatul nu este Null se
trimite la iesire sirul: Tabelul: magazincd a fost creat. In cazul in care instructiunea SQL nu a putut
fi executata functia mysql_query intoarce valoarea NULL.

Pentru crearea tabelelor se pot folosi de asemenea fisiere script. Acestea din urma au extensia
.sql , si contin instructiuni SQL .

Consideram fisierul creare_tabele.sql cu urmatorul continut:
# Nume fisier: creare_tabele.sql
# Use this schema for creating your database for
# a new installation of webProject.

CREATE TABLE judete (
jude_id INT(5) NOT NULL auto_increment,
jude_denumire varchar(100) default '',
PRIMARY KEY (jude_id),
KEY local_denu (jude_denumire)
) ;

CREATE TABLE localitati (
local_id INT(5) NOT NULL auto_increment,
local_judID INT(5) unsigned NOT NULL,
local_denumire varchar(100) default '',
PRIMARY KEY (local_id),
KEY local_denu (local_denumire),
KEY local_jude (local_judID)
) ;

_______________________________________________________________________________________________

Dupa cum se observa acest fisier contine comenzi pentru crearea a doua tabele: judete si
localitati. Pentru a executa acest fisier script deschidem o consola MySQL si executam comanda:
source creare_tabele.sql;
care va lansa in executie acest script si va creea cele doua tabele. De asemenea in acest script pot
fi inserate orice comenzi valide SQL.

6.4. Adaugarea, inserarea datelor intr-o tabela

n continuare vom considera baza de date : magazincd, si vom incerca sa creea un form HTML din
care sa preluam date si sa le inseram in tabela : Albume.

Pentru aceasta creeam mai intai un formular HTML, cu urmatoarele campuri:
-Nume (numele albumului)
-Autor (autorul piesei muzicale)
-Genul (rock, pop, blues, country,etc..)
-DataIntrarii (data in care a fost receptional CD-ul)
-Pret(pretul de vinzare)

Codul HTML pentru acest formular va fi ca cel din exemplul de mai jos:
<html>
<head>
<title>Adaugare CD-uri</title>
</head>
<body>
<form action="adaug_cd.php" method="POST">
<CENTER>
<table summary="" border="0" bgcolor="#808080">
<tr><td>
<caption >Preluare CD-uri</caption>
<tr>
<td>Nume</td><td><input type="text" size='30' name='nume'></td>
</tr>
<tr>
<td>Autor</td><td><input type="text" size='25' name='autor'></td>
</tr>
<tr>
<td>Gen</td>
<td><select name="gen">
<option value="rock">rock</option>
<option value="rock">pop</option>
<option value="rock">country</option>
<option value="rock">blues</option>
</select>
</td>
</tr>
_______________________________________________________________________________________________

<tr>
<td>Pret</td><td><input type="text" size='13' name='pret'></td>
</tr>
<tr align="center">
<td colspan="2"><input type="submit" name='submit' value='Trimite'></td>
</tr>
</table>
</td></tr>
</table>
</CENTER>
</form>
</body>
</html>
Se observa ca datele din formular vor fi trimise catre scriptul : adaug_cd.php.

In continuare cream scriptul adaug_cd.php ca mai jos:
<?php
//conectare la baza de date
$SQL = "INSERT INTO Albume (Nume, Autor, Gen, DataIntrarii, Pret) ";
$SQL .="VALUES('{$_POST['nume']}','{$_POST['autor']}','{$_POST['gen']}','";
$SQL .=date('Y-m-d')."',{$_POST['pret']})";
if(mysql_query($SQL)) {
echo "Datele au fost adaugate la tabela";
}
else {
echo "Eroare SQL".mysql_error();
}
}
?>

Se observa folosirea instructiunii SQL:
INSERT INTO numeTabela (cimp1,cimp2,cimp3,...) VALUES( Valoare1,Valoare2,Valoare3,...);

Ca si in alte cazuri folosim instructiunea mysql_query pentru a executa aceasta comanda SQL.

6.5. Citirea datelor dintr-o tabela sau interogare

In continuare ne propunem sa citim datele din tabela Albume, si sa le afisam apoi intr-un tabel
HTML. Pentru aceasta folosim comanda SQL SELECT , care realizeaza interogarea inregistrarilor
dintr-o tabela:

SELECT camp1, camp2, camp3,... FROM numeTabela WHERE clausa

Vom executa aceasta comanda SQL cu ajutorul instructiunii mysql_query:

_______________________________________________________________________________________________

$result = mysql_query(comanda SQL);

In acest caz variabila $result contine un indicator catre inregistrarile interogarii.
Pentru a parcurge inregistrarile linie cu linie folosim instructiunea:

$row = mysql_fetch_array($result);

Aceasta instructiune intoarce in variabila $row un array care contine ca elemente campurile
returnate de interogarea SQL.

Urmatorul exemplu citeste interogarile din tabela Albume si le afiseaza sub forma tabelara:
<html>
<head>
<title>Listare CD-uri</title>
</head>
<body>
<?php
$SQL = "SELECT * FROM Albume;";
if($res = mysql_query($SQL)) {
//Afisare cap de tabel
echo "<table summary='' border='1'>";
echo "<caption>Lista CD-uri</caption>";
echo "<tr bgcolor='#00ffff'>";
echo"<td>Nume</td><td>Autor</td><td>Gen</td><td>Data</td><td>Pret</td>";
echo "</tr>";
//Parcurgere inregistrari
while($row = mysql_fetch_array($res)) {
echo "<tr><td>{$row['Nume']}</td>";
echo "<td>{$row['Autor']}</td>";
echo "<td>{$row['Gen']}</td>";
echo "<td>{$row['DataIntrarii']}</td>";
echo "<td align='right'>{$row['Pret']}</td>";
echo "</tr>";
}
echo "</table>";
}
else {
echo mysql_error();
}
?>
</body>
</html>

_______________________________________________________________________________________________

vom considera baza de date: magazincd, si vom incerca sa creea un form HTML din care sa
preluam date si sa le inseram in tabela : Albume.

6.5. Citirea datelor dintr-o tabela sau interogare

Pentru a sterge inregistrari dintr-o tabela folosim comanda SQL DELETE:

DELETE FROM numeTabel WHERE clausa;

Consideram exemplul de mai sus in care vom adauga un camp numit Delete la tabelul existent. In
celulele corespunzatoare vom adauga Butoane pentru stergere. In momentul in care se face click
pe un buton, se apeleaza functia JavaScript: deleteCD cu parametrul egal cu numarul de
identificare a inregistrarii din tabela (campul id).

Aceasta functie JavaScript asigneaza variabilei hideden rowDel , valoarea campului id:
this.document.forms.stergForm.rowDel.value=rowID;

In continuare se apeleaza:
this.document.forms.stergForm.submit();

pentru a trimite datele catre script. Exemplul urmator ilustreaza acest lucru:
<html>
<head>
<title>Sterge CD-uri</title>
</head>
<body>
<form action="sterge_cd.php" method="POST" name='stergForm'>
<?php
// Sterge inregistrarea din tabela
if(isset($_POST['rowDel'])) {
$SQL = "DELETE FROM Albume where id =".$_POST['rowDel'];
echo "Delete succesfull";
}
}
$SQL = "SELECT * FROM Albume;";
//Afisare cap de tabel
echo "<table summary='' border='1'>";
echo "<caption>Lista CD-uri</caption>";
echo "<tr bgcolor='#00ffff'>";
echo
"<td>Nume</td><td>Autor</td><td>Gen</td><td>Data</td><td>Pret</td><td><Sterge></td>";
echo "</tr>";
_______________________________________________________________________________________________

//Parcurgere inregistrari
echo "<tr><td>{$row['Nume']}</td>";
echo "<td>{$row['Autor']}</td>";
echo "<td>{$row['Gen']}</td>";
echo "<td>{$row['DataIntrarii']}</td>";
echo "<td align='right'>{$row['Pret']}</td>";
echo "<td><input type='button' onclick = 'deleteCD( {$row['id']}
)'></td>";
echo "</tr>";
}
echo "</table>";
echo "<input type='hidden' name='rowDel'>";
}
else {
echo mysql_error();
}
?>
</form>
</body>
</html>
<script language="JavaScript" type="text/javascript">

</script>

Capitolul 7. SESIUNI SI COOKIE-URI

7.1. Despre sesiuni, crearea unei sesiuni PHP

Sesiunea reprezinta o modalitate prin care modulul PHP retine informatii de la o pagina la alta.
Odata cu initializarea unei sesiuni, utilizatorul poate pastra anumite variabile chiar daca in
continuare se viziteaza si alte pagini ale site-ului. In principiu informatia se pastreaza pana la
inchiderea browser-ului, sau pana cand utilizatorul distruge in mod explicit sesiunea curenta.
Intern lucrurile se desfasoara ca in exemplul urmator: in momentul cand un user s-a logat la site-
ul dumneavoastra, PHP atribuie acestuia un identificator unic de sesiune : SID.

Acest SID este inglobat intr-un coockie cu numele PHPSESSID si trimis apoi catre browserul
utilizatorului. Daca browserul nu suporta cookie-uri sau acestea sunt dezactivate, atunci acest SID
este adaugat la adresa URL. In acelasi timp se creeaza un fisier cu numele SID se creeaza pe
server. In continuare daca utilizatorul doreste sa stocheze anumite informatii, aceste vor fi practic
scrise in acest fisier SID de pe server.
_______________________________________________________________________________________________

Folosirea sesiunilor prezinta urmatoarele avantaje:
-Sesiunile pot fi folosite chiar daca browserul utilizatorului nu suporta cookie-uri sau daca
acestea sunt dezactivate.
-Permit stocarea unui volum mare de informatii, spre deosebire de cookie-uri care sunt
limitate in aceasta privinta.
-Sunt mai sigure in raport cu cookie-urile deoarece informatiile nu sunt transmise in mod
repetat intre client si server.

Initializarea unei sesiuni se face cu functia : session_start(). Aceasta trebuie sa fie printre primele
linii de cod dintr-un script PHP, deoarece apelul acestei functii trebuie facut inainte de trimiterii
catre browser-ul Web a vreunui HTML sau chiar a unui spatiu vid. Daca folosim stocarea iesirii in
buffer nu mai este necesara acesta: instructiunea session_start() nu trebuie inserata neaparat la
inceputul codului.

Instructiunea session_start() nu este necesare daca in fisierul de configurare php.ini , variabila
session.auto_start are valoarea true.

In continuare folosim un exemplu in care avem o pagina principala A.php care contine o legatura
catre pagina B.php. In pagina A.php, cream o variabila cu numele user_Name, pe care o
initializam cu o anumita valoare. Observam ca daca deschidem pagina B , aceasta variabila poate
fi citita intr-un script PHP:

<?php
//Fisierul a.php
session_start();
if(!isset($_SESSION['userName']))
$_SESSION['userName'] = "Ionescu";
?>
<html>
<body>
Aceasta este pagina A
<?php
echo "<br>Variabila de sesiune are valoarea: ".$_SESSION['userName'];
?>
<br>Legatura <a href="B.php">spre pagina B</a>
</body>
</html>

<?php
//Fisierul b.php
session_start();
?>
<html>
<head>
_______________________________________________________________________________________________

<title>Pagina B</title>
</head>
<body>
Aceasta este pagina B
<?php
echo "<br>Variabila de sesiune are valoarea: ".$_SESSION['userName'];
?>
<br>Legatura <a href="A.php">spre pagina A</a>
</body>
</html>

In acest exemplu se observa ca pagina B detine informatii despre variabila de sesiune creata in
pagina A. Se observa ca atribuirea , respectiv citirea variabilelor se face folosind variabila super-
globala : _SESSION.

7.2 Manipularea variabilelor sesiunii.

In anumite momente ar putea fi interesant sa aflam identificatorul sesiunii curente. Pentru
aceasta folosim functia session_id(), ca in exemplul urmator:
<?php
//Aflarea identificatorului de sesiune : SID
session_start();
?>
<html>
<body>
<?php
echo "Identificatorul sesiunii curente SID este:".session_id();
//Identificatorul sesiunii curente SID este:2846240682abf24a09f42664fc03bbf3
?>
</body>
</html>

Functia session_id accepta un parametru. In acest caz putem seta un anumit SID pentru sesiunea
curenta. In acest caz trebuie sa apelam functia session_id inainte de functia : session_start(), ca in
exemplul urmator:
<?php
//Setarea identificatorului de sesiune
session_id(123456);
session_start();
?>
<html>
<body>
<?php
echo "Identificatorul sesiunii curente SID este:".session_id();
//Identificatorul sesiunii curente SID este: 123456
_______________________________________________________________________________________________

?>
</body>
</html>

Deoarece variabilele de sesiune pot fi citite de alti utilizatori neautorizati, nu este indicat sa
pastram aici informatii esentiale cum sint parolele pentru baza de date.

Pentru a creea un minimum de securitate putem codifica aceste informatii , folosind functtile de
codare oferite de PHP: md5() sau crypt().

Functia md5(sirDeCaractere) codifica sirul de caractere furnizat ca parametru si returneaza un sir
de 32 charactere hexazecimale. Aceasta functie foloseste algoritmul de criptare: RSA Data
Security, Inc. MD5 Message-Digest Algorithm,

Acestl lucru este exemplificat in cele ce urmeaza:
<?php
$sir = Ionescu;
echo md5($sir); //produce iesirea: 1f3870be274f6c49b3e31a0c6728957f
?>

Acest mecanism de codare este ireversibil.

Consideram cazul in care avem o variabila de sesiune care pastreaza o parola si dorim sa codam
aceasta variabila astfel incat utilizatorii rau intentionati sa nu o poata folosi.
Pentru aceasta folosim functia md5(sir), pentru a o cripta. Mai mult initializam o variabila globala
cu numele $secret, careia ii atribuim ca valoare un sir de caractere. In continuare concatenam
valorile $parola si $secret si apoi criptam rezultatul. In acest caz chiar daca cineve reuseste sa
decripteze variabila de sesiune este putin probabil sa poata separa sirul $secret creat de noi. Ca si
in cazul conectarilor la baza de date este bine sa pastram acest fisier cu un nivel mai sus decat
directorul pentru pagini de Web:

<?php
$secret = jfhwpa0cnwwmddien5432fdwwq345s;
$parola = computer;
session_start();
$_SESSION[parola] = md5($secret.$parola);
//Consideram variabila $varTest
//Pentru a testa daca valoarea variabilei $varTest este egala cu $parola
if(md5($secret.$varTest) == $_SESSION[parola])
echo Valorile sunt egale;
else
echo Valorile nu sunt egale;
?>

7.2. Stergerea unei sesiuni

Pentru a putea sterge o sesiune este necesar sa incepem scriptul PHP cu instructiunea:
_______________________________________________________________________________________________

session_start, ca intotdeauna cand folosim sesiuni.

Pentru a sterge toate variabilele memorate in matricea $_SESSION folosim
unset($_SESSION);

Pentru a sterge doar o variabila memorata in sesiune folosim :
unset($_SESIION[numeVariabila]);

Datele sesiunii sunt memorate in server in fisiere temporare. Pentru a sterge datele sesiunii din
server folositi:
session_destroy();

Acesta procedura este ilustrata in exemplul urmator:
<html>
<body>
Stergerea datelor sesiunii
<?php
//Initializarea datelor sesiunii
session_start();
//Sterge matricea $_SESSION
unset($_SESSION);
//Sterge datele din server
session_destroy();
echo "<br>Sesiunea curenta a fost inchisa;
?>
</body>
</html>

7.3. Crearea si citirea cookie-urilor

Cookie-urile reprezinta o metoda prin care serverul poate salva informatii despre datele
utilizatorului in sistemul de calcul al utilizatorului. Multi utilizatori considera cookie-urile ca ceva
primejdios prin aceea ca serverul poate afla prea multe informatii despre calculatorul client.In
realitate cookie-urile stocheaza doar niste informatii pe discul local al utilizatorului iar utilizatorul
are posibilitatea sa afiseze doar informatiile dorite de el.

Majoritatea bowsereleor de Web au posibilitatea sa activeze/dezactiveze cookie-urile. In cazul in
care depanati un script PHP si folositi ca browser Internet Explorer, utilizatorul poate modifica
setarile privind cookie-urile astfel incat ori de cate ori se primeste sau trimite un cookie, Internet
Explorer sa afiseze o fereasta de dialog cu informatii despre numele si valoarea cookie-urilor.

Pentru a realiza acest lucru, selectati : Internet options, apoi executati click pe eticheta Privacy, iar
apoi pe butonul Advanced din sectiunea Settings. Selectati optiunea: Override automatic cookie
handling si apoi selectati Prompt pentru First Party Cookies cat si pentru Thirt-party cookies:

_______________________________________________________________________________________________

PHP pune la dispozitia utilizatorilor functii pentru transmiterea cookie-urilor de la server la
browser, si modalitati de citire a cookie-urilor. Un lucru important de retinut este faptul ca
cookie-urile trebuie sa fie transmise inaintea oricarei alte informatii.
Cookie-urile se pot transmite cu instructiunea:

setcookie(numeCookie, Valoarea ce se transmite);

Folosind aceasta functie se pot transmite mai multe cookie-uri succesiv; protocoalele Web
limiteaza insa la maximum 20, numarul cookie-urilor ce pot fi trimise aceluiasi utilizator.
Citirea cookie-urilor se face simplu accesand variabila super-globala:

$_COOKIE[numeCookie]

In exemplul urmator ne propunem sa afisam un meniu care permite utilizatorului sa selecteze
culoare de fundal si culoarea textului intr-o pagina Web. Odata selectate aceste doua valori,
trimitem doua cookie-uri cu numele pageColor, respectiv fontColor. Ulterior vom citi aceste
valori si fom seta culorile pentru background si text functie de continutul variabilelor setate in
aceste doua cookie-uri:

<html>
<head>
</head>
<body>
<?php
if($send_cookie)
echo "Cookie a fost trimis";
?>
<form action="option.php" method="GET">
<table summary="">
_______________________________________________________________________________________________

<tr>
<td>PageColor</td><td><select name="pageColor" onchange="onPageColorChanged()"
id="id_selPageCol">
<option value="#00ffff">Aqua</option>
<option value="#0000ff">Blue</option>
<option value="#ff00ff">Fuchisa</option>
<option value="#808080">Gray</option>
<option value="#008000">Green</option>
<option value="#00ff00">Lime</option>
<option value="#800000">Maroon</option>
</select>
</td>
<td>
<div style="background-color: #00ffff; display:inline" id="id_page"
> </div>
</td>
</tr>
<tr>
<td>FontColor</td><td><select name="fontColor" onchange="onFontColorChanged()"
id="id_selFontCol">
<option value="#00ffff">Aqua</option>
<option value="#0000ff">Blue</option>
<option value="#ff00ff">Fuchisa</option>
<option value="#808080">Gray</option>
<option value="#008000">Green</option>
<option value="#00ff00">Lime</option>
<option value="#800000">Maroon</option>
</select>
</td>
<td>
<div style="background-color: #00ffff; display:inline" id="id_font"
> </div>
</td>
</tr>
<tr align="center">
<td colspan="2"><input type="submit" value="Trimite" name="submit"></td>
</tr>
</table>
</form>
<br>Legatura spre <a href="test_cookie.php">pagina de test</a>
</body>
</html>
<script language="JavaScript" type="text/javascript">

</script>

A doua pagina : test_cookie.php , citeste cele doua variabile din cookie si seteaza in mod
corespunzator culorile pentru text si background:

<html>
<head>
<title>Test cookie</title>
</head>
<body
<?php
if($_COOKIE['pageColor'])
echo "bgcolor=".$_COOKIE['pageColor'];
if($_COOKIE['fontColor'])
echo " text=".$_COOKIE['fontColor'];
?>
Legatura spre <a href="option.php">setare pagina</a>
</body>
</html

7.3. Introducerea parametrilor intr-un cookie

In exemplele de mai sus am folosit doar parametrii nume si valoare pentru transmiterea cookie-
urilor. In realitate sintaxa functiei este urmatoarea:

setcookie(nume, valoare, expirare, path, domain, secure);

Al treilea parametru: expirare este folosit pentru a determina perioada de valabilitate a acestui
cookie. In general acest parametru se specifica prin adaugarea unui anumit numar de minute la
timpul curent. Acest parametru se specifica in secunde. De exemplu daca dorim sa trimitem un
cookie care sa aiba durata de viata de o ora :

setcookie(nume, valoare, time() + 3600);

3600 reprezinta 60 minute inmultit cu 60 secunde, deci numarul secundelor dintr-o ora.
Atentie: daca specificati acest paramteru ca :

setcookie(nume, valorea, time()-60);

acest cookie va fi sters (durata de viata a expirat).
_______________________________________________________________________________________________

Argumentele path si domain sunt folosite pentru a limita un cookie pentru a limita un cookie la un
anumit director dintr-un site Web , respectiv la un anumit domeniu (de exemplu www.mySite.ro).
Pentru a limita durata de viata a unui cookie astfel incat acesta sa existe numai cand utilizatorul
se afla in dosarul domeniului:

setcookie(nume, valorea, time()+3600, /user/);

7.4. Monitorizarea vizitatorilor unui site

In multe situatii reale dorim sa aflam mai multe despre vizitatorii care ne viziteaza site-ul. De
aceea in continuare vom scrie un exemplu de script PHP care foloseste cookies si o baza de date
MySQL pentru acest scop. Acesta va fi un exemplu simplu de monitorizare a vizitatorilor si anume:
vor fi inregistrate doar vizitele la pagina index a site-ului dumneavoastra.

Cand vizitatorul acceseaza pagina index , PHP va verifica daca exista un cookie valid pe sistemul
de calcul al utilizatorului. Daca exista inseamna ca persoana a mai vizitat site-ul nostru in perioada
de timp prestabilita(durata de viata a cookie-ului). Daca nu exista inseamna ori ca aceasta
persoana nu a mai vizitat site-ul nostru , ori ca l-a mai vizitat , dar cu un timp in urma mai mare ca
durata prestabilita(durata de viata a cookie-ului).
Pentru a mentine date despre vizitatori creea o tabela numita Visitors, intr-o baza de date
MySQL:
create table visitors(browser char(85) NOT NULL,
ip char(30) NOT NULL,
host char(85) NOT NULL,
timeOfVisit datetime NOT NULL);

Prima coloana: browser , va contine informatii despre browserul folosit de utilizator. Aceste
informatii sunt extrase din variabila PHP super-globala: $HTTP_USER_AGENT.

<?php
include ("../../dbconnect.php");
//setcookie('visitors',1, time() -60);
if(!isset($_COOKIE['visitors'])) {
setcookie('visitors',1, time() + 3600);
//adaugare vizitator
record_user($_SERVER['HTTP_USER_AGENT']);
}
?>
<html>
<head>
<title>Monitoring</title>
</head>
<body>
<?php
////////////////////////////////////////////////////////////
_______________________________________________________________________________________________

// Function: browser_info
// Purpose: Returns browser type and version
////////////////////////////////////////////////////////////
function browser_info ($agent) {
// Determine browser type
// Search for Internet Explorer signature.
$browse_version = "";
$iPos=0;
if (($iPos=strpos($agent,'MSIE')) != false ) {
$browse_type = "IE";
for($iCrt=$iPos+strlen('MSIE'); $agent[$iCrt] != ';'; $iCrt++)
$browse_version .= $agent[$iCrt];
}
// Search for Opera signature.
elseif (($iPos=strpos($agent,'Opera')) != false) {
$browse_type = "Opera";
for($iCrt=$iPos+strlen('Opera'); $agent[$iCrt] != ';'; $iCrt++)
}
// Search for Netscape signature. The search for the Netscape browser
// *must* take place after the search for the Internet Explorer and Opera
// browsers, because each likes to call itself
// Mozilla as well as by its actual name.
elseif (($iPos=strpos($agent,'Mozilla/')) != false) {
$browse_type = "Netscape";
for($iCrt=$iPos+strlen('Mozilla/'); $agent[$iCrt] != ';';
$iCrt++)
}
// If not Internet Explorer, Opera, or Netscape, then call it unknown.
else {
$browse_type = "Unknown";
$browse_version = "Unknown";
}
// return the browser type and version as array
return array($browse_type, $browse_version);
}
////////////////////////////////////////////////////////////
// Function: opsys_info
// Purpose: Returns the user operating system
////////////////////////////////////////////////////////////
function opsys_info($agent) {
// Determine operating system
if ( strstr ($agent, 'Win') ) // Search for Windows platform
$opsys = "Windows";
elseif ( strstr($agent, 'Linux') ) // Search for Linux platform
$opsys = "Linux";
_______________________________________________________________________________________________

elseif( strstr ($agent, 'Unix') ) // Search for UNIX platform
$opsys = "Unix";
elseif ( strstr ($agent,'Mac') ) // Search for Macintosh platform
$opsys = "Macintosh";
else // Platform is unknown
$opsys = "Unknown";
return $opsys;
}
////////////////////////////////////////////////////////////
// Function: record_user
//
////////////////////////////////////////////////////////////
function record_user() {
$ip = $_SERVER['REMOTE_ADDR'];
$host=gethostbyaddr($_SERVER['REMOTE_ADDR']);
$SQL = "SELECT * FROM visitors WHERE ip='$ip' AND host='$host'";
$res = mysql_query($SQL);
if($res && mysql_num_rows($res) > 0) {
$timestamp = date("Y-m-d H:i:s");
if($row = mysql_fetch_array($res)) {
$count = $row['count'] + 1;
$SQL = "UPDATE visitors SET count=$count, timeOfVisit = '$timestamp'";
if(!mysql_query($SQL))
echo "MySQL error:".mysql_error();
}
}
else {
list($browser,$version) = browser_info($_SERVER['HTTP_USER_AGENT']);
$operatingSystem = opsys_info($_SERVER['HTTP_USER_AGENT']);
$compBrowser = "$browser $version $operatingSystem";
$timestamp = date("Y-m-d H:i:s");

$SQL = "INSERT INTO visitors VALUES ('$compBrowser','$ip','$host','$timestamp',1)";
if(!mysql_query($SQL))
echo "MySQL error:".mysql_error()."<br>".$SQL;
}
}
////////////////////////////////////////////////////////////
// Function: record_user
// $maxNr: afiseaza ultimii maxNr vizitatori
////////////////////////////////////////////////////////////
function list_vizitors($maxNr){
$SQL = "SELECT * from visitors ORDER BY timeOfVisit DESC LIMIT 0,$maxNr";
echo "<table border='1'>";
echo "<caption>Lista ultimilor vizitatori</caption>";
echo "<tr bgcolor='#669966'> <td>Browser</td> <td>IP</td> <td>Host</td>
<td>Ultima data</td> <td>Nr. vizite</td>";
_______________________________________________________________________________________________

echo "<tr>";
echo "<td>{$row['browser']}</td> <td>{$row['ip']}</td> <td>{$row['host']}</td>
<td>{$row['timeOfVisit']}</td> <td>{$row['count']}</td>";
echo "</tr>";
}
echo "</table>";
}
}
//Afiseata lista cu ultimii 10 vizitatori
list_vizitors(10);
?>
</body>
</html>

In acest exemplu functia browser_info returneaza browserul, respectiv versiunea browserului sub
forma unui array. Functia opsys_info returneaza sistemul de operare al utilizatorului.

Functia record_user() adauga/actualizeaza inregistrarea cu privire la vizitator.

Functia list_vizitors($maxNr) listeaza ultimii maxNr vizitatori in ordinea descendenta a datei
ultimei vizite.

Rezultatul executarii acestui script este afisat in figura de mai jos:

7.5 Stergerea cookie-urilor

Un cookie expira automat dupa inchiderea browserului sau dupa scurgerea duratei de viata
declarate. Pentru a sterge un cookie se poate proceda dupa cum urmeaza:
- se trimite un cookie care contine doar numele fara a fi specificata valoarea:
setcookie(nume, );
- sau se declara o durata de viata mai mica ca data/timpul curent:
setcookie(nume, , time()-60);

_______________________________________________________________________________________________

Capitolul 8. UTILIZAREA CLASELOR IN PHP

8.1 Despre POO, avantajele utilizarii claselor

Programarea orientata pe obiecte:POO reprezinta o metoda moderna de abordare a programarii.
Ea s-a dezvoltat datorita faptului ca programele recente au devenit tot mai complexe, iar
programarea structurata, bazata pe functii si proceduri nu mai corespunde cerintelor moderne.
POO permite descompunerea in subprobleme sau parti corelate cu problema de rezolvat. Unul
dintre elementele care stau la baza POO este conceptul de clasa. O clasa este de fapt o structura
care contine variabile(membrii) si functii (metode):

class className {
var membru1;
var membru2;
...................
functionclassName();
function metoda1();
function metoda2();
...........................
};

Membrii si metodele declarate intr-o clasa apartin clasei respective si se acceseaza specificand
numele clasei. Acest concept se numeste : incapsularea datelor, si contribuie la o mai buna
protejare a datelor. In programarea structurata se foloseau multe variabile globale; in cazul unui
program complex , practic din orice parte a codului se putea modifica valoarea acestor variabile.
In acest caz este destul de greu de depistat portiunea de cod care produce eroarea. In cazul POO ,
modificarea membrilor unei clase se poate face doar prin metodele clasei(daca nu se specifica
acesti membrii ca variabile publice). In acest caz se limiteaza zona de cod suspectata ca a produs
eroarea.

Un alt concept important al POO este mostenirea si polimorfismul. Mostenirea consta in aceea ca
putem declara anumite clase ca fiind derivate din anumite clase de baza. In cele mai multe situatii
astfel de clase extind functionalitatile clasei de baza. In acest fel se reduce foarte mult cantitatea
de cod necesara.

8.2. Declararea claselor, clase derivate

Declaratia unei clase incepe cu cuvantul cheie: class .Variabilele sau membrii clase se specifica
folosinf cuvantul: var. Functiile sau metodele unei clase se declara specificand cuvantul function .
Clasele au un constructor al clasei adica o metoda speciala care instantiaza o clasa. Numele
functiei constructor este acelasi cu numele clasei.

In continuare consideram clasa Cpersoanal, care are urmatorii membrii:
$nume, $ocupatia, $varsta

_______________________________________________________________________________________________

<?php
class CPersoana {
var $nume;
var $ocupatia;
var $varsta;
function CPersoana ($aName, $aOcupation, $age) {
$this->nume=$aName;
$this->ocupatia=$aOcupation;
$this->varsta=$age;
}
function getName() {
return $this->nume;
}
function getOcupatia() {
return $this->ocupatia;
}
function getVarsta() {
return $this->varsta;
}
}
//Utilizarea clasei CPersoana
//Creeaza o instanta a clasei CPersoana
$pers = new CPersoana (Ionescu,mecanic, 35,Ionescu@yahoo.com);
echo <br>Numele este.$pers->getName(). Ocupatia=.$pers->getOcupatia();
?>

Dorim sa extindem clasa de mai sus astfel incat sa contina si date despre home-page si e-mail:

<?php
class CpersoanaCuEmail extends CPersoana {
var $email;
var $home_page;
function CpersoanaCuEmail ($aName, $aOcupation, $age, $aHomePage, $aEmail) {
$this->nume=$aName;
$this->ocupatia=$aOcupation;
$this->varsta=$age;
$this->home_page = $aHomePage;
$this->email=$aEmail;
}
function getEmail() {
return $this->email;
}
function getHomePage() {
return $this->home_page;
}
}
//Utilizarea clasei CpersoanaCuEmail
_______________________________________________________________________________________________

//Creeaza o instanta a clasei CpersoanaCuEmail
$pers = new CpersoanaCuEmail (Ionescu,mecanic, 35,www.Ionescu.ro,
Ionescu@yahoo.com);
echo <br>Numele este.$pers->getName(). Ocupatia=.$pers->getOcupatia(). Home
page:.$pers->getHomePage();;
?>

8.3. Instantierea claselor; stergerea instantelor unei clase

Instantierea unei clase se face prin operatorul new:
$var1 = new NumeClasa();

Variabila $var1 contine o referinta la obiectul clasei. In continuare referirea metodelor clasei se
face prin operatorul de referentiere: -> ca mai jos:
$var1->Metoda1();

apeleaza metoda cu numele Medoda1() ,care apartine clasei NumeClasa.

Stergerea instantelor unei clase se face simplu prin apelarea functiei:
unset($var1);

In continuare orice apel de genul $var1->Metoda1(); va fi semnalat ca eroare.

Atentie: in cazul in care am initializat unii membrii ai clasei cu variabile de tip obiect sau resurse,
este bine ca inainte de stregerea instantelor clasei sa eliberam memoria ocupata de acestea.
Oricum PHP dispune de un mecanism de garbadge-collection , care elimina din memorie
elementele alocate dar care nu mai sunt referite in program.

Pentru a exemplifica aceste lucruri, in continuare vom implementa o clasa : ParserXML, cu care
vom parcurge un document XML.

PHP pune la dispozitie cateva functii importante pentru manipularea docmentelor XML:
xml_parser_create(); returneaza o referinta catre resursa XML parser
xml_parser_free($resursa); elibereaza resursa creata de functia de mai sus
xml_parse($data); Start parsing pentru un document
xml_set_element_handler($resursa , openTagFunc,closeTagFunc) specifica functiile
callback care vor fi apelate de PHP in cadrul elementelor
xml_set_caracter_data_handler($resursa , carDataFunc); specifica functia callback
apelata de PHP pentru character data.

Vom folosi clasa ParserXML pentru a citi un document XML dintr-un fisier de pe disk si a-l
transforma in document formatat HTML:
<html>
<head>
</head>
_______________________________________________________________________________________________

<body>
<?php
class ParserXML {
var $m_parser; // resursa parserului XML
var $m_html; // documentul HTML formatat
var $m_xml_file; // fisierul XML
var $m_open_tags; // Array: taguri de inceput
var $m_close_tags; //Array: taguri de sfirsit
function ParserXML() {
$this->m_html="";
$this->m_xml_file="";
$this->m_open_tags = array();
$this->m_close_tags = array();
$this->m_parser = xml_parser_create();
xml_parser_set_option($this->m_parser,
XML_OPTION_CASE_FOLDING, false);
xml_set_object($this->m_parser,$this);
xml_set_element_handler($this->m_parser,"openElement",
"closeElement");
xml_set_character_data_handler($this->m_parser,"caracterData");
}
function ParserDestroy() {
xml_parser_free($this->m_parser);
}
function setOpenTags($arrOpenTags) {
$this->m_open_tags=$arrOpenTags;
}
function setCloseTags($arrCloseTags) {
$this->m_close_tags = $arrCloseTags;
}
function html() {
return "<html>$this->m_html</html>";
}
function openElement($parser, $tag, $attributes) {
if($format=$this->m_open_tags[$tag])
$this->m_html .= $format;
//if($tag=="nume" && isset($attributes['email'])) {
//$format = "<a href='mailto:".$attributes['email']."'> Mail to ".$attributes['email'];
//$this->m_html .= $format;
//}
}
function closeElement($parser, $tag) {
//if($tag=="nume") {
//$this->m_html .="</a>";
//}
if($format=$this->m_close_tags[$tag])
_______________________________________________________________________________________________

$this->m_html .= $format;
}
function caracterData($parser, $cData) {
$this->m_html .= $cData;
}
function parse($xmlFile) {
if($fp = fopen($xmlFile,'rb')) {
while($data = fread($fp,4096)) {
if(!xml_parse($this->m_parser,$data, feof($fp))) {
$linNr = xml_get_current_line_number($this-
>m_parser);
$errMsg=xml_error_string($this->m_parser);
die("Eroare XML errMsg la linia $linNr");
}
}
}
}
}
$open_tags = array('mesaje'=>"<table summary='' colspan='0' border='1'>",
'mesaj'=>"<tr align='center'>",
'nume'=>"<td>",
'adresa'=>"<td>",
'email'=>"<td>",
'varsta'=>"<td>");
$close_tags = array('mesaje'=>"</table>\r\n",
'mesaj'=>"</tr>\r\n",
'nume'=>"</td>",
'adresa'=>"</td>",
'email'=>"</td>",
'varsta'=>"</td>");
$parser = new ParserXML();
$parser->setOpenTags($open_tags);
$parser->setCloseTags($close_tags);
$parser->parse("test.xml");
echo $parser->html();
?>
</body>
</html>

Fisierul test.xml contine:

<mesaje>
<mesaj>
<nume email='Ionescu@yahoo.com'>Ionescu</nume>
<adresa>Deva</adresa>
<virsta>39</virsta>
_______________________________________________________________________________________________

</mesaj>
<mesaj>
<nume>Popescu</nume>
<adresa>Hunedoara</adresa>
<virsta>39</virsta>
</mesaj>
</mesaje>

Scriptul de mai sus va genera un tabel cu coloanele: nume, adresa,virsta.

_______________________________________________________________________________________________

Capitolul 9. EXEMPLU DE SCRIPT PHP

Un formular (form) se creaza folosind tagul HTML <form> iar marcajul de sfarsit de formular se
creaza cu tagul </form>

Ca parametrii ai form-ului se specifica action=numeScript.php, prin acest parametru se specifica
scriptul care va procesa datele trimise din form. Un alt parametru important este :
method = GET sau method = POST care specifica modalitatea in care vor fi transmise datele
spre scriptul PHP. Metoda POST transmite datele fara a fi vizibile de utilizator, metoda GET
foloseste URL-ul urmat de unul sau mai multi parametrii care de fapt reprezinta valorile
cimpurilor din form.

Ex:http://www.MyDomain.com/preluare_formular.php?nume=Ion&titlu=coordonator

<html>
<head>
</head>
<body>
<tr>
<td>
<tr align="right">
</tr>
<tr align="right">
<td>Password</td><td><input type="password" size="25"
name="password"></td>
</tr>
<tr>
</tr>
<tr>
</tr>
</table>
</td>
</tr>
</table>
</form>
</body>
</html>
_______________________________________________________________________________________________

Acesta pagina HTML va genera un formular ca mai jos:

Introducem in continuare secventa care va prelua datele din formular. In cazul in care Name=Ion
si Password=computer scriptul va afisa :
<br>Salut Ion .Autentificare realizata' ; iar in alte cazuri scriptul va afisa :
Nume sau parola incorecte<br>Incercati din nou

Scriptul introdus are culoarea albastra:
<html>
<head>
</head>
<body>
<?php
if(isset($_POST)) {
if($_POST['name'] == 'Ion' && $_POST['password']== 'computer'){
echo '<br>Salut'.$_POST['name'].'<br>Autentificare realizata';
die;
}
else
echo '<br>Nume sau parola incorecte<br>Incercati din nou';
}
}
?>
<tr>
<td>
<tr align="right">
_______________________________________________________________________________________________

</tr>
<tr align="right">
<td>Password</td><td><input type="password" size="25"
name="password"></td>
</tr>
<tr>
</tr>
<tr>
</tr>
</table>
</td>
</tr>
</table>
</form>
</body>
</html>?>

Daca utilizatorul selecteaza linkul: New user , va fi incarcat scriptul autentif.php, care creeaza un
formular cu datele personale ale utilizatorului si introduce aceste date intr-o tabela din baza de
date. Pentru conectare la baza de date am folosit urmatorii paramtrii:

$host="localhost";
$port="3306";
$userName="webuser1";
$password="pass1";

<html>
<head>
<title>Formular de inregistrare</title>
</head>
<body>
<?php
//Conectare la BD
$host="localhost";
$port="3306";
$userName="webuser1";
$password="pass1";

$handler = mysql_connect($host, $userName, $password);
if(!$handler) {
echo 'Conectare la baza de date esuata. Nume sau parola incorecte'.mysql_error();;
die();
}
_______________________________________________________________________________________________

else{
echo 'Autentificare reusita in BD';
if(!mysql_select_db('tst2',$handler))
echo 'Could not find database ';
if(isset($_GET)) {
if(isset($_GET['nume']) && isset($_GET['pass'])) {
$query ="SELECT nume,parola from utilizatori WHERE nume='".$_GET['nume']."'
AND parola='".$_GET['pass']."'";
$result = mysql_query($query,$handler);
//echo "after";
/*if(!$result)
{
echo "MySQL Error: ".mysql_error();
die();
}
else*/

$rows = mysql_num_rows($result);
if($rows > 0) {
echo "Utilizatorul cu numele ".$_GET['nume']." exista deja
in baza de date";
}
else {
$query = "INSERT INTO utilizatori (nume, parola, email, telefon,
localitate) VALUES(";
$query .= "'".$_GET['nume']."',";
$query .= "'".$_GET['pass']."',";
$query .= "'".$_GET['adr_email']."',";
$query .= "'".$_GET['telefon']."',";
$query .= "'".$_GET['localitate']."');";
$result = mysql_query($query);
if(!$result) {
echo "MySQL Error: ".mysql_error();
die();
}
else {
"Utilizatorul ".$_GET['nume']." a fost introdus
in baza de date";
}
}
}
}
}
?>

<form action="autentif.php" method="GET">
<table summary="" bgcolor="#c0c0c0">
<tr><td>
_______________________________________________________________________________________________

<table>
<caption><font color="#000080" size="5">Formular de
inregistrare</font></caption>
<tr><td>Nume</td><td><input type="text" name="nume" size="15"></td></tr>
<tr><td>Parola</td><td><input type="password" name="pass"
size="20"></td></tr>
<tr><td>Confirmare Parola</td><td><input type="password" name="confirmpass"
size="20"></td>
</tr>
<tr><td>Adresa E-mail</td><td><input type="text" name="adr_email"
<tr><td>Telefon</td><td><input type="text" name="telefon"
<tr>
<td>Localitate</td><td><select name="localitate">
<option value="1">Deva</option>
<option value="2">Hunedoara</option>
<option value="3">Calan</option>
<option value="4">Orastie</option>
</select></td>
</tr>
<tr><td></td><td><input type="submit" value="Submit" ></td></tr>
</table>
</td></tr>
</table>
</form>
</body>
</html>

_______________________________________________________________________________________________

In continuare modificam scriptul de logare astfel incat sa se confrunte informatiile din formular cu
cele existente in baza de date.

<html>
<head>
</head>
<body>
<?php
if(isset($_POST)) {
if(isset($_POST['name']) && isset($_POST['password'])) {
//Logare la BD
$handler = mysql_connect('localhost:3306','webuser1','pass1');
if(!$handler) {
echo "Could not connect to database ".mysql_error();
die();
}
mysql_select_db('tst2');
$query = "SELECT nume,parola from utilizatori WHERE nume='".$_POST['name']."'
AND parola='".$_POST['password']."';";
//echo "<br>Query=".$query;
$result = mysql_query($query);
if(!isset($result) || !mysql_num_rows($result)) {
echo "Nume sau parola incorecte.<br>Incercati din nou";
_______________________________________________________________________________________________

}
else {
echo "<br>Salut ".$_POST['name']."<br>Autentificare reusita";
}
}
}
?>

<tr>
<td>
<tr align="right"> <td align="right">Name</td> <td><input type="text" size="25"
name="name"></td> </tr>
<tr align="right"> <td>Password</td><td><input type="password" size="25"
name="password"></td> </tr>
<tr> <td colspan="2" align="center"><input type="submit" value="Logon"></td> </tr>
<tr> <td colspan="2" align="center"><a href="autentif.php">New user?</a> </tr>
</table>
</td>
</tr>
</table>
</form>
</body>
</html>

Amg MA 11180

Î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

Amg MA 11180

Încărcat de

Drepturi de autor:

Formate disponibile

_____________________________________________________________________________________________

Acest document este proprietatea Institutului Multimedia Romano-Elvetian.

S-ar putea să vă placă și