Sesiuni în PHP

Protocolul HTTP este poate unul dintre cele mai simple protocoale. Este un protocol care tăieşte în prezent, nu are amintiri şi nici vise care speră să i se îndeplinească în viitor. Tradus în limbaj tehnic acest lucru înseamnă că un server web (care se foloseşte de protocolul HTTP) nu va şti şi nici nu-i va păsa dacă o cerere va veni de la acelaşi utilizator precum precedenta sau de la un utilizator nou. Acesta tratează fiecare cerere ca şi cum ar fi unică şi ca şi cum nu ar avea nici o legătură cu posibile cereri precedente sau viitoare. Acest lucru ar fi un dezavantaj evident, dacă nu ar exista diverse căi de a suplini acest neajuns. O astfel de cale se numeşte sesiune, iar limbajul PHP dispune de o serie de funcţii pentru a uşura lucrul cu sesiuni.

Sesiunile sunt folosite aşadar pentru a crea continuitate între accesările utilizatorilor unui site, chiar dacă aceste au loc la intervale relativ ridicate de timp. Sesiunile sunt stocate pe server, iar la cel mai jos nivel de reprezentare ele sunt nişte fişiere ce sunt stocate într-o zonă sigură a serverului de unde PHP-ul poate avea acces pentru citire, modificare sau creare. Ele sunt menţinute în relaţie cu clientul printr-un identificator de sesiune care va fi stocat la client de regulă într-un cookie(poate fi transmis şi printr-un parametru din GET).

Sesiunile de deschid în două modalităţi: imiplicit şi explicit. Implicit se face prin directiva de configurare aflată în fişierul php.ini numită session.auto_start, care setată pe valoarea 1 va porni implicit sesiunea la începutul rulării oricărui script PHP. Explicit, aceasta se realizează la cererea programatorului folosind funcţia session_start() de regulă la începutul fiecărui script. Avantaje si dezavantaje există de ambele parţi, prin pornirea implicită se evită apelarea în fiecare script al aplicaţiei a funcţiei session_start() însă datorită faptului că o sesiunea se va crea înainte de încărcarea fişierelor auxiliare folosite într-o aplicaţie, cum ar fi cele de definire a claselor, facând astfel imposibilă stocarea unor obiecte în sesiuni. Pornită explicit, funcţia session_start() va trebui apelată întotdeauna înainte de a trimite orice informaţie către client, deoarece aceasta va încerca stabilirea cookie-ului de sesiune, care va fi transmis printr-un header la client.

Informaţiile stocate pe sesiunie se pot regăsi în variabila superglobala $_SESSION care va fi creată automat la pronirea sesiunii şi care va conţine toate informaţiile deja existente pe sesiune. Se pot scrie, citi şi sterge informaţii din această variabilă, care beneficiază de toate avantajele oferite de vectorii limbajului PHP.

session_start();
$_SESSION[‘isLogged’] = true;
session_start();
if ($_SESSION[‘isLogged’])
{
    echo "Utilizatorul este autentificat";
}

Presupunând că cele 2 coduri reprezintă fişiere diferite, apelate în ordine vor genera afişarea mesajului de autentificare iar variabila se va păstra pe sesiune până la ştergerea ei sau pănă la distrugerea sesiunii.

O sesiune este persistentă până când aceasta este ştearsă sau până când ea expiră. Timpul de expirare este dat de către timpul de expirarea al cookie-ului păstrat în browser-ul clientului. Directiva session.cookie_lifetime din php.ini este setată implicit pe valoarea zero, şi înseamnă că sesiunea va expira în momentul în care utilizatorul va închide browser-ul. În cazul în care se doreşte forţarea unei sesiuni persistente se poate folosi funcţia session_set_cookie_params(). Distrugerea manuală a datelor existente într-o sesiune se poate face prin functia session_destroy()

cURL

cURL este un utilitar din linie de comandă folosit pentru transferul de fişiere ce pot fi accesate printr-un URL. Principalul scop şi utilizare a acestui program este automatizarea transferului de fişiere sau secvenţelor de operaţii, fiind o unealtă excelentă de a simula un client web şi acţiunile pe care le poate întreprinde un utilizator în browser-ul lui. cURL suportă transferul de date folosind mai multe protocoale cum ar fi: HTTP, HTTPS, FTP, FTPS, TFTP, Telnet, SCP precum şi altele.

Pentru ca această unealtă să poată fi folosita în diverse aplicaţii, a fost dezvoltată o librărie numită libcurl care poate fi inglobată în diverse aplicaţii şi care oferă aceeaşi funcţionlitate ca şi utilitarul în sine. Limbajul PHP deţine şi el o astfel de librărie, scrisă de către Daniel Stenberg, şi care oferă conectarea cu diverse servere folosind următoarele protocoale: http, https, ftp, gopher, telnet, dict, file şi ldap. Deasemenea libcurl suportă certificate de securitate, POST si PUT prin HTTP, încărcări de fişiere prin FTP sau din formularele HTTP, proxy-uri, cookie-uri sau autentificări folosind nume de utilizator şi parolă.

Un exemplu de folosire simplă este următorul:

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, ‘http://www.google.com’);
curl_exec($ch);
curl_close($ch);

PHP are implementate o serie de funcţii pentru lucru cu această librărie. Un algoritm general de funcţionare este descris şi în exemplul de mai sus care nu face altceva decât să returneze acceseze pagina google.com. Astfel, la început am creat o nouă sesiune de cURL folosind funcţia curl_init, şi am stocat-o în variabila $ch. Acesteia i se pot adăuga diverse opţiuni care să personalizeze sesiunea respectivă. În final sesiunea se execută, adică cererea către google.com este făcută, iar la final se eliberează resursa creată.

Într-o sesiune de cURL se pot adăuga mai mulţi parametrii care vor determina comportamentul acesteia. Iată câteva dintre cele mai uzuale opţiuni, care vor fi setate folosind funcţia curl_setopt:

  • CURLOPT_URL - reprezintă URL-ul pentru care se crează sesiunea şi cu care se va încerca trimiterea/primirea de date
  • CURLOPT_USERAGENT - va seta semnătura pe care o va lăsa accesarea la server
  • CURLOPT_HTTPHEADER - reprezintă un vector în care se pot defini header-ele de HTTP care se vor folosi la accesarea serverului
  • CURLOPT_REFERER - reprezintă URL-ul de pe care vine cererea curentă, cel care a referit acest nou URL
  • CURLOPT_ENCODING - reprezintă tipul de arhivare aplicat transferului curent, de regula gzip
  • CURLOPT_RETURNTRANSFER - va face ca funcţia curl_exec să nu afişeze aceste rezultatul sesiunii ci sa-l returneze într-o variabilă.
  • CURLOPT_HTTPGET - indică faptul că se modalitatea de transmitere a datelor este HTTP GET; aceasta este modalitatea implicită de transmitere a dateleor, astfel că setarea ei este necesară doar dacă într-o aceeaşi sesiune a fost făcută anterior o conexiune diferită
  • CURLOPT_POST - va determina trimiterea unei cereri de tip HTTP POST, cea implicită fiind GET
  • CURLOPT_POSTFIELDS - poate fi folosit în cazul unei cereri de tip POST şi aici se vor specifica variabilele pentru POST
  • CURLOPT_TIMEOUT - reprezintă numărul de secunde pentru care se va reîncerca o conexiune în caz ca cea iniţială a eşuat
  • CURLOPT_PORT - este portul pe care se va face cererea şi este implicit 80 pentru o conexiune folosind HTTP şi 21 folosind FTP
  • CURLOPT_PROXY - este numele serverului de proxy prin care se va face conexiunea
  • CURLOPT_PROXYUSERPWD - numele de utilizator şi parola pentru acces la serverul proxy, dacă sunte necesare
  • CURLOPT_FOLLOWLOCATION - va transmite librăriei de cURL să urmeze un redirect în cazul în care serverul o va dicta
  • CURLOPT_SSL_VERIFYPEER - verifică valabilitatea certificatului de securitate în cazul unei conexiui folosind SSL
  • CURLOPT_SSL_VERIFYHOST - indică faptul că în cazul unei conexiuni securizate, certificatul SSL trebuie să fie emis pentru host-ul care a fost contactat de catre cURL
  • CURLOPT_UPLOAD - va fi folosit în cazul unui upload
  • CURLOPT_FRESH_CONNECT - indică faptul că se va folosi o conexiune nouă în loc de cea existentă în cache
  • CURLOPT_HTTP_VERSION - indică versiunea protocolului HTTP care va fi folosită pentru comunicare
  • CURLOPT_MAXREDIRS - numărul maxim de redirectări pe care conexiunea le va urma
  • CURLOPT_COOKIE - reprezintă cookie-urile care vor exista în momentul cererii către server
  • CURLOPT_COOKIEFILE - reprezintă un fişier în care sunt stocate unul sau mai multe cookie-uri care vor insoţi cererea către server
  • CURLOPT_COOKIEJAR - reprezintă un fişier în care se vor stoca cookie-urile provenite de la server

Pe lângă aceşti parametrii care pot fi aplicaţi asupra cererii, există şi diverşi parametri care pot furniza informaţii referitoare la răspunsul venit din partea serverului în urma executării cererii de către cURL. Acestea pot fi acceste folosind funcţia curl_getinfo:

  • CURLINFO_HTTP_CODE - va furniza codul de răspuns al cererii
  • CURLINFO_TOTAL_TIME - timpul total afecatat sesiunii
  • CURLINFO_EFFECTIVE_URL - reprezintă ultimul URL care a fost folosit in sesiunea cURL
  • CURLINFO_REDIRECT_TIME - timpul total afectat redirectărilor dictate de server
  • CURLINFO_SIZE_UPLOAD - numărul de bytes încărcaţi către server
  • CURLINFO_SIZE_DOWNLOAD - numărul de bytes primitţi de la server
  • CURLINFO_CONTENT_TYPE - tipul de conţinut primit de la server; este util pentru a distinge între un conţinut HTML şi unul care în mod normal ar fi oferit către download

O atenţie sporită trebuie avută la aceste opţiuni referitor la versiunea de PHP pe care o folosiţi, întru-cât ele au fost introduse de-a lungul timpului sau chiar recent şi nu pot exista în versiunea pe care o utilizaţi.

Trimitere de POST cu cURL

Vom încerca în cele ce urmeză să oferim câteva exemple de folosire a cURL, pentru a exemplifica puterea de lucru care o poate oferi acesta.

Să presupunem, aşadar, existenţa unui formular de autentificare pe un site care va cere utilizatorului adresa de email cu care acesta s-a înregistrat şi parola lui, după cum urmează:

<form action="http://www.example.ro/post.php" method="post">
    Email: <br />
    <input type="text" name="email" />
    Email: <br />   
    <input type="password" name="pass" /><br />
    <input type="submit" value="Log In" />
</form>

Putem crea astfel un script care să simuleze o autentificare întocmai precum un utilizator s-ar fi autentificat direct pe site.

$ch = curl_init("http://www.example.ro/post.php");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, "email=blog@inphpwetrust.com&pass=foobar");
curl_setopt($ch, CURLOPT_FOLLOWLOCATION , true);
curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3")
curl_setopt($ch, CURLOPT_HEADER, false)
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
echo curl_exec($ch);
curl_close($ch);

Am început prin a crea o nouă sesiune care se va conecta la adresa http://www.example.ro/post.php şi pentru care am stabilit că va fi de tip HTTP POST, prin optiunea CURLOPT_POST, am mai setat o pseudo semnătură a “browser-ului” care se va conecta la server prin opţiunea CURLOPT_USERAGENT ca fiind Mozilla Firefox versiunea 3.0.3, varianta pentru Microsoft Windows XP, am indicat ca orice redirecţionare indicată de către server să fie urmărită şi de cURL prin optiunea CURLOPT_FOLLOWLOCATION, CURLOPT_HEADER indică faptul că nici un header primit ca răspuns nu va fi stocat, iar CURLOPT_RETURNTRANSFER va detemina ca doar corpul mesajului să fie preluat, iar în final după execuţia sesiunii de cURL va fi afişat în browser. Opţiunea CURLOPT_POSTFIELDS este cea mai importantă din aceast exemplu şi este cea care va determina autentificarea efectivă, deci într-un final returnarea unui conţinut care ar putea fi văzut doar de o persoană care s-ar autentifica pe un site. Valorile pentru elementele HTML de tip input email şi pass au fost setate aici, ele fiind credenţialele pe care aplicaţia de pe server va efectua autentificarea. Evident acesta este un exemplu simplu şi uşor de “hack-uit”, în ziua de azi multe din site-uri verifică veridicitatea utilizatorului folosindu-se de mai multe elemente sau afişează o imagine cu nişte caractere de recunoscut care pot fi mai greu sau chiar imposibil de nimerit folosind un script PHP.

Upload prin FTP folosind cURL

Deşi sunt şi alte metode de a încărca un fişier pe un server folosind protocolul FTP, sau simplu pentru a citi conţinutul unui director FTP, chiar şi limbajul PHP deţine niste funcţii de lucru cu FTP, cURL poate fi de ajutor atunci când acestea nu sunt dispobilie sau când se doreşte o mai mare flexibilitate în lucrul cu acest protocol. Următorul exemplu va folosi un handler de fişier creat cu funcţia fopen care va fi pasat parametrului CURLOPT_INFILE.

$fp = fopen(‘image.jpg’, ‘r’);
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, ‘ftp://ftp.domain.com/’);
curl_setopt($ch, CURLOPT_USERPWD, "ftpuser:ftppass");
curl_setopt($ch, CURLOPT_UPLOAD, true);
curl_setopt($ch, CURLOPT_INFILE, $fp);
curl_setopt($ch, CURLOPT_INFILESIZE, filesize($localfile));
curl_exec ($ch);
curl_close ($ch);
fclose($fp);

Design patterns

Un punct de reper pentru a descoperi un programator bun, indiferent de limbajul de programare pe care îl utilizează, este abilitatea acestuia de a aplica tehnici cunoscute de design al aplicaţiei. Design patterns(sau proiectarea modelelor) sunt un un set de soluţii ce pot fi aplicate la diverse probleme ce se întâlnesc frecvent în cadrul programării orientate pe obiect.

În teorie, aceste modele nu au legătură cu codul scris de un programator. Sunt niște soluţii de eficientizare a problemelor des întâlnite, nişte indicaţii pe care programatorul trebuie să le transpună în limbajul de programare pe care îl foloseşte. Ne vom referi în continuare la aceste modele legat de limbajul PHP, modele care deşi pot fi implementate folosind şi programarea procedurală, ele sunt evidenţiate mai bine cu ajutorul programării orientate pe obiect.

Singleton

Modelul Singleton este probabil cel mai simplu model. El este făcut pentru a permite accesul la o singură resursă care nu va fi niciodată duplicată, dar care trebuie făcută disponibilă în orice moment al execuţiei aplicaţiei. Implementarea unui Singleton trebuie să satisfacă cele două condiţii de acces global şi instanţiere singulară a resursei respective. Are nevoie de un mecanism de acces la class Singleton fără a instanţia un obiect şi un mecanism de a păstra informaţia asupra resursei ce urmează a fi folosită. Astfel acest model poate fi cel mai uşor implementat prin crearea unei clase ce va conţine o metodă care va crea o nouă instanţă a clasei, dacă aceasta nu exista deja, iar dacă există o va returna pe aceasta. Pentru a fi siguri că acea clasă nu va fi instanţiată în alt fel, constructorul este declarat protejat. Exemplul cel mai simplu este acela în care se pune problema existenţei unei singure conexiuni la baza de date:

class database
{
    private static $_singleton;
    private $_connection;
   
    protected function __construct()
    {
        $this->_connection = mysql_connect(SERVER, USER, PASSWORD);
    }
   
    public static function getInstance()
    {
        if (is_null(self::$_singleton))
        {
            self::$_singleton = new database();
        }
       
        return self::$_singleton;
    }
}

$cnx = database::getInstance();

Aşadar constructorul a fost declarat protejat pentru a controla accesul la el şi de a da posibilitatea apelării lui doar din interiorul clasei. Acest lucru este făcut cu ajutorul metodei statice getInstance, care verifică la fiecare apel al ei dacă există definit membrul static $_singleton, caz în care îl va returna, sau va încerca să creeze unul nou. Odată creat, metoda getInstance() nu va mai încerca să creeze unul nou ci-l va retuna pe cel creat tot timpul.

Factory

Modelul Factory se foloseşte în scenariile în care există o clasă generică (fabrica) care are posibilitatea de a crea o instanţă a una sau mai multe clase specializate în rezolvarea unei aceleaşi probleme dar în diferite moduri. Un astfel de exemplu îl reprezintă stocarea datelor de configurare într-o aplicaţie. Datele de configurare, precum credenţialele pentru conectarea la baza de date, sau căile de acces la diverse directoare, pot fi stocate în mai multe feluri: în fişiere XML, in fişiere INI sau chiar în baza de date. Astfel putem crea un mecanism care să returneze un obiect ce va şti să lucreze cu un anume mod de stocare a acestor date de configurare.

class configuration
{
    const STORE_IN_INI = 1;
    const STORE_IN_DB = 2;
    const STORE_IN_XML = 3;
   
    public static function factory($type = self::STORE_IN_INI)
    {
        switch ($type)
        {
            case self::STORE_IN_INI:
                return new configuration_ini();
            case self::STORE_IN_DB:
                return new configuration_db();
            case self::STORE_IN_XML:
                return new configuration_xml();
            default:
                throw new Exception(‘Tip de stocare necunoscut’);
        }
    }
}

Este evident faptul că toate cele 3 clase specializate de tratare a fișierelor de configurare (ini, xml, db) trebuiesc definite şi implementate, un avantaj fiind definirea lor conform unei clase abstracte. Apelarea “fabricii” se face după cum urmează:

$storage = configuration::factory(configuration::STORE_IN_XML);

Registry

Modelul Registry este un model Singleton mai evoluat, în sensul că permite stocarea mai multor resurse, ca într-un registru. Un exemplu ar fi acela în care, deşi avem conexiunea stabilită către baza de date printr-un Singleton, şi prin această conexiune se fac toate interogările, există posibilitatea ca din aplicaţie să fie nevoie de conexiunea în paralel către o alta bază de date pentru a efectua şi acolo diverse operaţiuni. Cu un simplu Singleton nu s-ar fi putut realiza aşa ceva însă cu un Registry acest lucru este posibil. Un astfel de Registry va trebui să implementeze metode de adăugare, verificare a existenţei şi de returnare a informaţiilor cerute.

class registry
{
    private static $_register;
   
    public static function add(&$element, $name)
    {
        $name = strtolower($name);
        self::$_register[$name] = $element;
    }
   
    public static function exists($name)
    {
        $name = strtolower($name);
        if (array_key_exists($name, self::$_register))
        {
            return true;
        }
        return false;
    }
   
    public static function &get($name)
    {
        $name = strtolower($name);
        if (self::exists($name))
        {
            return self::$_register[$name];
        }
        else
        {
            throw new Exception(‘Elementeul cerut nu exista in registru.’);
        }
    }
   
}

O folosirea a cestul model este următorul cu precizarea ca în acest exemplu clasa database nu este un Singleton:

$db = new database();
registry::add($db, ‘dbCnx’);
/*
verificarea conexiunii
*/

if (registry::exists(‘dbCnx’))
{
    $db = registry::get(‘dbCnx’);
}

Model-View-Controller

Spre deosebire de celelate modele discutate anterior, Model-View-Controller(denumit şi MVC) este un model destul de complex. Scopul lui este de a oferi o metodă de separare dintre logica aplicaţiei (model), modului de afişare (view) şi structura decizională (controller), aplicaţiile MVC fiind astfel usor de modificat atunci când se doreşte modificarea doar a modului de afişare sau a modului în care este tratată o cerere.

Logica unei astfel de aplicaţii este următoare: o cerere este făcută către aplicaţie şi este apelat controller-ul care va decide cum va trata cererea. Controller-ul va chema o clasă din Model, care efectiv va efectua interogări către baza de date, prelucrările necesare ale datelor sau orice alte operaţiuni necesare. Rezultatul, de regulă un set de date, va fi întors către Controller care va transmite aceste date părţii vizuale a aplicaţiei(View) unde deja există o structură de afişare a datelor ce tocmai au fost primite. Avantajul enorm al acestui model este separarea clară între cele 3 compomente şi uşurinţa cu care se pot extinde aplicaţiile dezvoltate pe acest model.

PHP RefCard

PHP RefCard

PHP RefCard

Am aflat zilele trecute citind feed-ul de la Zend Developer Zone cum că DZone a lansat mult aşteptatul PHP RefCard. Pentru cei care nu ştiu, acest RefCard reprezintă o broşură frumos formatată şi ordonată cu informaţii utile referitoare la un anume limbaj de programare.

PHP RefCard este realizat de către Jason Glimore, autorul a câtorva cărţi de referinţă cum ar fi Beginning PHP and MySQL: From Novice to Professional, Beginning PHP and Oracle: From Novice to Professional (Expert’s Voice) sau Beginning PHP and PostgreSQL 8: From Novice to Professional.

Recomand acest RefCard tuturor începătorilor ca un mic ghid asupra problemelor comune ce pot apărea referitor la configurare, programarea orientată obiect, stringuri, vectori, expresii regulate sau integrarea cu MySQL, precum şi diverse informaţii utile.

Structuri de control în PHP

Un script PHP este în esență o înşiruire de instrucţiuni. Instrucţiunile pot fi de mai multe feluri: atribuiri, apeluri de funcţii, structuri de control sau chiar instrucţiunea vidă. Aceste instrucţiuni sunt delimitate la finalul lor de către semnul punct şi virgulă. Totodată ele pot fi grupate într-o singură instrucţiune compusă, care la rândul ei devine o instrucţiune de sine stătătoare, înglobând mai multe instrucţiuni simple între două acolade.

Decizia

În crearea unui script, sau în general a oricărui program, vă veți întâlni cam în 100% din cazuri cu luatul de decizii. Sau mai bine zis cu scris cod care să ia decizii pe loc în momentul rulării aplicaţiei respective. Deşi rudimentară, este una din tehnicile de bază în programare (alături de iteraţie), fără de care probabil programarea dacă ar fi existat ar fi fost o meserie destul de greoaie. Se bazează pe faptul că în timpul execuţiei se poate dori execuţia unor anume instrucţinui în detrimentul altora în funcţie de, să zicem, nişte parametrii proveniţi de la utilizatori, deci de a lua o decizie: ce instrucţiune, sau set de instrucţiuni, să execut? Există două structuri de control care vă pot ajuta în luarea acestor decizii: if şi switch.

Instrucțiunea IF-ELSE-ELSEIF este o instrucţiune întâlnită în majoritatea limbajelor de programare şi mai este întâlnită sub denumirea de instrucţiunea decizională simplă. Astfel aceasta dă posibilitatea de a alege dintre două sau mai multe posibilităţi de execuţie a codului, folosind-se de niște condiţii testate în prealabil. Formatul general al acesteia este:

if (<conditie-if>)
    <instructiune-if>
[elseif (<conditie-elseif1>)
    <instructiune-elseif1>
elseif (<conditie-elseifn>)
    <instructiune-elseifn>
else
    <instructiune-else>]

Efectul acestei instrucţiuni este următorul: se evaluează condiţia din cadrul ramurei if, dacă aceasta are valoare logică de TRUE, atunci se execută instrucţiunea imediat următoare. În caz contrar se trece la prima ramură elseif(dacă există) testându-se condiţia şi executându-se instrucţiunea corespunzătoare în caz ca aceasta se evaluează la TRUE. Procesul continuă pentru toate ramurile elseif până când sunt terminate sau până la prima condiţie evaluată la TRUE. În caz ca nici una nu va fi găsită TRUE, se va executa instrucţiunea de pe ramura else, dacă există. De remarcat este faptul că se pot defini oricât de multe ramuri elseif şi doar una if sau else, şi că evaluarea la TRUE a unei condiţii face ca execuția să iasă din această structură de control. Totodată trebuie menţionat că oricare din ramurile definite suportă în corpul lor o singură instrucţiune; în cazul în care se dorește execuţia mai multor instrucțiuni acestea se pot grupa într-o instrucțiune compusă. Iată nişte exemple, pur didactice:

$number = 27;
if ($number % 2 == 0)
    echo "Numarul este par";
else
    echo "Numarul este impar";
/*
structura care foloseste si elseif
*/

if ($number % 3 == 0)
    echo "Numarul este divizibil cu 3";
elseif ($number % 3 == 1)
    echo "Numarul nu este divizibil cu 3, restul impartirii este 1";
else
    echo "Numarul nu este divizibil cu 3, restul impartirii este 2";

În cazul în care o instrucțiune IF ar conține multe ramuri elseif, scrierea lor ar putea deveni greoaie, precum citirea şi înțelegerea lor. De aceea PHP dispune şi de o instrucțiune decizională multiplă: SWITCH. Switch are avantajul că permite testarea unei variabile, sau a unei aceleiași expresii cu mai multe valori şi să execute o serie de instrucțiuni în caz că acesta ar fi egal cu una din valorile conținute în ramurile case.

switch (<variabila-sau-expresie>)
{
    case var1:
        instructiune1;
        [break;]
    [case var2:
        instructiune2;
        [break;]
    case varn:
        instructiunen;
        [break;]]
    [default:
        instructiune;]
}

Iată şi un exemplu concret:

$number = 27;
switch ($number % 3)
{
    case 0:
        echo "Numarul este divizibil cu 3";
        break;
    case 1:
        echo "Numarul nu este divizibil cu 3, restul impartirii este 1";
        break;
    case 2:
        echo "Numarul nu este divizibil cu 3, restul impartirii este 2";
        break;
}

Spre deosebire de lanțul de if-uri care se pot forma, instrucțiunea switch este mult mai robustă, atât prin modul de scriere dar şi prin modul de lucru. Diferă de instrucțiunea if prin faptul ca expresia este evaluată o singură dată la început şi apoi este verificată cu toate valorile întâlnite în ramurile case până când acestea corespund. Poate exista și o ramură default, care va fi executată când nici una din valorile din case nu corespund cu valoarea evaluată. Instrucțiunea break este folosită pentru a evita executarea mai multor ramuri în cazul în care o valoarea expresiei evaluate este întâlnită în una din ramurile case. Considerăm următorul exemplu:

switch ($number % 3)
{
    case 0:
        echo "Numarul este divizibil cu 3";
    case 1:
        echo "Numarul nu este divizibil cu 3, restul impartirii este 1";
    case 2:
        echo "Numarul nu este divizibil cu 3, restul impartirii este 2";
}

Deşi cu valoarea nulă în practică, exemplul de mai sus dacă v-a primi un număr divizibil cu zero si va afişa mesajele (sau executa intrucţiunile) de pe toate ramurile existente sub prima ramură până când va întâlni o instrucţiune break, sau, cum e şi cazul nostru, până la finalul structurii. Totuşi, un exemplu carea ar avea ceva logică şi care ar scoate în evidenţă lipsa folosirii de break, ar fi următorul:

switch ($number % 3)
{
    case 0:
        echo "Numarul este divizibil cu 3";
        break;
    case 1:
    case 2:
        echo "Numarul nu este divizibil cu 3";
}

În caz că expresia se va evalua la valoarea 1 scriptul va executa instrucţiunile din ramura cu valoarea 1 (in cazul nostru nici unul) şi instrucţiunile din ramura cu valoarea 2. Procesul ar fi continuat dacă ar fi existat şi alte ramuri.

Iteraţia

Iterația este procedura de repetare a unui set de aceleaşi instrucţiuni în anumite condiţii. Astfel aceste structuri de control pot fi folosite de regulă pentru a aplica acelaşi tratament asupra unui set de date, sau chiar pe o singură informaţie, până când se obţine un rezultat dorit. Cele mai uzuale instrucţiuni iterative sunt while, do-while, for, foreach.

while (<expresie>)
    <instructiune>;

do
{
    <instructiuni>;
} while (<expresie>);

Ambele structuri au rolul de a executa instrucţiunile din corpul lor până când expresiile respective ajung la valoarea TRUE. Diferenţa esenţială dintre ele este ca in cazul structurii while expresia este evaluată înainte ca orice iteraţie să aibă loc, deci corpul structurii while poate să nu fie executat niciodată, pe când în cazul instrucţiunii do-while expresia este evaluată după prima iteraţie, deci numărul minim de cicluri efectuate este de unu. Asemeni instrucţiunii decizionale simple, şi instrucţiunile iterative suportă în corpul lor doar execuţia unei singuri instrucţiuni, executarea mai mult instrucţiuni se face prin gruparea lor în una compusă.

/*
codul va afisa toate numerele de la 0 la 9
valoarea cu care $i va iesi din ciclu este 10
*/

$i = 0;
do {
    echo $i;
    $i++;
} while ($i < 10);
/*
codul următor are același efect cu cel de mai sus
*/

$i = 0;
while ($i < 10)
{
    echo $i;
    $i++;
}

În ambele cazuri, în instrucţiunile ce alcătuiesc corpul structurii, trebuie avută în vedere modificarea variabilei, sau a expresiei, care face scopul acelei expresiei, astfel se poate genera o bulcă infinită, buclă care nu se va termina într-un număr finit de paşi, ducând la o execuţie infinită a scriptului. In cazul celor doua exemple de mai sus, presupunem ca din corpul structurilor am scoate instrucţiunile de incrementare ale lui $i; acest lucru ar face ca valoarea lui $i să rămână tot timpul 0, deci mai mică decât 10, deci condiţia valabilă în orice iteraţie. Astfel de cazuri trebuiesc evitate.

Instrucţiunile for si foreach sunt tot instrucţiuni repetitive şi sunt considerate cele mai complexe structuri iterative din cadrul limbajului PHP.

for (expr-initiere; expr-testare; expr-iterare)
    instructiune;

Modul de funcţionare al acestei structuri este următorul: la prima intrarea în structura se va executa necondiţionat expresia expr-initiere, care de regulă va conţine instrucţiuni de iniţializare de variabile ce vor fi folosite în interiorul for-ului. În continuare, la fiecare iteraţie se va evalua expr-testare, al cărui rezultat va decide dacă instrucţiunea din corpul for-ului va fi executată sau nu. În caz că expresia va fi evaluată la valoarea FALSE, instrucţiunea nu va fi evaluată iar execuţia programului va ieşi din această structură. În cazul evaluării la TRUE, corpul structurii va fi executat, iar la finalul acestuia se va executa şi expr-iterare. Ca şi în cazurile precedente, executarea mai multor instrucţiuni presupune gruparea lor într-una compusă şi aceeaşi atenţie trebuie acordată evitării de bucle infinite. Complexitatea aceste structuri constă în faptul că oricare din cele 3 expresii pot lipsi, dându-se astfel o mai mare libertate programatorului în controlul acestei structuri.

Structura foreach este o structură introdusă din versiunea 4 a PHP şi este creată special pentru a itera prin elementele unui vector şi poate fi folosită în 2 moduri:

foreach ($array as $valoare)
    <instructiune>

foreach ($array as $index => $valoare)
    <instructiune>

Prima variantă de utilizarea va extrage fiecare element al vectorului la fiecare iteraţie în interiorul variabilei $valoare, pe când ce-l de-al doilea exemplu va separa indexul de valoarea elementului în cele 2 valori. Micul neajuns al acestei structuri este acela că iteraţia se face pe o copie a vectorului, deci orice modificare asupra $index sau $valoare nu va avea efect în vectorul care se iterează.

Întreruperea şi continuarea

Break şi continue sunt două instrucţiuni cu care se pot controla toate structurile iterative în sensul opririi sau continuării execuţiei de la începutul buclei. Astfel, o instrucţiune break va determina ieşirea dintr-o structură repetitivă a execuţiei, pe când continue va determina întoarcerea la începutul buclei, evaluarea expresiei de testare (dacă este cazul) şi reluarea execuţiei.

for ($i = 0; $i < 10; $i++)
{
    if ($i == 5)
        continue;
   
    echo $i . ‘,’;
   
    if ($i == 7 )
        break;
}

Exemplul precedent va afişa numerele 0, 1, 2, 3, 4, 6, 7. În interiorul structurii for la atingerea valorii 5 a lui $i se va executa instrucţiunea continue care va muta execuţia la incrementarea lui $i, şi apoi la execuţia următorului ciclu. La întâlnirea lui 7, deşi va fi afişat, execuţia va paraşi structura for, datorită instrucţiunii break. Un exemplu mult mai practic de folosirea a lui break este acela în care se dispune de un set de date (numere de exemplu), şi se doreşte aflarea dacă un număr oarecare se află în acel set de date. Metoda cea mai simplă şi rudimentară este căutarea secvenţială, în care fiecare element al setului de date este comparat cu acea valoare, până când cele 2 valori conicid sau până setul de date este temrinat. Îmbunătăţirea considerabilă ar fi ca în momentul în care elementul a fost găsit, scriptul ca nu caute în elementele rămase ci să printeze un mesaj şi să încheie execuţia.

$array = array(1,4,2,8,6,3,9,0);
$searchNo = 8;
foreach ($array as $element)
{
    if ($searchNo == $element)
    {
        echo "Numarul cautat a fost gasit";
        break;
    }
}

De notat este că în cazul instrucţiunilor imbricate repetitive, apelul lui continue sau break va determina continuarea sau întreruperea primului ciclu repetitiv în care instucţiunea a fost apelată. Dacă de exemplu se doreşte iesirea şi din cel de-al doilea, sau al treilea ciclu imbricat, se poate folosi următoarea sintaxă:

break 2;

Aşadar, este recomandat ca după fiecare apel a lui break să nu uitaţi terminarea instrucţiunii cu un punct şi virgulă, în caz contrar, dacă după aceasta există o instrucţiune care să returneze sau să se evalueze la o valoarea numerică, această valoare va fi pasată instrucţiunii break, lucru care poate afecta logica scriptului.

Metode magice în PHP

PHP 5 aduce un nou model al programării orientate pe obiect cu o multitudine de îmbunatăţiri şi facilităţi, spre bucuria programatorilor deja obişnuiţi cu pseudo-modelul din PHP 4. O facilitate care poate ajuta în cazul unor proiecte cu module interconectabile, este cea numită metode magice. Acestea sunt un set de metode standard, rezervate în limbajul de programare, care au o aceeaşi semnificaţie şi o aceeşi funcţionalitate în cazul oricăror clase definite de utilizator. Aceşte metode sunt autoapelate în anumite condiţii sau în cazul unor acţiuni externe.

Constructor si destructor

Metodele __construct() şi __destruct(), deşi pot fi numite magice doar prin modul de scriere, ele făcând parte din teoria programării orientate pe obiect, sunt metodele care se vor apela automat la crearea (instanţierea) respectiv distrugerea unui obiect aparţinând unei clase. De regula, în constructor se crează conexiuni, se setează variabile, se preiau variabile externe sau orice altă acţiune de iniţializare a elementelor clasei, pe când în destructor se face curăţenie printre aceste elemente, se închid eventualele conexiuni sau se şterg fişiere.

<?php
       
        class math
        {
                protected $a;
                protected $b;
               
                public function __construct($x, $y)
                {
                        $this->a = $x;
                        $this->b = $y;
                }
               
                public function add()
                {
                        return $this->a + $this->b;
                }
               
                public function multiply()
                {
                        return $this->a * $this->b;
                }
               
                public function __destruct()
                {
                        unset($this->a);
                        unset($this->b);
                }
        }
       
        $math = new math(3, 8);
        echo $math->add();
        unset($math);
?>

Constructorul va fi astfel apelat în momentul creării obiectului folosind operatorul new iar destructorul va fi apelat în la apelul lui unset() asupra obiectului în mod expicit sau în mod implicit la terminarea execuţiei scriptului, daca nu s-a făcut altfel.

Serializare şi deserializare

Serializarea este procesul de a liniariza o variabilă de orice tip într-una de tip string, cu scopul de a pastra informaţiile din interiorul ei(precum si tipul/tipurile de date) şi pentru a le transmite la distanţă fără pierdere de informaţii. Deserializarea este, evident, procesul invers. Daca în cazul unui vector rezultatul serializării este un string ce conţine în ordine şi pe nivele elementele acestuia, în cazul claselor se oferă posibilitatea de a alege ce date să se pastreze sau să se porteze. Pentru acest lucru au fost create două metode magice care vor fi apelate automat la apelul serializării sau a deserializării: __sleep() şi __wakeup().

<?php
       
        class math
        {
                protected $a;
                protected $b;
               
                public function __construct($x, $y)
                {
                        $this->a = $x;
                        $this->b = $y;
                }
               
                public function add()
                {
                        return $this->a + $this->b;
                }
               
                public function multiply()
                {
                        return $this->a * $this->b;
                }
               
                public function __sleep()
                {
                        return array(‘a’, ‘b’);
                }
               
                public function __wakeup()
                {
                        echo ‘a=’ . $this->a . ‘; b=’ . $this->b;
                }
               
                public function __destruct()
                {
                        unset($this->a);
                        unset($this->b);
                }
        }
       
        $mathAdd = new math(3, 8);
        echo $mathAdd->add(); /* va afisa 11 */
        $tmpData = serialize($mathAdd);
       
        $mathMultiply = new math(0, 0);
        $mathMultiply = unserialize($tmpData);
        echo $math->multiply(); /* va afisa 24 */
?>

De menţionat este că la apelul unserialize() şi implicit a lui math::__wakeup() scriptul va printa valorile primite de la prima instanţiere a clasei.

String

Există şi o metodă simplă, numită __toString() care va fi apelată la fiecare apel al lui echo, print sau încercare de folosire a obiectului ca un string.

<?php
       
        class hello
        {
                protected $foo;
               
                public function __construct($bar)
                {
                        $this->foo = $bar;
                }
               
                public function __toString()
                {
                        return "Hello " . $this->foo;
                }
        }
       
        $hi = new hello(‘george’);
        echo $hi; /* va tipari "Hello george" */
       
?>

O altă metodă de transmitere a datelor între obiecte, posibil mai convenabilă decât serializarea şi deserializarea, poate fi făcută cu ajutorul funcţiei var_export() şi a metodei magice __set_state(). var_export() va returna un string care va conţine, fie valoarea numerica (în cazul variabilelor scalare de tip numeric), fie o valoare de tip string (cazul variabilelor string), fie stringul care ar crea un vector în cazul acestora, fie valoarea returnată de metoda magica __set_state() în cazul obiectelor. Această metodă magică a fost introdusă odată cu versiunea 5.1.0 a PHP.

<?php

        class A
        {
                public $var1;
                public $var2;
               
                public static function __set_state($an_array)
                {
                        $obj = new A;
                        $obj->var1 = $an_array[‘var1′];
                        $obj->var2 = $an_array[‘var2′];
                        return $obj;
                }
        }
       
        $a = new A;
        $a->var1 = 5;
        $a->var2 = ‘foo’;
       
        eval(‘$b = ‘ . var_export($a, true) . ‘;’);
        // $b = A::__set_state(array(
        //    ‘var1′ => 5,
        //    ‘var2′ => ‘foo’,
        // ));

?>

Autoîncărcarea

Deşi nu este o metodă, funcţia __autoload() poate fi de mare ajutor atunci când aplicaţia dispune de un numar considerabil de clase care nu sunt folosite toate în acelaşi timp. Astfel, aceasă funcţie se va apela şi va include, dacă este nevoie, un fişier care va conţine definiţia clasei, în momentul instanţierii unui obiect. În scenariul de faţă, este de preferat ca toate definiţiile clasei să fie situate într-un acelaşi director, iar fiecare clasă situată într-un fişier separat al cărui nume sa fie identic cu al clasei.

function __autoload($className)
{
        if (!class_exists($className)) 
        {
                include("includes/classes/" . $className . ".php");
        }
}

Se evită in acest fel încărcarea tuturor claselor existente în aplicaţie şi îngreunarea acesteia luând în considerare presupunerea ca nu toate clasele vor fi folosite în oricare acţiune a aplicaţiei, prin faptul ca o clasa va fi încarcată doar dacă este nevoie si doar atunci când este nevoie.

Paginare datelor este un mijloc eficient de a reduce datele raportate unui utilizator la o secţiune de interes local în ideea de a economisi timp de execuţie, spaţiu de afişare şi se a crea nişte raportări prietenoase. Exemplul cel mai simplu în reprezintă afişarea unor produse dintr-un magazin online pe … pagini, lucru care are avantajul că pe de partea clientului nu încarcă excesiv pagina utilizatorului (un magazin poate avea câteva sute de produse, poate chiar mii) iar pe partea serverului nu solicită nici baza de date dar nici procesările făcute după ce un set de date a fost returnat aplicaţiei, toate acestea făcându-se asupra unui set restrans de date.

Introdus in versiunea 1.6 a Zend Framework, modulul Zend_Paginator, aşteptat încă din versiunea 0.9, se vrea a fi o componentă flexibilă pentru paginarea colecţiilor de date şi prezentarea lor către utilizatori. Principalele avantaje ale acestui modul sunt posibilitatea de a pagina orice set de date, nu doar cele provenite din baza de date, aduce si prelucreaza doar setul de date care urmează a fi afişat nu asupra tuturor datelor, plus că fiind felxibil nu limitează programatorii doar la folosirea lui şi într-un anume mod, dar oferă totodată posibilitatea de folosirea a lui din alte componente ale framework-ului precum Zend_View sau Zend_Db.

Folosirea paginatorului este relativ simplă, şi se foloseşte de ideea că pentru a putea pagina un set de date, în orice format ar fi el, este nevoie de un adaptro specific pentru a putea interacţiona cu acele date. Astfel, pentru a putea pagina un vector, se poate folosi un array simplu din PHP, pentru a pagina un set de date returnate în urma unei interogări a bazei de date se foloseşte o instanţă a Zend_Db_Select, iar pentru a pagina un iterator se va folosi o instanşă a acestei clase din SPL. Pentru a începe folosirea paginatorului se poate instanţia acesta folosind adaptorul dorit, sau se poate folosi metoda statică factory():

$array = array(‘Luni’, ‘Marti’, ‘Miercuri’, ‘Joi’, ‘Vineri’, ‘Sambata’, ‘Duminica’);
$paginator = new Zend_Paginator(new Zend_Paginator_Adapter_Array($array));
$paginator = Zend_Paginator::factory($array);

În acest moment paginatorul are nevoie de o referinţă pentru a putea determnia şi prelucra secţiunea care va fi afişată utilizatorului, şi anume pagina, informaţie care de regula se stochează într-un parametru al URL-ului(implicit va fi considerată pagina 1). Totodată se poate specifica şi numărul de elemente care vor apărea intr-o pagină, acest număr este implicit 10.

$paginator->setCurrentPageNumber($this->_request->getParam(‘page’));
$paginator->setItemCountPerPage(20);

În final paginatorul se atribuie unei variabile din partea vizuală a aplicaţiei …

$this->view->paginator = $paginator;

iar apoi va fi afişată

<?php foreach ($this->paginator as $element): ?> 
<p><?php echo $element; ?></p>
<?php endforeach; ?>

Daca dorim paginarea unor date provenite din baza de date, cu siguranţă că va fi mai eficient ca interogarea făcută către baza de date să returneze doar acele date din pagina care ne interesează. Pentru acest lucru vom instanţia paginatorul folosind un obiect de tipul Zend_Db_Select, care va conţine o instrucţiune select personalizată pentru nevoile noastre.

class My_Model
{
    public static function getCategoryList($category_id, $page = 1)
    {
        $databaseAdaptor = Zend_Registry::get(‘db’);
        try
        {
            $select = new Zend_Db_Select($databaseAdaptor);
            /*$select = $databaseAdaptor->select();*/
            $select->from(‘products’, array(‘id’, ‘name’, ‘price’))
                    ->where(‘category_id = ?’, $category_id)
                    ->order(‘name asc’)
                    ;
                   
            $paginator = Zend_Paginator::factory($select);
            $paginator->setCurrentPageNumber($page);
            $paginator->setItemCountPerPage(10);
   
            return $paginator;
           
        }
        catch (Zend_Exception $ex)
        {
            Zend_Debug::dump($ex);
            return null;
        }
    }
}

Am creat asadar un model care va returna din baza de date toate produsele dintr-o anumită categorie, sortate după nume, folosind un obiect Zend_Db_Select instanţiat folosind un adaptor pentru baza de date, care a fost preluat din registru. Rezultatul unei astefel de abordări poate fi procesat într-un controller după cum urmează:

class IndexController extends Zend_Controller_Action
{
    public function indexAction()
    {
        Zend_Loader::loadClass(‘My_Model’);
        $this->view->paginator = My_Model::getNewsletterList($this->_request->getParam(‘category_id’), $this->_request->getParam(‘page’));
    }
}

Un alt aspect important al paginării este capacitatea acestei componente de a genera un nagivator printre “paginile” astfel determinate ale paginării, deci în ultimă instanţă posibilitatea de a avea acces secvenţial la tot setul de informaţii. Zend_Paginator furnizeată unul chiar interesant, datorită facilităţilor ce le oferă.

echo $this->paginationControl($this->paginator, ‘Sliding’, ‘pagination_control.phtml’);

Deşi ultimii doi parametri sunt opţionali, iar controlul ar putea funcţiona perfect fără aceste două informaţii, aceştia pot influenţa foarte mult modul în care acest index al navigării este construit. Ele se referă la, şi influenţează modul în care navigatorul generat va arăta şi comporta. Vom considera, pentru exemplificare, că navigatorul generat de Google la o căutare ar fi generat chiar de către Zend_Paginator.

Google Slider

Cel de-al doilea parametru controlează ce se întamplă daca acţionăm linkul “Precedentă” sau “Următoarele” şi poate avea urmatoarele valori

  • All caz în care va afişa toate paginile existente, lucru util pentru momentele când numărul paginilor rezultate este relativ scăzut
  • Elastic caz în care paginile se lărgesc şi se contractă în funcţie de poziţia în paginare şi numărul de pagini - gen Google
  • Jumping caz în care pe măsură ce utilizatorul trece de la o pagină la alta, pagina curentă se muta catre finalul unui interval de pagini, la finalul caruia va continua cu un interval nou
  • Sliding caz în care pagina curentă va fi afişată în centrul intervalului de pagini afişat, sau cel mai aproape posibil (gen Yahoo!); acesta este valoarea implicită

Cu toate acestea însă programatorul nu este restricţionat la acest set de posibilităţi, oferindui-se posibilitatea de a-si crea singur porpiul paginator. Pentru acest lucru sunt disponibile o serie de metode predefinite:

  1. first() — numărul primei pagini
  2. firstItemNumber() — numărul primei înregistrari din pagină în setul general de date
  3. firstPageInRange() — numărul primei pagini din setul curent
  4. current() — numărul paginii curente
  5. currentItemCount() — numărul de elemente afişate pe pagina curentă
  6. last() — numărul ultimei pagini
  7. lastItemNumber() — numărul ultimei înregistrari din pagină în setul general de date
  8. lastPageInRange() — numărul ultimei pagini din setul curent
  9. next() — numărul paginii următoare
  10. pageCount() — numărul total de pagini
  11. pagesInRange() — paginile aflate în setul de pagini
  12. previous() — numărul paginii precedente
  13. totalItemCount() — numărul total de elemente

Prin setul curent de pagini, ne-am referit la paginile vizibile la o afişare.

Vectorii

Vectorii, numiţi in engleză array, reprezintă cea mai avansată metodă de stocare a datelor în PHP. Sunt cele mai flexibile structuri de date: ele permint indecşi numerici sau alfanumerici, dar şi combinaţii; pot avea indecşi auto-incrementabili şi pot fi folosiţi ca stive, cozi, mulţimi, vectori uni, bi sau multi-dimenisonali şi pot stoca practic orice tip de dată. Este şi motivul pentru care în nucleul php există aproximativ 70 de funcţii definite pentru a uşura lucrul cu vectorii.

Aşadar aceşti vectori sunt o colecţie ordonată de obiecte numite generic elemente. Oricare dintre aceste elemente are o cheie unică în vector precum şi o valoare. Vectorii pot fi creaţi in 2 feluri, fie apeland functia array simplu, sau cu parametrii caz în care aceştia sunt atribuiţi vectorului.

$arr = array();
$arr = array(‘a’ => 1, ‘b’ => 2, ‘c’ => 3);
$arr = array(1 => ‘a’, 2 => ‘b’, 3 => ‘c’);
$arr = array(1, 2, 3);

Primul apel va crea un vector gol, cel de-al doilea un vector cu indecşi alfanumerici, al 3-lea cu indecşi numerici, iar pentru cel din urmă am furnizat doar valorile elementelor, pentru care indecşii de vor atribui automat prin autoincrementare.

Afisarea vectorilor

Spre deosebire de tipurile de date scalare(int, string, float) care pot fi afişate folosind funcţia echo, pentru vectori aceasta prezintă cateva neajunsuri la afişarea datelor. De exemplu, în timpul unui debug poate fi esenţial să avem informaţii nu doar despre datele aflate în elemnte, dar şi tipul lor de date, pe oricare din nivelele existente. Pentru a preîntâmpina această problemă PHP furnizează 2 funcţii de afişare recursivă a informaţiilor dintr-un array:

$array = array(1, 2, ‘foo’);
print_r($array);
var_dump($array);

Acest cod va produce următorul text:

Array
(
[0] => 1
[1] => 2
[2] => foo
)
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
string(3) “foo”
}

Observaţi cum, deşi ambele afişează elementele vectorilor, doar var_dump afişează şi tipul de dată al elementului respectiv. Mai mult, doar var_dump este capabil sa afişeze informaţiile despre mai mult de o variabiă, iar print_r are capacitatea de a trimite rezultatul către o variabilă prin specificarea celui de-al doilea parametru optional.