Web 2020 04/12: Programare Web – Dezvoltarea aplicaţiilor Web în PHP

Dr.SabinBuragaprofs.info.uaic.ro/~busaco/
Tehnologii Web
programare Web (III)
dezvoltarea aplicațiilor Web
cu limbajul și mediul PHP
Dr. Sabin Corneliu Buraga – profs.info.uaic.ro/~busaco/

„E mediocru ucenicul
care nu-și depășește maestrul.”
Leonardo da Vinci

Cum folosim un server de aplicații
pentru a dezvolta o aplicație Web?

server de aplicații web
Scop:
eficientizarea proceselor de dezvoltare
a aplicațiilor Web de anvergură

Integrat în unul/mai multe servere Web
de asemenea, poate oferi propriul server Web
sau mediu de execuție

Poate încuraja sau impune o viziune arhitecturală
privind dezvoltarea de aplicații Web
situație tipică:
MVC ori variații
(re)vezi prezentarea
anterioară

Simplifică maniera de invocare
de programe (script-uri) ale unei aplicații Web
generarea de conținut dinamic pe partea de server

Aspecte de interes:
limbaj(e) de programare
API-ul de bază
stocare persistentă a modelelor de date
interacțiune Web
cookie-uri și sesiuni
medii de dezvoltare + cadre de lucru, componente,…
caracteristici particulare

Limbaj(e) de programare
oferind suport pentru una sau mai multe paradigme:
imperativă
obiectuală
funcțională
reactivă
concurentă
paralelă
…

statice – exemple: C#, Java, Rust
versus
dinamice – e.g., JavaScript, PHP, Python, Ruby

procesate prin interpretare și/sau compilare
uzual, se preferă generarea de cod intermediar:
IL (Intermediate Language) – C#, Java, Scala,…

API de bază
contribuie la „puterea” limbajului și
a serverului de aplicații
(via funcții/clase predefinite)

API de bază
contribuie la „puterea” limbajului și
a serverului de aplicații
(via funcții/clase predefinite)
securitate, consistență,
acces la resursele mediului de operare/rulare,
asigurarea independenței de platformă etc.

Stocare persistentă
în baze de date relaționale – folosind SQL

exemple:
ADO.NET pentru ASP.NET
Java – JDBC (Java DataBase Connectivity)
PHP – funcții/module predefinite, plus biblioteci
incorporate (SQLite + mysqli) sau diverse extensii

ORM (Object-Relational Mapping): șablonul Data Mapper
Go – framework-ul Xorm
Java – specificația JPA (Java Persistence API)
+ implementări: EclipseLink, Hibernate, OpenJPA,…
Node.js – biblioteca Sequelize
PHP – framework-uri: Cycle ORM, Doctrine, Propel, RedBean etc.
avansat

Active Record – șablon arhitectural utilizat în cadrul ORM
pentru a încapsula într-o clasă o tabelă sau un view
exemple:
active_record, TypeORM (module Node.js), Castle Project (.NET),
DBIx::Class (Perl), Django ORM și Orator (Python),
Play Framework (Java, Scala), Rails (Ruby)
avansat

pe baza modelelor arborescente: XML
date (semi)structurate
transformări în alte formate: XPath, XSLT
procesări: DOM, SAX, SimpleXML etc.
validări de date: DTD, XML Schema, RELAX,…
interogări: XQuery cursurile
viitoare

recurgând la alte paradigme non-relaționale
(bazate pe grafuri și/sau cheie—valoare)
distribuite la nivel de Internet, scalabile – NoSQL
github.com/erictleung/awesome-nosql
nosql.mypopescu.com/kb/nosql
exemplificări:
Cassandra, MarkLogic, MongoDB, Neo4j, OpenLink Virtuoso, Redis
avansat

Interacțiune Web
facilitată de controale specificate
în cadrul codului-sursă invocat la nivel de server

Interacțiune Web
facilitată de controale specificate
în cadrul codului-sursă invocat la nivel de server
se pot emula câmpuri din formularele HTML și/sau
oferi noi controale interactive – e.g., calendar, slideshow,…
generare de cod procesabil la nivel de client (front-end)
componente Web (HTML + CSS + JavaScript) executate de browser

Interacțiune Web
exemplificări:
ASP.NET (<asp:control> – e.g., FileUpload, ListBox, Table,...)
framework-ul PRADO (PHP)
formidable, form-data, forms – module Node.js
platforma Java: JSF (JavaServer Faces)
avansat

Interacțiune Web
încurajarea folosirii de machete de vizualizare (templates)
pe baza unui procesor specific
Web template system

Interacțiune Web
Web template system
utilizând specificații de prezentare a conținutului
(Web template), datele persistente
(e.g., preluate dintr-o bază de date sau fișiere) sunt folosite
de un procesor (template engine)
pentru a genera documente HTML
ori alte reprezentări în alte formate

implementare
exemplu:
specificația de prezentare a conținutului
(HTML template – .tpl) include nume de variabile – aici,
de forma [@variabilă] – ce vor fi înlocuite cu valorile efective
preluate din program în urma rulării componentei
de procesare a machetelor de vizualizare

<h1 class="profile">User profile: [@username]</h1>
<img src="[@photoURL]" alt="photo"/>
<div class="identity">[@firstName] [@lastName]</div>
<div class="location">[@location]</div>

$profile = new Template ('templates/profile.tpl');
$profile->set ('username') = 'Tux';
$profile->set ('photoURL') = 'imgs/tux.svg';
$profile->set ('firstName') = 'Tuxy';
$profile->set ('lastName') = 'Pinguinesscool';
$profile->set ('location') = 'Romania';
🐧Tuxy Pinguinesscool
Romania
User profile: Tux

Interacțiune Web
Web template system
la nivel de server
Apache FreeMarker (Java), Blade (PHP), Haml (Ruby),
Mustache (C++, JS, PHP, Python, Scala,…), Pug (Node.js),
Razor (.NET), Smarty (PHP), Tonic (PHP), XSLT (XML)

Interacțiune Web
Web template system
la nivel de client
disponibile pentru JavaScript:
doT, EJS, Handlebars, Mustache.js, Nunjucks,…
github.com/sorrycc/awesome-javascript#templating-engines

Interacțiune Web
managementul cookie-urilor și sesiunilor
via structuri/tipuri de date – diverse exemplificări:
clasa HttpSession (ASP.NET), interfața HttpSession (servlet-uri Java),
HTTP::Session (Perl), session (Flask – framework Python), web.session
(web.py), HttpFoundation (componentă Symfony – framework PHP),
clasa SessionComponent (CakePHP), tabloul session (Ruby on Rails),
play.mvc.Http.Cookie (Play pentru Java/Scala), sessions (Gorilla – Go)
cookie-parser și express-session (module Node.js pentru Express)
avansat

Interacțiune Web
transfer asincron de date via suita de tehnologii Ajax
eventual, via framework-uri/module/clase adiționale
vezi cursurile
viitoare

Suport acordat ingineriei software
stimularea/impunerea folosirii unor șabloane de
proiectare (arhitecturale, comportamentale, structurale,
vizând procesările concurente și/sau distribuite și altele)
AMI (asynchronous method invocation), broker,
CBD (components-based development), DAO (data access object),
DDD (domain-driven design), DTO (data transfer object), façade,
MOM (message-oriented middleware), microservice, MV*,
publish-subscribe, SOA (service-oriented architecture), singleton,…
avansat

proiectare
exemplificare: anti-șablonul Spaghetti Code
uzual, specific aplicațiilor – aici, Web – care „amestecă”
partea de procesare cu maniera de prezentare (view)
și mecanismul de acces la modelul datelor
sourcemaking.com/antipatterns/spaghetti-code

Suport acordat ingineriei software
încurajează adoptarea unei/unor arhitecturi:
stratificate (layered)
conduse de evenimente (event-driven)
extensibile (microkernel / plug-in)
folosind microservicii (microservices)
„în nori” (space-based, cloud)
conform M. Richards, Software Architecture Patterns, O’Reilly, 2015
www.oreilly.com/programming/free/files/software-architecture-patterns.pdf
avansat

Exemple – inclusiv framework-uri
C++ – CppCMS, Silicon, TreeFrog, Wt
C# et al. (platforma .NET) – ASP.NET
D – Dweb, vibe.d
Dart – Aqueduct, shelf, Stream,…
Erlang / Elixir – Chicago Boss, Phoenix, N2O, Sugar
Go – Beego, Buffalo, Gin, Gorilla, Revel
Haskell – Snap, Spock, Yesod etc.

inspectarea tehnologiilor folosite
de o aplicație Web
cu instrumentul WhatRuns

Java (Jakarta Enterprise Edition – ex-J2EE) – GlassFish,
JBoss, Tomcat, Payara + Apache Struts, Apache Wicket,
Grails, Spring, Vaadin
JavaScript (ECMAScript) – Node.js + Derby, Express,
Locomotive, Meteor,…
Perl – Catalyst, CGI::Application, Mojolicious
PHP – PHP

inspectarea tehnologiilor
folosite de o aplicație Web

Python – Gunicorn, Tornado, uWSGI, Waitress etc.
(pe baza specificației WSGI – Python Web Server Gateway Interface)
+ Django, TurboGears, web2py
Ruby – Passenger, Puma, Thin, Unicorn,…
(implementează specificația Rack)
+ Ruby on Rails, Sinatra
Rust – Gotham, Iron, Rocket, Rouille etc.
Scheme – Artanis

abordare multi-limbaj:
Vert.x
(disponibil pentru Java, JS, Groovy, Ruby, Ceylon, Scala,…)

Integrat într-o stivă de tehnologii (software stack)
suită software (servere, instrumente, utilitare,…)
oferind suport pentru dezvoltarea de aplicații Web
disponibilă – uzual, în regim open source –
pentru o anumită platformă
(sistem de operare, server Web, server de baze de date,
server de aplicații, limbaj de programare)

LAMP
(Linux, Apache HTTP Server, MariaDB/MongoDB, Perl/PHP/Python)
alternative:
FAMP (FreeBSD), MAMP (macOS),
WAMP (Windows), XAMP (multi-platformă)
www.apachefriends.org

avansat
www.wamp.net – instrumente dedicate dezvoltatorilor Web

pe baza JavaScript – full stack Web development
MEAN (MongoDB, Express, Angular, Node.js)
MERN (MongoDB, Express, React, Node.js)
avansat
de parcurs
suplimentul Node.js

abordări complementare:
LAPP (Linux, Apache, PostgreSQL, Perl/PHP/Python)
LEMP (Linux, Nginx, MySQL/MariaDB, Perl/PHP/Python)
LLMP (Linux, Lighttpd, MySQL/MariaDB, Perl/PHP/Python)
LYCE (Linux, Yaws, CouchDB, Erlang)
LYME (Linux, Yaws, Mnesia, Erlang)
avansat

inspectarea tehnologiilor folosite de o aplicație Web
studii de caz

Informații esențiale despre PHP?

php
Istoric
Caracteristici importante
Limbajul de programare PHP
paradigme: procedurală, obiectuală, funcțională
PHP ca platformă de dezvoltare Web
interacțiune, acces la baze de date, framework-uri,
biblioteci și instrumente, studii de caz concrete

Personal Home Page Tools (1995)
Rasmus Lerdorf
PHP 3 (1998)
dezvoltat de Zend – Zeev Suraski & Andi Gutmans
PHP 4 (2000)
suport pentru programare obiectuală
PHP 5 (2004) – varianta cea mai recentă: PHP 5.6 (2014)
noi facilități inspirate de Java
PHP 6 (actualmente abandonat)
phpngPHP 7 (2015), PHP 7.2 (2017), PHP 7.4 (2019)
strong typing, suport pentru Unicode, performanță,…

php: caracterizare
Server de aplicații Web
oferă un limbaj de programare
de tip script, interpretat
poate fi inclus direct și în cadrul documentelor HTML

Limbajul PHP este procedural, oferind suport și
pentru alte paradigme de programare
(obiectuală și, mai recent, funcțională)
poate fi folosit și ca limbaj de uz general
php: caracterizare

Sintaxă inspirată de C, Perl și Java – case sensitive
spațiile albe (caracterele spațiu, Tab, New Line) n-au
niciun efect asupra modului de execuție a programului
uzual, fișierele ce conțin cod-sursă PHP au extensia .php
php: caracterizare

Disponibil gratuit – open source – pentru
diverse platforme (FreeBSD, Linux, Windows, macOS etc.)
și servere Web: Apache, IIS, Nginx,…
www.php.net
www.zend.com
php: caracterizare

Maniera de funcționare a procesorului (engine-ului) PHP
Client
Web
cerere HTTP
(GET, POST,...)
răspuns
(reprezentare)
HTML, PNG, PDF,
SVG, JSON, ZIP,...
procesor
(engine)
Zend
server de
aplicații
PHP
programe
.php

resurse (externe)
Server Web

Maniera de funcționare a procesorului (engine-ului) PHP
Client
Web
cerere HTTP
(GET, POST,...)
răspuns
(reprezentare)
HTML, PNG, PDF,
SVG, JSON, ZIP,...
procesor
(engine)
Zend
server de
aplicații
PHP
programe
.php

resurse (externe)
Server Web
eventual, pot fi integrate
diverse extensii (module)

Programul PHP e interpretat de Zend Engine 2
care generează instrucțiuni interne – opcodes
www.php.net/manual/en/internals2.opcodes.php
www.phpinternalsbook.com
php: caracterizare

fazele importante ale interpretării
programelor PHP
vs. compilarea codului Java
codul PHP e interpretat de fiecare dată
când trebuie executat
program (script) PHP
procesare (parse)
compilareopcodes
execuție (Zend)
rezultat (output)
cod-sursă Java
procesare (parse)
compilarebytecodes
salvare cod binar
rezultat (output)
fișier binar (.class)
Java Virtual Machine
execuție compilare
execuție
interpretorPHP
compilatorJava

line # * op fetch ext return operands
----------------------------------------------------------------------------
3 0 > EXT_NOP
1 RECV !0
5 2 EXT_STMT
3 ADD_STRING ~0 'Hello+'
4 ADD_VAR ~0 ~0, !0
5 ECHO ~0
6 6 EXT_STMT
7 > RETURN null
<?php
class Greeting {
public function sayHello ($to)
{
echo "Hello $to";
}
}
$greeter = new Greeting ();
$greeter->sayHello ("World");
?>
opcodes
convertirea codului PHP
în opcodes
tinyurl.com/zn6c53x
avansat

php: caracterizare
pentru eficiență,
opcode-urile
sunt stocate
într-o memorie
partajată
avansat
execuție
program PHP
check opcode cache
procesare (parse)
compilareopcodes
salvare în
memoria partajată
nu există în cache există în cache (cached)
preluare din
memoria partajată
(shared memory)
execuție (Zend Engine)
rezultat (output)

php: caracterizare
diverse comportamente ale platformei PHP,
inclusiv încărcarea extensiilor (biblioteci partajate .so/.dll),
se pot configura via fișierul php.ini
precision = 14 ; controlul preciziei valorilor float – detalii la php.net/precision
safe_mode = Off ; controlul procesării – de studiat php.net/safe-mode
max_execution_time = 30 ; număr maxim de secunde privind execuția unui program
memory_limit = 128M ; dimensiunea maximă a memoriei alocate unui script
post_max_size = 8M ; dimensiunea maximă a datelor transmise prin metoda POST
default_mimetype = "text/html" ; tipul MIME implicit transmis de un script PHP
file_uploads = On ; sunt acceptate preluări (upload-uri) de fișiere
upload_max_filesize = 32M ; dimensiunea maximă a unui fișier preluat de la client
allow_url_fopen = On ; se permite deschiderea de fișiere specificate printr-un URL
session.use_cookies = 1 ; sesiunile Web vor recurge la cookie-uri
session.name = PHPSESSID ; numele cookie-ului referitor la sesiunea Web
…
; precizarea extensiilor încărcate la inițializarea serverului de aplicații
extension=php_pdo_sqlite.dll ; suport pentru SQLite via PDO (PHP Data Objects)
extension=php_mysqli.dll ; suport pentru MySQL
extension=php_soap.dll ; suport pentru servicii Web dezvoltate cu SOAP
…

Maniera de rulare a programelor PHP
– eventual, la nivel de bloc de cod –
poate fi ajustată via directiva declare
www.php.net/manual/en/control-structures.declare.php
// setul de caractere folosit pentru generarea conținutului
declare (encoding='UTF-8');
// verificare strictă a tipurilor de date la PHP 7+
declare (strict_types=1);
php: caracterizare

Pentru creșterea performanței,
se poate adopta compilarea JIT – just-in-time
HHVM – HipHop Virtual Machine (Facebook)
cod sursă PHPopcodescod mașină (e.g., x86-64)
www.hhvm.com  github.com/facebook/hhvm/
php: caracterizare
avansat
JIT

Pentru creșterea performanței,
se poate adopta compilarea JIT – just-in-time
HHVM – HipHop Virtual Machine (Facebook)
include și un server Web performant: Proxygen
permite încărcarea de extensii scrise în PHP/C++
utilizată de Baidu, Box, Etsy, Facebook, Wikipedia,…
php: caracterizare
avansat

php: caracterizare
Interacțiunea cu utilizatorul:
preluarea valorilor câmpurilor formularelor Web
cookie-uri
sesiuni
autentificarea utilizatorului
acces la variabile globale – create „din zbor”

php: caracterizare
Facilități pentru tehnologiile Web:
prelucrare de URL-uri
suport pentru HTTP – inclusiv cURL
caching via memcached
dezvoltare de servicii Web prin SOAP și REST
…și altele

php: caracterizare
Suport pentru acces la baze de date:
la nivel abstract
DBAL (DataBase Abstraction layer)
iODBC (Independent Open DataBase Connectivity)
PDO (PHP Data Objects)
www.phptherightway.com/#databases_abstraction_layers

php: caracterizare
Suport pentru acces la baze de date:
specific unui server de baze de date
relațional: DB2, MySQL, Oracle, PostgreSQL, SQLite,…
bazat pe NoSQL – e.g., MongoDB
a se parcurge www.phptherightway.com/#databases

php: caracterizare
Prelucrarea conținutului resurselor:
fișiere audio – via biblioteci: ktaglib, oggvorbis etc.
arhive de tip bzip2, LZF, RAR, ZIP, ZLIB
documente PDF
conținut grafic în diverse formate
fișiere în format JSON
documente XML – creare, procesare, validare etc.
informații privind cărți de credit
...

php: caracterizare
Suport pentru resurse de sistem + Internet:
sisteme de fișiere, inclusiv FTP
procese – cu Libevent, PCNTL, pthreads,...
răspuns la evenimente – via Event
socket-uri
poștă electronică – e.g., IMAP, POP3
...și multe altele

(în loc de) pauză
wronghands1.files.wordpress.com/2020/01/reference-shelf.jpg

PHP ca limbaj de programare procedurală

php: caracterizare
Programare procedurală
(procedural programming)
paradigmă bazată pe apeluri de proceduri (rutine, funcții)
conținând o serie de pași pentru realizarea calculelor
limbajele procedurale sunt imperative, utilizând
instrucțiuni (comenzi) ce modifică starea programului
exemple: FORTRAN (1954), ALGOL (1958),
BASIC (1964), Pascal (1970), C (1972), Ada (1978)

php: tipuri de date – scalare
boolean
TRUE sau FALSE

int
valori întregi specificate în baza…
10 (decimal) 3734
16 (hex) 0xE96
8 (octal) 07226
2 (binary) 0b111010010110
www.php.net/manual/en/language.types.integer.php

float
numere reale
reprezentate uzual conform IEEE 754 (dublă precizie)
dimensiunea reprezentării e dependentă de platformă
(precizia poate fi ajustată în fișierul de configurare php.ini)
www.php.net/manual/en/language.types.float.php
floating-point-gui.de

float
valoare specială:
constanta NAN (not a number)
funcții predefinite utile:
is_nan()
is_finite()
is_infinite()

string
șiruri de caractere ASCII
(începând cu PHP 7, există suport nativ pentru Unicode)

string
șiruri de caractere ASCII
(începând cu PHP 7, există suport nativ pentru Unicode)
pot fi folosite caractere escape precum
n (New Line) r (Carriage Return) t (Tab)
(Backslash) $ (Dollar) " (Double Quote) ' (Quote)

string
delimitatori uzuali:
" sau '
un șir nu poate avea mai mult de 2 GB

php: tipuri de date – compuse
array
asociere între valori (de orice tip)
și chei (de tip integer sau string)

array
nu există o distincție clară
între tablouri indexate și cele asociative
un tablou poate reprezenta diverse structuri de date:
listă (vector), tablou asociativ – hash (implementarea
unei asocieri de valori – mapping), dicționar, colecție,
stivă, coadă,…

array
// un tablou indexat (vector de valori) – sintaxa inițială
$cadouri = array ("ceas", "prăjitură", "colier", "topor");
// un tablou asociativ – perechi <cheie, valoare>
array ( "nume" => "Tux", "dimensiune" => 17, "oferta" => TRUE );
// sintaxa simplificată – preferată (începând cu PHP 5.4)
[ "nume" => "Tux", "dimensiune" => 17, "oferta" => TRUE ];

object
instanță a unei clase
creat cu operatorul new

php: tipuri de date – speciale
resource
semnifică o referință la o resursă externă
exemplificări: bzip2, curl, ftp, gd, mysql link, mysql result,
pdf document, printer, stream, socket, xml, zlib
o resursă e creată de funcții specifice
e.g., resursa de tip stream inițiată de funcția fopen()
și folosită apoi de funcțiile fread(), feof(), fgets() etc.

resource
semnifică o referință la o resursă externă
funcții predefinite:
is_resource()
get_resource_type()
detalii la www.php.net/manual/en/resource.php

null
specifică valoarea NULL
reprezentând o variabilă care nu are valoare
funcții utile:
is_null()
unset()

php: variabile
Variabilele au nume compuse din litere, cifre și
caractere _ prefixate de simbolul $
pot stoca valori – aparținând unui tip de date –
sau referințe (specificate cu &)
www.php.net/manual/en/language.variables.php

php: variabile
Variabile create „din zbor”
tipul de date e determinat pe baza contextului
convertirea automată a tipului (type casting)
e similară celei de la limbajul C
$ani = 21; /* o variabilă de tip Int */
$conectat = TRUE; # una de tip Boolean
$prefer["culoare"] = "gri"; // un tablou asociativ

$nume = 'Tux';
// comportament diferit privitor la substituția valorii efective
// a unei variabile în funcție de delimitatorii folosiți
// pentru șirurile de caractere
echo "Salut $nume!n";
echo 'Salut $nume!n';
execuția online a codului PHP via instrumentul Web Ideone
Salut Tux!
Salut $nume!n

php: variabile
Funcții predefinite utile:
var_dump()
settype()
is_bool(), is_int(), is_float(), is_array(), is_string()
is_scalar(), is_numeric()
…și altele

php: variabile
Vizibilitatea variabilelor (scope)
pentru a putea fi folosite în întreg programul,
variabilele trebuie declarate ca fiind globale
php.net/manual/en/language.variables.scope.php

$scor = 33;
function oferaScor () {
echo "Scor curent: " . $scor;
}
oferaScor();
Undefined variable:
scor in prog.php on line 4
$scor = 33;
function oferaScor () {
global $scor;
echo "Scor curent: " . $scor;
// similar cu $GLOBALS["scor"]
}
oferaScor();
Scor curent: 33

php: variabile
Vizibilitatea variabilelor (scope)
o variabilă poate fi declarată ca fiind statică
există doar în domeniul de vizibilitate local
(e.g., în cadrul unei funcții), dar nu-și pierde valoarea
atunci când execuția programului părăsește
acel domeniu de vizibilitate

php: variabile
Eliberarea memoriei alocate se realizează automat
(garbage collection)
fiecare variabilă are asociat în memorie un container (zval)
vezi funcția xdebug_debug_zval() oferită de extensia Xdebug
www.php.net/manual/en/features.gc.php

php: variabile predefinite
Variabile disponibile în întreg programul
(superglobals)
$GLOBALS [ ]
tablou asociativ ce conține referințe
la toate variabilele definite global

$_SERVER [ ]
$_GET [ ] $_POST [ ] $_FILES [ ] $_REQUEST [ ]
$_SESSION [ ]
$php_errormsg
$argc $argv
...

$_SERVER [ ]
$_GET [ ] $_POST [ ] $_FILES [ ] $_REQUEST [ ]
$_SESSION [ ]
$php_errormsg
$argc $argv
...
specifice
serverului Web
cereri HTTP
ale clientuluidate despre
sesiunea Web
mesaj de eroare
raportat
argumente în
linia de comandă

php: constante
Specificate cu define ( )
sunt disponibile la nivel global în program
define ( string $nume , mixed $valoare ) : bool
define ("DIMENS_MIN", 13);
www.php.net/manual/en/function.define.php

php: constante predefinite
Exemplificări:
PHP_VERSION
PHP_OS
PHP_EOL
PHP_INT_MAX
PHP_INT_SIZE
DIRECTORY_SEPARATOR
TRUE
FALSE
NULL

Controlul manierei de raportare a erorilor:
E_ERROR erori fatale (execuția script-ului e oprită)
E_WARNING avertismente
E_PARSE erori de procesare a codului (parsing)
E_NOTICE notificări în timpul rulării
E_STRICT sugestii privind îmbunătățirea codului
E_DEPRECATED notificări despre aspecte demodate
www.php.net/manual/en/errorfunc.constants.php
www.phptherightway.com/#errors_and_exceptions

Mediul de execuție oferă acces la constante „magice”
ale căror valori pot fi folosite în cadrul programului
__LINE__
__FILE__
__DIR__
__FUNCTION__
__CLASS__
__TRAIT__
__METHOD__
__NAMESPACE__
avansat

php: operatori
Majoritatea, similari celor din limbajul C
aritmetici: + - * / % ++ --
asignare a valorii: = și => (pentru tablouri)
referință: &
asignare prin referință: =&
pe biți: & | ^ << >>
comparații: == === != <> !== < > <= >= ?: ?? <=>
control al raportării erorilor: @
logici: and or xor ! && ||
șiruri de caractere (concatenare) – ca la Perl: . .=

php: operatori
În PHP 7+, se pot folosi și noii operatori:
<=> (spaceship)
compararea a două expresii (de tip scalar),
întorcând –1, 0 sau 1
echo 15.5 <=> 15.5; // 0 (egalitate)
echo 15.5 <=> 16.5; // -1 (mai mic)
echo 17.5 <=> 15.5; // 1 (mai mare)

php: operatori
În PHP 7+, se pot folosi și noii operatori:
?? (null coalescing)
oferă valoarea primului operand dacă există și nu e NULL,
altfel întoarce valoarea celui de-al doilea operand
// folosim ca nume de utilizator valoarea furnizată în formular
// (preluată prin GET sau POST); dacă nu există, va fi 'tux'
$username = $_GET['user'] ?? $_POST['user'] ?? 'tux';

php: structuri de control
if, switch, while, do, for, break, continue
asemănătoare celor din C
if (!$nume) {
echo ("Numele nu a fost furnizat…");
} else {
echo ("Bine ai venit, " . $nume . "!n");
}

php: exemplu
<?php
// umplem un tablou cu valori de la 1 la 10
for ($index = 1; $index <= 10; $index++) {
$values[$index] = $values;
}
// realizăm suma valorilor
$sum = 0;
foreach ($values as $item)
$sum += $item;
/* afișăm suma obținută la ieșirea standard
pentru a fi trimisă clientului Web */
echo ("<p>Sum of first 10 numbers is <strong>" .
$sum . "</strong>.</p>");
?>

Invocarea (rularea) programului PHP direct
din linia de comandă:
salvăm codul într-un fișier text – values.php
apelăm interpretorul PHP din linia de comandă
php values.php
<p>Sum of first 10 numbers is <strong>55</strong>.</p>

Invocarea (rularea) programului PHP
la nivelul serverului Web:
plasăm fișierul sursă – cu drepturi de citire și execuție
în navigator, indicăm URL-ul către program
pentru a-l invoca via metoda GET a protocolului HTTP
rezultatul generat
de script

Includerea de cod-sursă din alte fișiere
(suport pentru modularizare)
include
caută fișierul sursă în directoarele predefinite specificate
via include_path și-l evaluează
dacă fișierul nu există, se generează un avertisment
include_once – pentru a-l include o singură dată

Includerea de cod-sursă din alte fișiere
(suport pentru modularizare)
require
caută fișierul sursă în directoarele predefinite specificate
via include_path și-l evaluează
dacă fișierul nu există, se emite o eroare fatală
require_once – pentru a-l include o singură dată

Funcții definite de utilizator:
function trimiteMesaj ($exped="", $dest="", $subiect="Web") {
// corp…
}
php: funcții
parametri cu
valori implicite
php.net/manual/en/language.functions.php

define ('MAX', 10); // numărul maxim de valori
function patrat ($numar) { // funcția de ridicare la pătrat
return $numar * $numar;
}
$numar = 0;
while ($numar < MAX) {
$numar++; // incrementăm numărul
if ($numar % 2) // e număr impar...
continue; // continuăm cu următoarea iterație
// e număr par, deci afișăm pătratul lui
echo "$numar la pătrat este " . patrat ($numar) . "n";
} // final de while

Funcții definite de utilizator:
php: funcții
numele funcțiilor sunt considerate case-insensitive
parametrii pot fi dați prin referință – prefixați de &
la PHP 5.6+, numărul variabil de parametri e indicat de …
php.net/manual/en/functions.arguments.php

infomagic ();
function infomagic () {
printf("<p>Sunt <code>%s()</code> și execut linia %d
din <code>%s</code>.</p>", __FUNCTION__, __LINE__, __FILE__);
printf("<p>Folosesc PHP <code>%s</code> de pe <code>%s</code>
cu serverul Web <code>%s</code>.</p>",
PHP_VERSION, php_uname(), $_SERVER['SERVER_SOFTWARE']);
}
Funcțiile sunt vizibile oriunde în program:

infomagic ();
function infomagic () {
printf("<p>Sunt <code>%s()</code> și execut linia %d
din <code>%s</code>.</p>", __FUNCTION__, __LINE__, __FILE__);
printf("<p>Folosesc PHP <code>%s</code> de pe <code>%s</code>
cu serverul Web <code>%s</code>.</p>",
PHP_VERSION, php_uname(), $_SERVER['SERVER_SOFTWARE']);
}
 Sunt infomagic() și execut linia 15 din /opt/lampp/htdocs/magic.php.
Folosesc PHP 7.4.2 de pe Linux debian 4.9.0-11-amd64 #1 SMP
Debian 4.9.189-3+deb9u2 (2019-11-11) x86_64 cu serverul Web
Apache/2.4.41 (Unix) OpenSSL/1.1.1d PHP/7.4.2
mod_perl/2.0.8-dev Perl/v5.16.3.
Funcțiile sunt vizibile oriunde în program:

php: funcții
<?php
// argumentele trebuie să fie întregi, valoarea oferită trebuie să fie de tip int
function aduna (int ...$numere): int {
$suma = 0;
foreach ($numere as $numar) {
$suma += $numar;
}
return $suma;
}
echo aduna (7, 3, 74, 1);
echo aduna (pi (), '?');
pentru PHP 7+, se poate preciza și tipul de date
pentru fiecare argument, plus valoarea întoarsă de funcție
(scalar type declarations)
85
Fatal error: Uncaught TypeError:
Argument 1 passed to aduna() must
be of the type integer, float given
Next TypeError: Argument 2 passed
to aduna() must be of the type
integer, string given

Începând cu PHP 5.3,
pot fi specificate și funcții anonime
programare funcțională – e.g., closures
$saluta = function ($nume) { // variabilă de tip funcție
printf ("Salut %s...n", $nume);
};
$saluta ('lumea');
$saluta ('Tuxy');
php: funcții
vezi www.phptherightway.com/pages/Functional-Programming.html

Funcțiile anonime se pot specifica prescurtat
de la versiunea PHP 7.4 (lansată pe 28 noiembrie 2019)
short closures
concept asemănător cu arrow functions
construcție funcțională disponibilă
în limbajul JavaScript (ECMAScript 6 – ES6)
php: funcții

declare (strict_types=1); // verificare strictă a tipurilor de date
header ('Content-type: text/plain'); // trimitem clientului text neformatat
// declararea prescurtată a unei funcții anonime
// care are un argument de tip string la intrare și întoarce int
// variabilă de tip funcție: fn(argument) => corp
// (pentru corp, se permite o singură expresie; 'return' nu e permis)
$salută = fn(string $nume): int => printf("Salut %s! [la %s].n",
$nume, date("j-m-Y H:i:s T", time()));
$salută('lume');
sleep(2); // se așteaptă 2 secunde...
$salută('Tuxy');
 Salut lume! [la 21-02-2020 13:10:34 CET].
Salut Tuxy! [la 21-02-2020 13:10:36 CET].

php: funcții predefinite
matematice și de conversie
de manipulare a șirurilor de caractere
de prelucrare a tablourilor
de acces la resurse și de lucru cu fișiere
de manipulare a bazelor de date
privitoare la conexiunile de rețea
criptografice
pentru accesarea resurselor XML, PDF, JPEG,...
specifice sistemului de operare
generale
detalii la php.net/manual/en/funcref.php

Matematice:
abs(), mod(), fmod()
ceil(), floor(), round(), max(), min()
exp(), log10(), log()
pow(), sqrt()
sin(), cos(), tan(), asin(), …, sinh(), …, pi()
rand(), srand()
bindec(), octdec(), dechex(),…, base_convert()
is_finite(), is_infinite(), is_nan()
php.net/manual/en/refs.math.php

Șiruri de caractere:
echo(), print(), printf(), sprintf() etc.
strlen(), chr(), ord(), substr(), strstr(), strpos(),…
strcmp(), strcasecmp(), strnatcmp() etc.
strcat(), str_replace(), str_ireplace(), strrev() etc.
trim(), ltrim(), rtrim()
explode(), implode(), split(), join(), strtok()
amănunte vizând procesarea textelor:
php.net/manual/en/refs.basic.text.php

Expresii regulate:
conform standardului POSIX
ereg(), ereg_replace(), split() etc.
compatibile cu cele din Perl – PCRE: www.pcre.org
preg_filter(), preg_grep(), preg_match(), preg_split(),…

un instrument Web
de testare și depanare
a expresiilor regulate
regex101.com/#PCRE

Tablouri:
array_count_values(), array_search(), array_filter(),
array_slice(), array_chunk()
array_fill(), array_combine(), array_shift(),
array_reverse(), array_multisort(), array_sum(),…
array_merge(), array_intersect(), array_diff()
array_keys(), array_key_exists()
array_push(), array_pop()
array_map(), array_reduce()
php.net/manual/en/book.array.php

/* filtrarea unor valori dintr-un tablou
pe baza unei funcții specificate de programator */
function valoare_mai_mica_decat ($numar) {
// întoarce o expresie de tip funcție – closure: abordare funcțională
return function ($element) use ($numar) {
return $element < $numar;
};
}
$punctaje = [ 7, 8, 9, 10, 7.5, 3, 10, 8.75, 4 ];
// folosim funcția predefinită array_filter() asupra tabloului cu punctaje
// pentru a obține valorile mai mici decât o valoare dată (aici: 7)
$valori = array_filter ($punctaje, valoare_mai_mica_decat (7));
print_r ($valori);
a se studia și wiki.php.net/rfc/closures
avansat
Array
(
[5] => 3
[8] => 4
)

$web = [ 'JS', 'PHP' ];
$mofturi = [ 'Lua', 'Rust', 'Scala' ];
$limbaje = [ 'C#', ...$web, 'Java' ];
print_r ($limbaje);
// fuziune – similar cu array_merge()
print_r ([ ...$mofturi, ...$web ]);
avansat
În PHP 7.4+ se poate folosi operatorul …
în cadrul tablourilor (asemănător cu ECMAScript 2018)
Array
(
[0] => C#
[1] => JS
[2] => PHP
[3] => Java
)
Array
(
[0] => Lua
[1] => Rust
[2] => Scala
[3] => JS
[4] => PHP
)

Procesarea caracterelor:
ctype_digit(), ctype_xdigit(), ctype_print(),
ctype_punct(), ctype_space(),…
ctype_alpha(), ctype_alnum(), ctype_lower(),
ctype_upper()

Dată & timp:
getdate(), localtime(), gettimeofday(), time() etc.
date(), idate(), gmdate(),…
checkdate()
strftime(), strtotime()
vezi și extensiile Calendar, DateTime, HRTime

Variabile PHP:
empty(), isset(), unset()
strval(), print_r(), var_dump()
serialize(), unserialize()
a se consulta și php.net/manual/en/book.var.php

Fișiere și directoare:
folosind tipul de date FILE – ca la limbajul C:
fopen(), fread(), fscanf(), fgets(), fwrite(), fprintf(),
fseek(), ftell(), feof(), fclose(), ftruncate(), fstat(),...
file(), copy(), rename(), delete(),
move_uploaded_file(), tmpfile()
file_exists(), filesize(), filetype(), fileperms(),…, stat()
is_dir(), is_file(), is_readable(), is_writeable(),…
chdir(), mkdir(), rmdir()
disk_free_space(), disk_total_space()
de studiat și php.net/manual/en/refs.fileprocess.file.php

URL-uri:
urldecode(), urlencode(), parse_url()
base64_decode(), base64_encode()
http_build_query()

define('URL', 'http://undeva.info:8080/oferta/jucarii/produs/?nume=Tux&marime=17#oferta');
header('Content-type: text/plain'); // conținutul trimis clientului va fi text obișnuit
// divizarea unui URL pe componente ale unui tablou asociativ
$adresaWeb = parse_url(URL);
foreach(array_keys($adresaWeb) as $componenta) {
printf("%s=%sn", $componenta, $adresaWeb[$componenta]);
}
// procesăm șirul de interogare (query_string al URL-ului)
// fiecare parametru va fi stocat în tabloul $parametri
parse_str($adresaWeb['query'], $parametri);
if ($parametri['marime'] < 13) {
echo "Jucăria nu e în regulă...n";
} else {
echo "Jucăria e bună (" . $parametri['marime'] . ")
și are numele " . $parametri['nume'] . ".n";
}
procesarea componentelor unui URL:

define('URL', 'http://undeva.info:8080/oferta/jucarii/produs/?nume=Tux&marime=17#oferta');
header('Content-type: text/plain'); // conținutul trimis clientului va fi text obișnuit
// divizarea unui URL pe componente ale unui tablou asociativ
$adresaWeb = parse_url(URL);
foreach(array_keys($adresaWeb) as $componenta) {
printf("%s=%sn", $componenta, $adresaWeb[$componenta]);
}
// procesăm șirul de interogare (query_string al URL-ului)
// fiecare parametru va fi stocat în tabloul $parametri
parse_str($adresaWeb['query'], $parametri);
if ($parametri['marime'] < 13) {
echo "Jucăria nu e în regulă...n";
} else {
echo "Jucăria e bună (" . $parametri['marime'] . ")
și are numele " . $parametri['nume'] . ".n";
}
procesarea componentelor unui URL:
scheme=http
host=undeva.info
port=8080
path=/oferta/jucarii/produs/
query=nume=Tux&marime=17
fragment=oferta
Jucaria e în regulă (17)
și are numele Tux.

Prelucrarea resurselor Web (HTML, JSON):
nl2br(), htmlentities(), htmlspecialchars(), strip_tags()
get_browser(), show_source(), highlight_string(),...
json_encode(), json_decode(), json_last_error()

// piesele albumului 'Animals' de Pink Floyd (1977) exprimate în Unicode
$animals = [ "🐷 on the Wing #1", "Dogs 🐕",
[ "🐖🐖🐖" => "Pigs (Three Different Ones)" ],
"Sheep 🐑", "🐷 on the Wing #2" ];
$json = json_encode($animals); // codificăm (serializăm) în JSON
$animals2 = json_decode($json); // decodificăm datele JSON
// informații privind variabilele folosite
var_dump($animals, $animals2, $json);
(de)codificarea de date interne ↔ date JSON:

$animals
array(5) {
[0]=>
string(19) "🐷 on the Wing #1"
[1]=>
string(16) "Dogs 🐕"
[2]=>
array(1) {
["🐖🐖🐖"]=>
string(27) "Pigs (Three Different Ones)"
}
[3]=>
string(10) "Sheep 🐑"
[4]=>
}
$animals2
array(5) {
[0]=>
[1]=>
string(16) "Dogs 🐕"
[2]=>
object(stdClass)#1 (1) {
["🐖🐖🐖"]=>
string(27) "Pigs (Three Different Ones)"
}
[3]=>
string(10) "Sheep 🐑"
[4]=>
}
$json
string(191) "["ud83dudc37 on the Wing #1","Dogs ud83dudc15u200dud83euddba",
{"ud83dudc16ud83dudc16ud83dudc16":"Pigs (Three Different Ones)"},
"Sheep ud83dudc11","ud83dudc37 on the Wing #2"]"

Suport pentru operații criptografice:
password hashing – funcțiile password_*()
extensii utile
CSPRNG (generare de numere pseudo-aleatoare – la PHP 7+)
Hash (funcții hash_*() – de tip digest)
OpenSSL (funcționalități ce vizează SSL/TLS)
Sodium (operații de (de)criptare avansate – cazul PHP 7.2+)
amănunte la php.net/manual/en/refs.crypto.php

Suport vizând conținutul grafic (raster/vectorial):
extensii preinstalate
Cairo – procesări vectoriale/raster: www.cairographics.org
EXIF – acces la meta-date JPEG
GD – prelucrări raster (GIF, JPEG, PNG): libgd.github.io
ImageMagick – procesări multi-format: www.imagemagick.org
php.net/manual/en/refs.utilspec.image.php

Alte funcții utile:
die(), eval(), exit(), sleep(), usleep(), time_sleep_until()
uniqid(), sys_getloadavg()
php_info(), php_check_syntax()

php: alte facilități
SPL (Standard PHP Library)
acces la maniere standard de prelucrare a datelor
structuri de date definite:
SplStack, SplQueue, SplHeap, SplPriorityQueue,...
iteratori:
ArrayIterator, FilesystemIterator, RegexIterator etc.
www.php.net/spl
www.phptherightway.com/#standard_php_library
avansat

Alte extensii de bază preinstalate
în cazul PHP 7+, se pot folosi structuri de date eficiente
interfețe:
Collection Hashable Sequence
clase:
Vector Deque Map Pair Set Stack Queue PriorityQueue
www.php.net/manual/en/book.ds.php
avansat

Alte extensii de bază preinstalate
YAML – suport pentru YAML Ain’t Markup Language
Swoole – acces la rețea: TCP, UDP, HTTP, WebSocket
Streams – lucrul cu fluxuri („șuvoaie”) de date
SeasLog – facilități pentru jurnalizare
GeoIP – localizare geografică
Parsekit – analizarea opcode-urilor PHP
www.php.net/manual/en/refs.basic.other.php
avansat

Controlul execuției proceselor
extensii de interes
(unele disponibile doar pe sisteme Linux)
Eio, Ev, Expect, Libevent, PCNTL, POSIX, parallel,
pthreads, pht, Semaphore, Shared Memory, Sync
www.php.net/manual/en/refs.fileprocess.process.php
avansat

Controlul execuției proceselor
rularea asincronă a codului se poate realiza
via biblioteci suplimentare
exemplificare:
ReactPHP
facilitează realizarea de operații asincrone – neblocante –
de intrare/ieșire asincrone bazate pe evenimente
reactphp.org
avansat

Execuția programelor din linia de comandă
PHP CLI
php.net/manual/en/features.commandline.php
avansat

PHP ca modul al unui server Web (Apache, NGINX)
e.g., pe baza modulelor proxy_fcgi
și php-fpm (FastCGI Process Manager) – php-fpm.org
wiki.apache.org/httpd/php
www.nginx.com/resources/wiki/start/topics/examples/phpfcgi/
avansat

PHP 5.4+ oferă un server Web incorporat
exemplu de invocare:
php –S localhost:8000 –t phpwebapp/
php.net/features.commandline.webserver
avansat

Inter-conectivitatea cu alte tehnologii/platforme
exemple de extensii:
V8js – procesarea și rularea codului JavaScript
via procesorul V8 (Google) folosit de Chrome și Node.js
www.php.net/manual/en/book.v8js.php
Lua + LuaSandbox – interpretarea programelor Lua
www.php.net/manual/en/book.luasandbox.php
avansat

Care-i suportul oferit de PHP
pentru programarea obiectuală?

php: caracterizare
Programare obiectuală
(object-oriented programming)
paradigmă bazată pe conceptul de obiect – incluzând
date (atribute, proprietăți) și cod (metode, proceduri)
uzual, obiectele interacționează între ele
și reprezintă instanțe de clase
exemple: Smalltalk (1972), Objective-C (1984),
C++ (1985), Python (1990), Java (1995), C# (2000)

php: clase
Suport pentru definirea claselor via class
și de instanțiere prin operatorul new
obiectele sunt tratate similar referințelor
(o variabilă de tip obiect conține o referință la un obiect
și nu o copie a lui)
php.net/manual/en/oop5.intro.php
detalii la php.net/language.oop5

programare obiectuală – încapsularea
class Student { // specificarea unei clase
// proprietăți (date-membre)
private $an;
private $email;
public $nume;
// metode publice
public function seteazaAn ($unAn) {
$this->an = $unAn;
}
public function furnizeazaAn () {
return $this->an;
}
}
$this este o pseudo-variabilă
specificând o referință la obiectul curent

programare obiectuală – încapsularea
class Student { // specificarea unei clase
// proprietăți (date-membre)
private $an;
private $email;
public $nume;
// metode publice
public function seteazaAn ($unAn) {
$this->an = $unAn;
}
public function furnizeazaAn () {
return $this->an;
}
}
// instanțierea unui obiect
$stud = new Student ();
$stud->seteazaAn (2);
$stud->nume = 'Tux';
print_r ($stud);
Student Object
(
[an:Student:private] => 2
[nume] => Tux
[email:Student:private] =>
)

php: clase
Ca la C++, membrii – proprietăți sau metode –
pot fi declarați ca fiind
publici (public)
privați (private)
protejați (protected)

programare obiectuală – moștenirea
class StudentDestept extends Student {
private $note; // notele obținute (proprietate)
public function seteazaNote ($n) {
$this->note = (array) $n;
}
public function furnizeazaNote () {
return (array) $this->note;
}
}
$altStud = new StudentDestept ();
// apel de metodă din clasa de bază
$altStud->seteazaAn (2);
// apel de metodă din clasa derivată
$altStud->seteazaNote (
['TW' => 10, 'IP' => 9]
);

programare obiectuală – moștenirea
class StudentDestept extends Student {
private $note; // notele obținute (proprietate)
public function seteazaNote ($n) {
$this->note = (array) $n;
}
public function furnizeazaNote () {
return (array) $this->note;
}
}
$altStud = new StudentDestept ();
// apel de metodă din clasa de bază
$altStud->seteazaAn (2);
// apel de metodă din clasa derivată
$altStud->seteazaNote (
['TW' => 10, 'IP' => 9]
);
print_r ($altStud);
StudentDestept Object
(
[note:StudentDestept:private]
=> Array
(
[TW] => 10
[IP] => 9
)
[an:Student:private] => 2
[nume] =>
[email:Student:private] =>
)

php: clase
Metode speciale:
constructorii sunt numiți __construct()
destructorii sunt denumiți __destruct()

php: clase
Accesarea proprietăților/metodelor
statice, constante sau suprascrise
::
scope resolution operator (Paamayim Nekudotayim)
www.php.net/manual/en/language.oop5.paamayim-nekudotayim.php

php: clase
Accesarea proprietăților/metodelor
statice, constante sau suprascrise
::
self – clasa curentă
parent – clasa părinte

de la versiunea PHP 7.4 (2019) se poate specifica explicit
tipul de date al proprietăților definite de o clasă
class Student {
// proprietăți cu tip
private int $an;
private string $email;
public string $nume;
// etc.
}
$stud = new Student ();
$stud->nume = TRUE;
Fatal error: Uncaught TypeError:
Typed property Student::$nume
must be string, bool used
instrument Web de testare: sandbox.onlinephpfunctions.com

php: clase
Proprietățile sau metodele declarate cu static
pot fi accesate fără a fi nevoie de instanțierea clasei
pentru exemple, a se studia
www.php.net/manual/en/language.oop5.static.php

php: clase
Se permit clase/metode abstracte declarate cu abstract
clasele abstracte nu pot fi instanțiate
orice clasă având măcar o metodă abstractă
este considerată abstractă
metodele abstracte trebuie implementate
în clasa copil (specificată cu extends) a clasei abstracte

php: interfețe
Specificarea metodelor ce vor fi ulterior implementate
de o clasă (ca la Java)
// interfața privind o machetă de vizualizare (template)
interface iMacheta {
// setează o variabilă ce va fi substituită
// cu valoarea ei în cadrul machetei
public function setVar ($nume, $var);
// furnizează reprezentarea machetei
public function oferaReprez ($macheta);
}
amănunte la php.net/manual/en/language.oop5.interfaces.php

// clasa implementând interfața
class Macheta implements iMacheta {
// tablou asociativ cu variabilele ce trebuie înlocuite cu valorile lor
private $variabile = array ();
public function setVar ($nume, $var) {
$this->variabile[$nume] = $var;
}
public function oferaReprez ($macheta) {
foreach ($this->variabile as $nume => $val) {
// substituim în machetă numele variabilelor cu valorile lor
$macheta = str_replace ('{' . $nume . '}', $val, $macheta);
}
return $macheta;
}
}
aspecte mai avansate: www.phptherightway.com/#templating

php: interfețe & clase predefinite
Traversable
Iterator
IteratorAggregate
Throwable
ArrayAccess
Serializable
Closure
Generator
www.php.net/manual/en/reserved.interfaces.php

php: interfețe & clase predefinite
// exemplificare: interfața Iterator
Iterator extends Traversable {
// metode ce trebuie scrise de programator
// în clasa ce implementează interfața
abstract public mixed current ( void )
abstract public scalar key ( void )
abstract public void next ( void )
abstract public void rewind ( void )
abstract public boolean valid ( void )
}

php: introspecție
Acces la informații vizând o clasă:
un program PHP poate obține date referitoare la clase,
interfețe, funcții, metode, extensii – reverse engineering
ReflectionClass implements Reflector
php.net/manual/en/book.reflection.php

php: introspecție
$clasa = new ReflectionClass ('StudentDestept');
// afișăm informații despre clasa specificată
printf ("<p>Clasa <em>%s</em> extinde %s
și e declarată în fișierul <tt>%s</tt>.</p>",
$clasa->getName (), var_export ($clasa->getParentClass (), 1),
$clasa->getFileName ());
Clasa StudentDestept extinde
ReflectionClass::__set_state(array( 'name' => 'Student', ))
și e declarată în fișierul /home/profs/busaco/html/php/introspect.php.

php: trăsături de clasă (traits)
Trait
concept preluat de la limbajul Self
oferit de PHP 5.4+
colecție de metode ce pot fi refolosite în cadrul altor clase
www.php.net/manual/en/language.oop5.traits.php

Trait
considerat ca șablon (template C++) al unei clase
față de interfețe, oferă implementări ale metodelor,
nu doar signaturile lor
astfel, se oferă suport pentru pseudo-moștenire multiplă
aspecte formale: scg.unibe.ch/research/traits

// trăsături (comportamente) asociate unor figuri geometrice 2D
trait Rotire {
public function roteste ($unghi) { // implementează rotirea
}
}
trait Mutare {
public function mutaLa ($x, $y) { // mută la alte coordonate
}
}
trait Colorare {
public function coloreaza ($culoare) { // realizează colorarea
}
}

abstract class Figura { // clasa figurilor geometrice
public function deseneaza () {
echo ('Am desenat ' . get_class());
}
}
class Dreptunghi extends Figura {
// folosește trăsăturile dorite
use Colorare, Mutare, Rotire; // poate fi colorat, mutat, rotit
public function transforma () { // o transformare specifică
}
}

// clasa Cerc nu mai poate fi extinsă
final class Cerc extends Figura {
// un cerc poate fi mutat și colorat
use Mutare, Colorare;
// declararea unei constante proprii
const PI = 3.1415265;
// specificarea unei metode
public function calculeazaArie () {
}
}

// instanțiem 2 figuri: un cerc și un dreptunghi
$unCerc = new Cerc ();
$unDreptunghi = new Dreptunghi ();
$unCerc->deseneaza ();
$unCerc->roteste (); // va cauza emiterea unei erori
$unDreptunghi->deseneaza ();
Am desenat Cerc
PHP Fatal error: Call to undefined method Cerc::roteste()
in /home/dMdWgn/prog.php on line 47

php: proprietăți speciale
O clasă are asociate proprietăți speciale („magice”)
ce pot fi suprascrise
__construct ()
__destruct ()
__toString ()
__get ()
__set ()
altele la www.php.net/manual/en/language.oop5.magic.php

php: obiecte
Obiectele pot fi „clonate” via clone
Obiectele se pot compara folosind operatorul ===

php: obiecte
Funcții de manipulare a claselor și obiectelor
get_class() va returna numele unui obiect,
instanță a unei clase
get_parent_class() furnizează clasa părinte
din care provine un anumit obiect
method_exists() testează dacă există o metodă
pentru un anumit obiect specificat
class_exists() testează existența unei clase
is_subclass_of() determină dacă există o relație
de moștenire dintre două clase

php: excepții
try catch throw
clasa Exception
similare celor din Java
detalii la www.php.net/manual/en/language.exceptions.php

php: spații de nume
Folosite pentru evitarea coliziunilor de nume și
pentru efectuarea de alias-uri
declarare cu namespace (prima linie de program)

declarare cu namespace (prima linie de program)
exemplu: namespace Facebook; // Facebook SDK for PHP
de aprofundat www.phptherightway.com/#namespaces

același spațiu de nume poate fi definit în fișiere multiple
pot exista ierarhii de (sub-)spații de nume
namespace ProiectModulSubmodul;
class GenSVG { ... };
referire cu
ProiectModulSubmodulGenSVG

utilizare prin use (eventual specificând un alias)
use ProiectModulSubmodul;

utilizare prin use (eventual specificând un alias)
use ProiectModulSubmodul;
exemple concrete:
use FacebookAuthenticationAccessToken;
use IlluminateFoundationExceptionsHandler as ExceptionHandler;

construcțiile care nu aparțin niciunui spațiu de nume
definit sunt considerate ale spațiului de nume global
namespace ProiectWeb;
function fopen () { // specificarea unei funcții proprii
...
$fisier = fopen (...); // apel de funcție predefinită (din spațiul global)
}

Care sunt facilitățile
vizând interacțiunea Web?

php: interacțiune web
Datele de la client (browser) se regăsesc
în tablouri asociative predefinite (și globale):
$_GET[ ] – datele transmise prin metoda GET
$_POST[ ] – datele expediate prin POST
$_COOKIE[ ] – cookie-urile receptate
$_REQUEST[ ] – datele primite de la client
(conținutul lui $_GET, $_POST și $_COOKIE)
$_SESSION[ ] – datele referitoare la sesiunile Web

Alte variabile globale utile:
$_SERVER[ ]
oferă informații privind serverul Web
$_SERVER['PHP_SELF'] indică numele script-ului PHP
$_SERVER['REQUEST_METHOD'] – metoda HTTP folosită
$_SERVER['HTTP_REFERER'] – URL-ul referind resursa
$_SERVER['HTTP_USER_AGENT'] – detalii despre client
www.php.net/manual/en/reserved.variables.server.php

Alte variabile globale utile:
$_ENV[ ] – date despre mediul (environment) de execuție
$_FILES[ ] – datele despre fișierele primite prin upload
www.php.net/manual/en/features.file-upload.php
vezi exemplul din arhiva
aferentă prelegerii

<form action="afiseaza.php" method="post">
<input type="text" name="nume" />
<input type="text" name="varsta" />
<input type="submit" value="Trimite" />
</form>

<form action="afiseaza.php" method="post">
<input type="text" name="nume" />
<input type="text" name="varsta" />
<input type="submit" value="Trimite" />
</form>
<?php
// programul afiseaza.php invocat prin POST
if (!$_REQUEST["nume"])
echo ("Nu ați specificat numele!");
else
echo ("Numele este" . $_REQUEST["nume"]);
?>
fiecare nume de câmp din formular reprezintă
o cheie a tabloului asociativ $_REQUEST [ ]
(în funcție de metoda HTTP, poate fi regăsit în $_GET sau $_POST)

php: cookie-uri – creare
Stabilirea unui cookie via funcția setcookie ()
setcookie ( string $nume_cookie
[, string $valoare = "" [, int $timp_expirare = 0
[, string $cale = "" [, string $domeniu = ""
[, bool $securizare = FALSE [, bool $httponly = FALSE ]]]]]] ) : bool

php: cookie-uri – creare
Stabilirea unui cookie via funcția setcookie ()
setcookie ( string $nume_cookie
[, string $valoare = "" [, int $timp_expirare = 0
[, string $cale = "" [, string $domeniu = ""
[, bool $securizare = FALSE [, bool $httponly = FALSE ]]]]]] ) : bool
setcookie ("vizita", "1", time()+3600); // persistent – expiră peste 1h
setcookie ("culoare", "verde"); // nepersistent – de ce?
…
echo "Un cookie de culoarea " . $_COOKIE["culoare"];

php: cookie-uri – expirare
Eliminarea unui cookie:
se anulează valoarea și timpul;
eventual, celelalte atribute ale cookie-ului
setcookie ($nume_cookie, "", 0, "/", "");
detalii la www.php.net/manual/en/function.setcookie.php

php: cookie-uri – consultare
Cookie-ul e specificat (accesat) ca o variabilă
$_COOKIE ['nume_cookie']
tablou asociativ
global

php: sesiuni web
Managementul sesiunilor: funcțiile session_start(),
session_register(), session_id(), session_unset(), session_destroy()
<?php
session_start (); // inițiem o sesiune
if (!isset ($_SESSION['accesari'])) {
$_SESSION['accesari'] = 0; } else {
$_SESSION['accesari']++; }
variabila
accesari atașată
sesiunii
detalii la php.net/manual/en/book.session.php

php: sesiuni web
Managementul sesiunilor: clasa SessionHandler
SessionHandler implements SessionHandlerInterface {
public bool open ( string $save_path , string $session_name ) : bool
public string create_sid ( void ) : string
public string read ( string $session_id ) : string
public bool write ( string $session_id , string $session_data ) : bool
public bool gc ( int $maxlifetime ) : int // elimină vechile sesiuni
public bool destroy ( string $session_id ) : bool
public bool close ( void ) : bool
}
php.net/manual/en/book.session.php

(în loc de) pauză

Cum pot fi accesate bazele de date din PHP?

php: bd
Suport nativ pentru o multitudine
de servere/tehnologii de baze de date:
MongoDB – clasele MongoDB MongoClient MongoCursor
MySQL / MariaDB – clasa mysqli
PostgreSQL – funcțiile pg_*()
SQLite – clasa SQLite3
etc.
conexiunile pot fi persistente

php: bd – mysql
Funcții/metode pentru acces la MySQL/MariaDB
conectare la server: mysql_connect (), mysql_pconnect ()
selectare (utilizare) bază de date: mysql_select_db ()
execuția unei interogări: mysql_query ()
raportare de erori: mysql_errno (), mysql_error ()
preluarea rezultatelor într-un tablou: mysql_fetch_array ()
multe altele…
actualmente, abordare depreciată – eliminată în PHP 7

php: bd – extensia mysqli
Scop: acces usor și flexibil la MySQL/MariaDB
din programele PHP5+
aborare procedurală sau obiectuală
facilitează mentenabilitatea codului
compatibilitate cu API-ul MySQL
asigură securitatea și performanța
documentații disponibile la www.php.net/mysqli

Metode importante:
inițierea unei conexiuni cu serverul MySQL – mysqli ( )
interogări SQL – query ( ), prepare ( ), execute ( )
procesarea răspunsului – fetch ( ), fetch_assoc ( )
închiderea conexiunii – close ( )
etc.

php: bd – exemplu
Pentru început, vom crea un cont de utilizator MariaDB
care va asigura acces autentificat clienților – în acest caz,
programe PHP – asupra bazei de date students
disponibilă pe serverul MariaDB
(infoiasi)$ mysql -u root -p mysql
Enter password: **********
Welcome to the MariaDB monitor. Commands end with ; or g.
Server version: 10.4.11-MariaDB Source distribution
MariaDB [mysql]> GRANT SELECT, INSERT, UPDATE, DELETE, CREATE,
DROP ON students.* TO 'tux@localhost' IDENTIFIED BY 'p@rola’
WITH GRANT OPTION;
Query OK, 0 rows affected (0.001 sec)

pentru administrare facilă, recurgem la instrumentul Web
Adminer – www.adminer.org
alternativă: phpMyAdmin – www.phpmyadmin.net
vizualizarea/alterarea structurii tabelei create

inserarea de
înregistrări
exportul
datelor

execuția
manuală de
comenzi SQL
istoricul
interogărilor

// instanțiem obiectul mysqli
$mysql = new mysqli ('localhost', 'tux', 'p@r0la', 'students');
if (mysqli_connect_errno ()) {
die ('Conexiunea a eșuat...');
}
// formulăm o interogare și o executăm
if (!($rez = $mysql->query ('select name, year from students'))) {
die ('A survenit o eroare la interogare');
}

// instanțiem obiectul mysqli
$mysql = new mysqli ('localhost', 'tux', 'p@r0la', 'students');
if (mysqli_connect_errno ()) {
die ('Conexiunea a eșuat...');
}
// formulăm o interogare și o executăm
if (!($rez = $mysql->query ('select name, year from students'))) {
die ('A survenit o eroare la interogare');
}
!!!
Parola e dată „în clar”!
atenție la probleme de securitate ce pot surveni

// generăm o listă numerotată cu datele despre studenți
// (cod HTML în stil spaghetti – practică nerecomandată!)
echo ('<ol>');
// rezultatele sunt disponibile într-un tablou asociativ
while ($inreg = $rez->fetch_assoc ()) {
// coloană a tabelei  cheie a tabloului
echo ('<li>Studentul ' . $inreg['name'] .
' este în anul ' . $inreg['year'] . '</li>');
}
echo ('</ol>');
// închidem conexiunea cu serverul MySQL/MariaDB
$mysql->close ();

php: bd
În practică, se recurge la un strat de abstractizare
a accesului la sistemul de stocare
DBAL – DataBase Abstraction Layer
abordare uzuală:
PDO (PHP Data Objects)
aspecte pragmatice în tutorialul phpdelusions.net/pdo

php: bd – extensia pdo
// datele de conectare la serverul de baze de date MySQL/MariaDB
$host = '127.0.0.1';
$db = 'students';
$user = 'tux';
$pass = 'p@r0la'; // atenție: parola e specificată „în clar”!
$charset = 'utf8';
// stabilirea numelui sursei de date: DSN (Data Source Name)
$dsn = "mysql:host=$host;dbname=$db;charset=$charset";
// opțiuni vizând maniera de conectare
$opt = [
// erorile sunt raportate ca excepții
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
// rezultatele vor fi disponibile într-un tablou asociativ
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
// conexiunea e persistentă
PDO::ATTR_PERSISTENT => TRUE
];
php.net/manual/en/book.pdo.php

// preluăm de la clientul Web anul de studii (implicit: 2)
$year = $_REQUEST['year'] ? $_REQUEST['year'] : 2;
try {
$pdo = new PDO ($dsn, $user, $pass, $opt); // instanțiem un obiect PDO
// pregătim comanda SQL parametrizată
$sql = $pdo->prepare ('SELECT year, name, age FROM students
WHERE year=? ORDER BY age');
if ($sql->execute ([ $year ])) { // comanda SQL poate fi executată?
while ($row = $sql->fetch ()) { // ...preluăm fiecare înregistrare găsită
// ...și o afișăm (coloana tabelei e cheie a tabloului asociativ)
echo '<p>' . $row['name'] . ' e în anul ' . $row['year'] . '</p>';
}
}
} catch (PDOException $e) {
echo "Eroare: " . $e->getMessage(); // mesajul excepției survenite
};

Un posibil rezultat oferit de execuția
programului PHP invocat via un URL precum
https://profs.info.uaic.ro/~/busaco/php/pdo-test.php?year=2
Tuxy Pinguinesscool e în anul 2
Grace Hopper e în anul 2
Margaret Hamilton e în anul 2
de studiat exemplul din
arhiva aferentă prelegerii

php: bd
Uzual, peste DBAL se va putea folosi o soluție
(i.e. framework, componentă, bibliotecă,…)
de tip ORM – Object-Relational Mapping
exemple:
Doctrine – www.doctrine-project.org
Propel – propelorm.org
RedBeanPHP – redbeanphp.com
avansat

Instrumente utile pentru dezvoltatorii Web?

instrumente: framework-uri
Facilități:
MV* și diverse șabloane de proiectare
acces la baze de date (ORM, DAO, ActiveRecord,…)
validare și filtrare a datelor de intrare
autentificare + controlul accesului
management de cookie-uri și sesiuni Web
avansat

Facilități:
machete de prezentare a datelor – templating
suport pentru performanță – i.e. caching
transfer asincron de date (Ajax, Web Socket)
suport pentru servicii Web și API-uri REST/GraphQL
extensibilitate – e.g., module create de programator și
gestionate cu utilizatorul Composer
avansat

avansat
fluxuri de activități realizate de un framework Web
routing security appli-
cation
con-
troller
caching view
🗎
program
.php
models
libraries
helpers
plugins
others

CakePHP – cakephp.org
CodeIgniter – codeigniter.com
FuelPHP – fuelphp.com
Laminas (ex-Zend Framework) – docs.laminas.dev
Laravel – laravel.com
Nette – nette.org
Phalcon – phalcon.io
PRADO – www.pradoframework.net
Symfony – symfony.com + Symfony Flex – flex.symfony.com
Yii – www.yiiframework.com
avansat

├───application
│ ├───cache
│ ├───config
│ ├───controllers
│ ├───core
│ ├───helpers
│ ├───language
│ ├───libraries
│ ├───logs
│ ├───models
│ └───views
│ └───errors
│ ├───cli
│ └───html
├───system
│ ├───core
│ ├───database
│ │ └───drivers
│ │ ├───mysqli
│ │ ├───pdo
│ │ ├───...
│ └───libraries
│ ├───Cache
│ ├───Javascript
│ └───Session
└───user_guide
avansat
structura de directoare
a unei aplicații Web dezvoltate
cu un framework axat pe MVC
CodeIgniter
codeigniter.com/docs

avansat
structura de directoare
a unei aplicații Web dezvoltate
via framework-ul Laravel
laravel.com/docs/
laracasts.com/skills/php
├───app
│ ├───Commands
│ ├───Console
│ ├───Events
│ ├───Exceptions
│ ├───Handlers
│ ├───Http
│ ├───Providers
│ ├───Services
│ └───User.php
├───bootstrap
│ ├───app.php
│ └───autoload.php
├───config
├───database
│ ├───migrations
│ └───seeds
├───public
├───resources
│ ├───assets
│ ├───lang
│ └───views
├───server.php
├───storage
└───tests

instrumente: micro-framework-uri
Un micro-framework reprezintă
un cadru de lucru Web minimalist
avansat

Un micro-framework reprezintă
un cadru de lucru Web minimalist
nu include, uzual, facilități sofisticate
deseori, axat asupra unui singur aspect vizând
dezvoltarea Web – e.g., crearea unui API, microserviciu,…
avansat

Fat-Free – fatfreeframework.com
Flight – flightphp.com
Fresh Squeezed Limonade – github.com/yesinteractive/fsl
Leaf PHP – leaf-docs.netlify.com
Lumen – lumen.laravel.com
Slim – www.slimframework.com
Siler – siler.leocavalcante.dev
avansat

instrumente: pachete
Managementul dependențelor
dintre biblioteci și pachete
Composer
getcomposer.org
www.phptherightway.com/#dependency_management
avansat

Meta-datele + dependențele de alte (versiuni de) pachete
sunt specificate în fișierul composer.json
{
"name": "organizație/pachet",
"version": "1.3.74" // versiunea curentă a pachetului
"license": [ "LGPL-2.1-only", "GPL-3.0-or-later" ], // licența de utilizare
"authors": [ { "name": "Tuxy", "role": "Developer" } ], // autor(i)
"require": {
"php" : "^5.5 || ^7.0", // versiunile PHP necesare execuției codului
"spațiu-de-nume/altpachet": "2.0.*", // versiunea dependenței externe
"organizație/pachet2": "*" // alt pachet propriu
},
"repositories": [ // sursa de unde poate fi preluat pachetul
{ "type": "composer", "url": "http://packages.undeva.info" } ]
}
avansat
se recurge la Composer
(alte valori: git, vcs, pear, package)

Pachetele sunt încapsulate în arhive PHAR (PHP Archive) și
pot fi publice/private
avansat

Pachetele sunt încapsulate în arhive PHAR (PHP Archive) și
pot fi publice/private
php composer.phar comandă
unde comandă poate fi:
install – instalare locală/globală inclusiv a dependențelor
update – actualizare de pachete
remove – eliminarea pachetelor
search – căutarea unui pachet
show – afișarea tuturor pachetelor disponibile
depends – afișarea pachetelor ce depind de un pachet specific
help – oferirea de informații de ajutor
…și altele
avansat

Pachetele publice se pot prelua de pe Web de la
Packagist – depozit de pachete (repository)
packagist.org
avansat

Managementul dependențelor
dintre biblioteci și pachete
alternativă – mai veche:
PEAR (PHP Extension and Application Repository)
pear.php.net
+
extensii oferite de terți:
PECL (PHP Extension Community Library)
pecl.php.net
avansat

instrumente: medii de dezvoltare
Medii pre-configurate pentru dezvoltare Web
server Web + PHP + server(e) de baze de date + utilitare

Apache + PHP 7 +
MySQL/MongoDB…
AMPPS
www.ampps.com
XAMPP
www.apachefriends.org
cu suport pentru
diverse configurări
de sisteme Web
(extensii)

Nginx + PHP7 + MariaDB +
Redis + unelte de administrare
WinNMP – winnmp.wtriple.com

instrumente
medii de dezvoltare (și pentru) PHP „în nori”
disponibile direct în navigatorul Web
AWS Cloud9, Codenvy, Koding, REPL.it,…

instrumente: execuție online
editarea și execuția online a programelor PHP
Ideone – ideone.com
PhpFiddle – phpfiddle.org

Editarea și execuția online a programelor PHP
pentru testarea rapidă a codului, a se considera și
PHPTester – phptester.net
PHP Sandbox – sandbox.onlinephpfunctions.com

pentru teste vizând bazele de date relaționale,
de experimentat DB Fiddle – www.db-fiddle.com
și/sau SQL Fiddle – sqlfiddle.com
de studiat și Industry-specific Data Models
www.databaseanswers.org/data_models/
inclusiv SQL Zoo – sqlzoo.net

instrumente: documentare
avansat
Generarea automată a documentației unei aplicații
ApiGen – www.apigen.org
Daux – daux.io
phpDocumentor – www.phpdoc.org
phpDox – phpdox.de
Sami – github.com/FriendsOfPHP/Sami
github.com/ziadoz/awesome-php#documentation

instrumente: documentare
avansat
Marcaje (adnotări) speciale în comentariile PHP:
@author
@category
@version
@copyright
@license
@see
@todo
@since
@deprecated
@var
@global
@method
@package
@subpackage
@param
@return
@throws
@inheritdoc
@example
@source
@uses
@used-by
@link
@internal
@property
@property-read
@property-write
docs.phpdoc.org/references/phpdoc/

instrumente: analiza codului
Analiza statică a codului-sursă PHP
pentru descoperirea de greșeli de programare (bugs),
verificarea adoptării unor stiluri de redactare
(coding standards), corectare automată (fixers),
determinarea de metrici (metrics):
complexitate, linii de cod,…
github.com/exakat/php-static-analysis-tools
avansat

avansat
PHP Standards Recommendations – www.php-fig.org/psr/
redactate de PHP FIG (Framework Interop Group)
PSR1: Basic Coding Standard
PSR2: Coding Style Guide – actualmente învechit
PSR3: Logger Interface
PSR4: Autoloading Standard
PSR6: Caching Interface
PSR7: HTTP Message Interface
PSR12: Extended Coding Style Guide – extinde PSR2
…

avansat
Detected violations with PSR2 standards
FOUND 6 ERROR(S) AFFECTING 4 LINE(S)
----------------------------------------------------------------------
5 | ERROR | Whitespace found at end of line
8 | ERROR | Inline control structures are not allowed
13 | ERROR | Expected 1 blank line at end of file; 0 found
13 | ERROR | A closing tag is not permitted at the end of a PHP file
----------------------------------------------------------------------

instrumente: testare
atoum – atoum.org
Codeception – codeception.com
ParaTest (testare paralelă) – github.com/brianium/paratest
Peridot – peridot-php.github.io
PHPUnit – phpunit.de
SimpleTest – github.com/simpletest/simpletest
altele la github.com/ziadoz/awesome-php#testing
avansat

instrumente: testare
Profiling – analizarea și raportarea
fragmentelor de cod care se execută lent
PhpBench – github.com/phpbench/phpbench
Tracy – tracy.nette.org
Xdebug extension for PHP – xdebug.org/docs/profiler
XHGui (bazat pe XHProf) – github.com/perftools/xhgui
Z-Ray – www.zend.com/en/products/server/z-ray
github.com/ziadoz/awesome-php#debugging-and-profiling
avansat

instrumente: integrare continuă
CircleCI – circleci.com
PHPCI – github.com/dancryer/phpci
Sismo – sismo.symfony.com
github.com/ziadoz/awesome-php#continuous-integration
avansat

instrumente: acceleratoare
Caching pentru fișiere sursă sau opcode-uri + altele
Zend Opcache – integrat în PHP 5.5+
php.net/manual/en/book.opcache.php
de asemenea, de experimentat:
APCu (Alternative PHP Cache + User Cache)
Windows Cache for PHP
avansat

extensii
Hack (Facebook, din 2014)
limbaj de programare pentru HHVM, extinzând PHP
scop: creșterea productivității dezvoltatorului Web
facilități: tipuri de date explicite (type annotations),
generics, expresii λ, programare asincronă (async) și altele
hacklang.org
avansat

critici majore
mulți ani: lipsa unei specificații formale a limbajului
actualmente: github.com/php/php-langspec
inconsistență – e.g., foreach, nume de funcții predefinite
lipsa suportului nativ pentru Unicode (exceptând PHP 7)
lipsa suportului nativ pentru multi-threading,
însă posibil via extensii ca pthreads et al.
eev.ee/blog/2012/04/09/php-a-fractal-of-bad-design/
www.quora.com/Criticism-of-PHP

critici majore
PHP Sadness – phpsadness.com

critici majore
În PHP se pot ușor crea aplicații
ce „adoptă” anti-pattern-ul Spaghetti Code

critici majore
interfața
Web
HTML
PHP pentru acces
la date via SQL
și procesări
PHP pentru
prezentarea datelor
github.com/hanafiah/masterphp/tree/master/spaghetti

studiu de caz: Wikipedia
Jimmy Wales & Larry Sanger (2001)

studiu de caz: wikipedia
Scop: oferirea de conținut deschis
via o suită de aplicații Web colaborative – wiki-uri
Wikipedia Foundation
menține Wikipedia, Wiktionary, Wikibooks, Wikiquote,
Wikivoyage, Wikisource, Wikimedia Commons,
Wikispecies, Wikinews, Wikiversity, Wikidata
en.wikipedia.org/wiki/Wikimedia_Foundation

MediaWiki – sistemul wiki utilizat pentru toate serviciile
implementat în PHP 7.2 + JavaScript
MariaDB (soluția principală de stocare – din 2013)
ImageMagick, DjVu, TeX, rsvg, ploticus etc.
(pentru procesare de conținuturi grafice în MediaWiki)
Apache HTTP Server + Nginx (servere Web)
se oferă inclusiv un API destinat dezvoltatorilor Web:
www.mediawiki.org/wiki/API:Main_page

Varnish (proxy + caching pentru conținut HTML)
Memcached (caching interogări asupra bazelor de date)
Elasticsearch (căutare textuală – implementare Java)
Swift (stocare redundantă distribuită de la OpenStack)
gdnsd (soluție C++ pentru DNS)
Linux Virtual Server – LVS (load balancing)
Debian / Ubuntu Server (sisteme de operare)
Icinga + Grafana (monitorizarea stării sistemelor)
Phabricator (raportarea deficiențelor – bug tracking)
meta.wikimedia.org/wiki/Wikimedia_servers
avansat

studiu de caz: wikimedia
infrastructura
Wikipedia (2015)
avansat

studii de caz
Numeroase situri Web recurg la sisteme de management
al conținutului (CMS – Content Management System)
concepute în PHP
generale:
Drupal, Joomla, WordPress etc.

studii de caz
CMS-urile pot include
extensii + teme vizuale

studii de caz

studii de caz
concepute în PHP
de tip wiki:
DokuWiki, MediaWiki, pmWiki etc.

studii de caz

studii de caz
concepute în PHP
specifice comerțului electronic:
Magento, OpenCart, PrestaShop,…

studii de caz
concepute în PHP
facilitând discuții online (message board, forum Web):
bbPress, esoTalk, phpBB,…

rezumat
privire generală asupra PHP
._ |_ ._
|_)| ||_)
| |
caracterizare, facilități, instrumente, exemple

episodul viitor:
un model de date pentru Web: familia XML
<event uri="https://stagiipebune.ro/">
<name xml:lang="ro">Stagii pe Bune</name>
<year>2020</year>
</event>
<participant>
<name uri="mailto:tux@info.uaic.ro">
Tuxy Pinguinnesscool</name>
<year kind="Bachelor">2</year>
</participant>

Web 2020 04/12: Programare Web – Dezvoltarea aplicaţiilor Web în PHP

More Related Content

What's hot (20)

Similar to Web 2020 04/12: Programare Web – Dezvoltarea aplicaţiilor Web în PHP (20)

More from Sabin Buraga (20)

Web 2020 04/12: Programare Web – Dezvoltarea aplicaţiilor Web în PHP