Curs Web Development
Curs HTML
Curs CSS
Curs Javascript
Curs PHP
Curs Phyton
Curs SQL
Curs SEO

PHP Avansat & Best Practices

Composer & PSR Standards

Composer este managerul de pachete standard pentru PHP, care permite instalarea și actualizarea bibliotecilor externe, precum și autoloading-ul claselor conform standardelor PSR. PSR-urile (PHP Standards Recommendations) definesc bune practici și convenții pentru cod PHP, cum ar fi PSR-1 și PSR-12 pentru standard de codare sau PSR-4 pentru autoloading.

De ce să folosim Composer și PSR?

Exemplu practic Composer

1. Inițializează proiectul cu Composer:

composer init

2. Instalează o librărie, de exemplu Monolog:

composer require monolog/monolog

3. Folosește autoloading-ul PSR-4 în proiect:

<?php
require 'vendor/autoload.php';

use Monolog\Logger;
use Monolog\Handler\StreamHandler;

// Crează un logger
$log = new Logger('aplicatie');
$log->pushHandler(new StreamHandler('app.log', Logger::WARNING));

// Log un mesaj
$log->warning('Aceasta este o avertizare!');
?>

MVC Pattern explicat

MVC (Model-View-Controller) este un pattern de arhitectură care separă responsabilitățile într-o aplicație:

Structura tipică a unui proiect MVC

project/
├── index.php         # Front controller
├── app/
│   ├── Controllers/
│   │   └── UserController.php
│   ├── Models/
│   │   └── User.php
│   └── Views/
│       └── user_list.php
└── vendor/           # Composer autoload

Exemplu practic simplu

Model - User.php

<?php
class User {
    private $users = [
        ['id' => 1, 'name' => 'Ion Popescu'],
        ['id' => 2, 'name' => 'Maria Ionescu']
    ];

    public function getAll() {
        return $this->users;
    }
}
?>

Controller - UserController.php

<?php
require_once 'Models/User.php';

class UserController {
    public function index() {
        $userModel = new User();
        $users = $userModel->getAll();
        include 'Views/user_list.php';
    }
}
?>

View - user_list.php

<?php foreach($users as $user): ?>
    <p>ID: <?php echo $user['id']; ?>, Nume: <?php echo $user['name']; ?></p>
<?php endforeach; ?>

Front Controller - index.php

<?php
require_once 'app/Controllers/UserController.php';

$controller = new UserController();
$controller->index();
?>

Astfel, orice cerere către index.php este direcționată către controller, care preia datele din model și le trimite către view pentru afișare. Acesta este un exemplu simplificat de MVC în PHP.

Unit testing cu PHPUnit

Unit testing reprezintă testarea individuală a funcțiilor sau claselor dintr-un proiect pentru a ne asigura că se comportă corect. PHPUnit este framework-ul standard pentru unit testing în PHP.

Instalare PHPUnit

Se recomandă instalarea prin Composer:

composer require --dev phpunit/phpunit ^10

Structura unui test simplu

project/
├── src/
│   └── Calculator.php
└── tests/
    └── CalculatorTest.php

Exemplu practic - Calculator.php

<?php
class Calculator {
    public function add($a, $b) {
        return $a + $b;
    }

    public function subtract($a, $b) {
        return $a - $b;
    }
}
?>

Exemplu practic - CalculatorTest.php

<?php
use PHPUnit\Framework\TestCase;

require_once __DIR__ . '/../src/Calculator.php';

class CalculatorTest extends TestCase {

    public function testAdd() {
        $calc = new Calculator();
        $this->assertEquals(5, $calc->add(2,3));
    }

    public function testSubtract() {
        $calc = new Calculator();
        $this->assertEquals(1, $calc->subtract(3,2));
    }
}
?>

Rulare teste

După instalarea PHPUnit, rulăm testele din terminal astfel: ./vendor/bin/phpunit tests/CalculatorTest.php Rezultatul va afișa dacă testele au trecut sau au eșuat.

Acest mecanism ne permite să verificăm funcționalități individuale ale codului și să depistăm rapid erorile, ceea ce este esențial pentru proiecte mari sau colaborative.

PHP 8 Features: Match, Nullsafe Operator & Attributes

1. Match Expression

Match este un înlocuitor mai sigur și mai concis pentru switch. Poate returna valori și nu necesită break-uri. 

<?php
$zi = 'marți';

$mesaj = match($zi) {
    'luni' => 'Începe săptămâna!',
    'marți' => 'Zi de muncă',
    'miercuri' => 'Mijlocul săptămânii',
    'joi', 'vineri' => 'Aproape weekend',
    default => 'Weekend',
};

echo $mesaj; // Output: Zi de muncă
?>

2. Nullsafe Operator (??)

Nullsafe operator permite accesarea în siguranță a proprietăților sau metodelor unui obiect care poate fi null, fără a provoca eroare. 

<?php
class User {
    public ?Profile $profile = null;
}

class Profile {
    public string $bio = 'Salut!';
}

$user = new User();

// Acces sigur fără eroare dacă $profile este null
$bio = $user->profile?>bio;

echo $bio; // Output: null
?>

3. Attributes (Anotări)

Attributes permit adăugarea de metadata la clase, metode sau proprietăți, fără a folosi docblocks. 

<?php
#[Attribute]
class ExampleAttribute {
    public function __construct(public string $info) {}
}

#[ExampleAttribute('Acesta este un exemplu')]
class MyClass {}

$reflection = new ReflectionClass(MyClass::class);
$attrs = $reflection->getAttributes();

foreach($attrs as $attr) {
    $instance = $attr->newInstance();
    echo $instance->info; // Output: Acesta este un exemplu
}
?>

Aceste facilități PHP 8 fac codul mai curat, mai sigur și mai expresiv.

Exemplu: Organizarea proiectului cu PSR-4

PSR-4 este standardul pentru autoloading clase în PHP. Permite încărcarea automată a claselor din namespace-uri corespunzătoare structurilor de directoare.

Structura proiectului


my_project/
├─ composer.json
├─ src/
│  ├─ Controllers/
│  │  └─ UserController.php
│  ├─ Models/
│  │  └─ User.php
│  └─ Services/
│     └─ AuthService.php
├─ public/
│  └─ index.php

Exemplu de clasă cu namespace

<?php
namespace App\Models;

class User {
    public string $name;
    public string $email;

    public function __construct(string $name, string $email) {
        $this->name = $name;
        $this->email = $email;
    }
}
?>

Composer & Autoloading PSR-4

În fișierul composer.json, definim autoloading-ul PSR-4: 

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

Apoi rulăm în terminal: composer dump-autoload. În public/index.php, putem folosi clasele direct: 

<?php
require __DIR__ . '/../vendor/autoload.php';

use App\Models\User;

$user = new User('Ion Popescu', 'ion.popescu@example.com');
echo $user->name; // Output: Ion Popescu
?>

Astfel, codul este organizat clar pe namespace-uri, clasele sunt încărcate automat, iar proiectul respectă standardele PSR-4.

Deployment ➔

Top